'use strict';

(function(globalScope, environmentType) {
  
  var Utils = (function() {
    function instanceOf(obj) {
      function testType(obj, _val) {
        function isDeferredType(obj) {
          if (obj instanceof Promise || (obj.constructor && obj.constructor.name === 'Promise'))
            return true;
    
          // Quack quack...
          if (typeof obj.then === 'function' && typeof obj.catch === 'function')
            return true;
    
          return false;
        }
    
        var val     = _val,
            typeOf  = (typeof obj);
    
        if (val === globalScope.String)
          val = 'string';
        else if (val === globalScope.Number)
          val = 'number';
        else if (val === globalScope.Boolean)
          val = 'boolean';
        else if (val === globalScope.Function)
          val = 'function';
        else if (val === globalScope.Array)
          val = 'array';
        else if (val === globalScope.Object)
          val = 'object';
        else if (val === globalScope.Promise)
          val = 'promise';
        else if (val === globalScope.BigInt)
          val = 'bigint';
        else if (val === globalScope.Map)
          val = 'map';
        else if (val === globalScope.WeakMap)
          val = 'weakmap';
        else if (val === globalScope.Set)
          val = 'set';
        else if (val === globalScope.Symbol)
          val = 'symbol';
        else if (val === globalScope.Buffer)
          val = 'buffer';
    
        if (val === 'buffer' && globalScope.Buffer && globalScope.Buffer.isBuffer(obj))
          return true;
    
        if (val === 'number' && (typeOf === 'number' || obj instanceof Number || (obj.constructor && obj.constructor.name === 'Number'))) {
          if (!isFinite(obj))
            return false;
    
          return true;
        }
    
        if (val !== 'object' && val === typeOf)
          return true;
    
        if (val === 'object') {
          if ((obj.constructor === Object.prototype.constructor || (obj.constructor && obj.constructor.name === 'Object')))
            return true;
    
          // Null prototype on object
          if (typeOf === 'object' && !obj.constructor)
            return true;
    
          return false;
        }
    
        if (val === 'array' && (Array.isArray(obj) || obj instanceof Array || (obj.constructor && obj.constructor.name === 'Array')))
          return true;
    
        if ((val === 'promise' || val === 'deferred') && isDeferredType(obj))
          return true;
    
        if (val === 'string' && (obj instanceof globalScope.String || (obj.constructor && obj.constructor.name === 'String')))
          return true;
    
        if (val === 'boolean' && (obj instanceof globalScope.Boolean || (obj.constructor && obj.constructor.name === 'Boolean')))
          return true;
    
        if (val === 'map' && (obj instanceof globalScope.Map || (obj.constructor && obj.constructor.name === 'Map')))
          return true;
    
        if (val === 'weakmap' && (obj instanceof globalScope.WeakMap || (obj.constructor && obj.constructor.name === 'WeakMap')))
          return true;
    
        if (val === 'set' && (obj instanceof globalScope.Set || (obj.constructor && obj.constructor.name === 'Set')))
          return true;
    
        if (val === 'function' && typeOf === 'function')
          return true;
    
        if (typeof val === 'function' && obj instanceof val)
          return true;
    
        if (typeof val === 'string' && obj.constructor && obj.constructor.name === val)
          return true;
    
        return false;
      }
    
      if (obj == null)
        return false;
    
      for (var i = 1, len = arguments.length; i < len; i++) {
        if (testType(obj, arguments[i]) === true)
          return true;
      }
    
      return false;
    }

    function sizeOf(obj) {
      if (obj == null)
        return 0;
    
      if ((typeof obj.length === 'number' || obj.length instanceof Number) && isFinite(obj.length))
        return obj.length;
    
      if (obj.constructor === Object.prototype.constructor || (obj.constructor && obj.constructor.name === 'Object'))
        return (Object.keys(obj).length + Object.getOwnPropertySymbols(obj).length);
    
      if (typeof obj.size === 'number')
        return obj.size;
    
      return 0;
    }

    function isEmpty(value) {
      if (value == null)
        return true;
    
      if (Object.is(value, Infinity))
        return false;
    
      if (Object.is(value, NaN))
        return true;
    
      if (instanceOf(value, 'string'))
        return !(/\S/).test(value);
      else if (instanceOf(value, 'number') && isFinite(value))
        return false;
      else if (!instanceOf(value, 'boolean', 'bigint', 'function') && sizeOf(value) == 0)
        return true;
    
      return false;
    }

    function dataToQueryString(data, nameFormatter, resolveInitial) {
      function fromObject(path, data) {
        let parts = [];
        let keys  = Object.keys(data);
    
        for (let i = 0, il = keys.length; i < il; i++) {
          let key = keys[i];
          let value = data[key];
    
          if (value && typeof value === 'object' && typeof value.valueOf === 'function')
            value = value.valueOf();
    
          if (Array.isArray(value))
            parts = parts.concat(fromArray(`${path}[${key}]`, value));
          else if (value instanceof Object)
            parts = parts.concat(fromObject(`${path}[${key}]`, value));
          else
            parts.push(`${encodeURIComponent(`${path}[${key}]`)}=${encodeURIComponent(value)}`);
        }
    
        return parts.filter(Boolean);
      }
    
      function fromArray(path, data) {
        let parts = [];
    
        for (let i = 0, il = data.length; i < il; i++) {
          let value = data[i];
          if (value && typeof value === 'object' && typeof value.valueOf === 'function')
            value = value.valueOf();
    
          if (Array.isArray(value))
            parts = parts.concat(fromArray(`${path}[]`, value));
          else if (value instanceof Object)
            parts = parts.concat(fromObject(`${path}[]`, value));
          else
            parts.push(`${encodeURIComponent(`${path}[]`)}=${encodeURIComponent(value)}`);
        }
    
        return parts.filter(Boolean);
      }
    
      if (!data || Utils.sizeOf(data) === 0)
        return '';
    
      let initial = '?';
      let parts   = [];
      let keys    = Object.keys(data);
    
      if (resolveInitial != null)
        initial = (typeof resolveInitial === 'function') ? resolveInitial.call(this) : resolveInitial;
    
      for (let i = 0, il = keys.length; i < il; i++) {
        let name  = keys[i];
        let value = data[name];
    
        if (Utils.isEmpty(value))
          continue;
    
        if (value && typeof value === 'object' && typeof value.valueOf === 'function')
          value = value.valueOf();
    
        name = (typeof nameFormatter === 'function') ? nameFormatter.call(this, name, value) : name;
        if (!name)
          continue;
    
        if (Array.isArray(value))
          parts = parts.concat(fromArray(name, value));
        else if (value instanceof Object)
          parts = parts.concat(fromObject(name, value));
        else
          parts.push(encodeURIComponent(name) + '=' + encodeURIComponent(value));
      }
    
      if (parts.length === 0)
        return '';
    
      return initial + parts.join('&');
    }

    function keysToLowerCase(obj) {
      var keys    = Object.keys(obj || {});
      var newObj  = {};

      for (var i = 0, il = keys.length; i < il; i++) {
        var key   = keys[i];
        var value = obj[key];
        newObj[key.toLowerCase()] = value;
      }

      return newObj;
    }

    function cleanObjectProperties(obj) {
      var keys    = Object.keys(obj || {});
      var newObj  = {};

      for (var i = 0, il = keys.length; i < il; i++) {
        var key   = keys[i];
        var value = obj[key];
        if (value == null || value == '')
          continue;

        newObj[key] = value;
      }

      return newObj;
    }

    function injectURLParams(routeName, _options) {
      var options = _options || {};
      var params = options.params || {};

      if (Utils.isEmpty(options.url))
        throw new Error([ 'API::', routeName, ': "url" is required.' ].join(''));

      return options.url.replace(/<<(\w+)(\?)?>>/g, function(m, name, _optional) {
        var optional = (_optional === '?');
        var param = params[name];

        if (Utils.isEmpty(param)) {
          if (!optional)
            throw new Error([ 'API::', routeName, ': Parameter "', name, '" is required. You need to add the following to your call: ', routeName, '({ params: { "', name, '": (value) } })' ].join(''));

          param = '';
        }

        return param;
      });
    }

    return {
      instanceOf,
      sizeOf,
      isEmpty,
      dataToQueryString,
      keysToLowerCase,
      cleanObjectProperties,
      injectURLParams,
    };
  })();


  function generateAPIInterface(globalScope, environmentType) {
      var helpStyles = {
        'error': 'font-weight: 800; color: red;',
        'normal': 'font-weight: 200;',
        'bold': 'font-weight: 800;',
        'boldYellow': 'font-weight: 800; color: yellow;',
      };
  
      const bold = (value) => {
        return '' + value + '';
      };
  
      const orange = (value) => {
        return '' + value + '';
      };
  
      
      function printTable(columns, rows, title, prefix) {
        function print(message) {
          lines.push((prefix || '') + message);
        }
  
        const sanitizeValue = (value) => {
          return ('' + value).replace(/\u001B\[\d+m/g, '');
        };
  
        const findLongestValue = (column) => {
          var maxSize = column.length;
  
          for (var i = 0, il = rows.length; i < il; i++) {
            var row = rows[i];
            if (!row)
              continue;
  
            var value = sanitizeValue('' + row[column]);
            if (value.length > maxSize)
              maxSize = value.length;
          }
  
          return maxSize;
        };
  
        const generateSequence = (size, char) => {
          var array = new Array(size);
          for (var i = 0, il = array.length; i < il; i++)
            array[i] = char;
  
          return array.join('');
        };
  
        const padColumnValue = (_value, columnSize) => {
          var value = sanitizeValue(_value);
          var prefixSize = Math.floor((columnSize - value.length) / 2.0);
          var prefix = generateSequence(prefixSize, ' ');
          var postfix = generateSequence(columnSize - value.length - prefixSize, ' ');
  
          return [ prefix, _value, postfix ].join('');
        };
  
        const capitalize = (value) => {
          return value.replace(/^./, (m) => {
            return m.toUpperCase();
          });
        };
  
        var lines = [];
        var columnSizes = {};
        var columnPadding = 4;
        var totalWidth = columns.length + 1;
  
        var lineChar = '~';
        var sepChar = bold('|');
  
        for (var i = 0, il = columns.length; i < il; i++) {
          var column = columns[i];
          var columnWidth = findLongestValue(column) + (columnPadding * 2);
  
          totalWidth += columnWidth;
  
          columnSizes[column] = columnWidth;
        }
  
        var hrLine = bold(sepChar + generateSequence(totalWidth - 2, lineChar) + sepChar);
        var hrLine2 = columns.map((column) => generateSequence(columnSizes[column], lineChar));
  
        hrLine2 = bold(sepChar + hrLine2.join(sepChar) + sepChar);
  
        if (title) {
          print(hrLine);
          print(sepChar + bold(padColumnValue(title, totalWidth - 2)) + sepChar);
        }
  
        print(hrLine);
  
        var line = [ sepChar ];
        for (var j = 0, jl = columns.length; j < jl; j++) {
          var column = columns[j];
          var columnSize = columnSizes[column];
  
          line.push(bold(padColumnValue(capitalize(column), columnSize)));
  
          line.push(sepChar);
        }
  
        print(line.join(''));
        print(hrLine);
  
        for (var i = 0, il = rows.length; i < il; i++) {
          var row = rows[i];
  
          if (i > 0)
            print(hrLine2);
  
          var line = [ sepChar ];
  
          for (var j = 0, jl = columns.length; j < jl; j++) {
            var column = columns[j];
            var columnSize = columnSizes[column];
            var value = ('' + row[column]);
  
            line.push(padColumnValue(value, columnSize));
  
            line.push(sepChar);
          }
  
          print(line.join(''));
        }
  
        print(hrLine);
  
        console.info(lines.join('\n'));
      }
  
  
      function assignHelp(func, methodName, help) {
        Object.defineProperty(func, 'help', {
          enumerable:   false,
          configurable: false,
          get: () => {
            if (!help || !help.description) {
              console.log('%cNo help found for route "' + methodName + '"', helpStyles.error);
              return;
            }
  
            console.info('%cHelp for %c' + methodName + '%c route:', helpStyles.bold, helpStyles.boldYellow, helpStyles.bold);
            console.info('  %cDescription:%c ' + help.description, helpStyles.bold, helpStyles.normal);
  
            if (!Utils.isEmpty(help.data))
              printTable([ 'property', 'type', 'description', 'required' ], help.data, bold('data: ') + orange('{ data: { ... } }'), '  ');
  
            if (!Utils.isEmpty(help.params))
              printTable([ 'property', 'type', 'description', 'required' ], help.params, bold('parameters: ') + orange('{ params: { ... } }'), '  ');
  
            if (!Utils.isEmpty(help.extra)) {
              for (var i = 0, il = help.extra.length; i < il; i++) {
                var item = help.extra[i];
  
                if (item.type === 'table')
                  printTable(item.columns, item.rows, item.title, '  ');
                else if (item.title)
                  console.log([ '  %c' + item.title + ':%c ', item.description ].join(''), helpStyles.bold, helpStyles.normal);
              }
            }
  
            if (help.example)
              console.info('  %cExample:%c ' + orange(help.example), helpStyles.bold, helpStyles.normal);
  
            if (!Utils.isEmpty(help.notes)) {
              for (var i = 0, il = help.notes.length; i < il; i++) {
                var note = help.notes[i];
                console.log([ '  %cNote ', i + 1, ':%c ', note ].join(''), helpStyles.bold, helpStyles.normal);
              }
            }
          },
          set: () => {},
        });
  
        return func;
      }
  
      function getDefaultHeader(headerName) {
        return apiInterface.defaultHeaders[headerName];
      }
  
      function getDefaultHeaders() {
        return apiInterface.defaultHeaders;
      }
  
      function setDefaultHeader(headerName, value) {
        if (value == null) {
          delete apiInterface.defaultHeaders[headerName];
          return;
        }
  
        apiInterface.defaultHeaders[headerName] = value;
      }
  
      function setDefaultHeaders(headers) {
        var headerNames = Object.keys(headers);
        for (var i = 0, il = headerNames.length; i < il; i++) {
          var headerName  = headerNames[i];
          var value       = headers[headerName];
  
          if (value == null) {
            delete apiInterface.defaultHeaders[headerName];
            continue;
          }
  
          apiInterface.defaultHeaders[headerName] = value;
        }
      }
  
      
  
      function browserRequestHandler(routeName, requestOptions) {
        return new Promise((function(resolve, reject) {
          if (!requestOptions || Utils.isEmpty(requestOptions.url)) {
            reject([ 'API::', routeName, ': "url" is required.' ].join(''));
            return;
          }
      
          var method      = (requestOptions.method || 'GET').toUpperCase();
          var url         = requestOptions.url;
          var data        = requestOptions.data;
          var extraConfig = {};
          var headers     = Object.assign(Utils.keysToLowerCase(this.defaultHeaders || {}), Utils.keysToLowerCase(requestOptions.headers || {}));
          var isFormData  = (data && (data instanceof FormData || data.constructor.name === 'FormData'));
      
          if (data) {
            if (!method.match(/^(GET|HEAD)$/i)) {
              if (isFormData) {
                extraConfig = {
                  body: data,
                };
              } else {
                if ((headers['content-type'] || '').match(/application\/json/i))
                  data = JSON.stringify(data);
      
                extraConfig = {
                  body: data,
                };
              }
            } else {
              var queryString = Utils.dataToQueryString(data);
              if (queryString)
                url = url + queryString;
            }
          }
      
          var options = Object.assign(
            { method },
            requestOptions,
            extraConfig,
            {
              headers: Utils.cleanObjectProperties(Object.assign(
                {},
                headers,
                Utils.keysToLowerCase(extraConfig.headers || {}),
              )),
            },
          );
      
          delete options.data;
          if (isFormData && options.headers)
            delete options.headers['content-type'];
      
          globalScope.fetch(url, Utils.cleanObjectProperties(options)).then(
            async function(response) {
              if (typeof requestOptions.responseHandler === 'function')
                return requestOptions.responseHandler(response);
      
              if (!response.ok || response.statusCode > 399) {
                var error = new Error(response.statusText);
                error.response = response;
      
                reject(error);
                return;
              }
      
              var contentType = response.headers.get('Content-Type');
              let data;
      
              if (contentType && contentType.match(/application\/json/i))
                data = await response.json();
              else if (contentType && contentType.match(/text\/(plain|html)/i))
                data = await response.text();
              else
                data = response.body;
      
              resolve({ response, body: data });
            },
            function(error) {
              reject(error);
            },
          );
        }).bind(this));
      }
  
      function makeRequest(routeName, options) {
        
        return browserRequestHandler.call(this, routeName, options);
        
      }
  
      var apiInterface = Object.create({
        defaultHeaders: {},
        makeRequest,
        getDefaultHeader,
        getDefaultHeaders,
        setDefaultHeader,
        setDefaultHeaders,
      });
  
      var defaultRouteOptions = {};
  
      apiInterface['addAttachmentsToMeeting'] = assignHelp((function addAttachmentsToMeeting(_options) { var clientOptions = {"credentials":"same-origin"}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/add-attachments', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('addAttachmentsToMeeting', options); delete options.params; return makeRequest.call(this, 'addAttachmentsToMeeting', options); }).bind(apiInterface), 'addAttachmentsToMeeting', {"description":"This method will add one or more attachments to the specified meeting. Only 'multipart/form-data' uploads are accepted (FormData).","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to add attachments to","required":true}],"example":"await API.addAttachmentsToMeeting({ data: FormData, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to add attachments to the meeting","FormData containing one or more files is required as the payload","All files contained in the FormData payload MUST have file names attached or the request will fail","Video file types will be uploaded asynchronously to Mux","Attachments for video file types will be returned with a \"status\" of \"pending\"","Video attachments will send out a websocket notification when the video is done uploading to Mux","All non-video attachments will be returned fully-uploaded with the \"status\" of \"ready\""]});
  
      apiInterface['addCollectionUsers'] = assignHelp((function addCollectionUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>/users', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('addCollectionUsers', options); delete options.params; return makeRequest.call(this, 'addCollectionUsers', options); }).bind(apiInterface), 'addCollectionUsers', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['addHighlightTags'] = assignHelp((function addHighlightTags(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/<<meetingHighlightID>>/tags', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('addHighlightTags', options); delete options.params; return makeRequest.call(this, 'addHighlightTags', options); }).bind(apiInterface), 'addHighlightTags', {"description":"This method will add the specified tags to the specified highlight.","data":[{"property":"tags","type":"Array<string>","description":"Tags to add to the specified highlight","required":true}],"params":[{"property":"meetingHighlightID","type":"string","description":"ID of highlight to add tags to","required":true}],"example":"await API.addHighlightTags({ data: { tags: [ 'tag1', 'tag2', 'tag3' ] }, params: { meetingHighlightID: 'some-highlight-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified highlight","Upon success the tags that were added to the highlight are returned","Tags that already existed on the highlight will not be returned... only added tags will be returned","Tags must be only alpha-numeric, plus underscore and hyphen","Any character that isn't alpha-numeric, hyphen, or underscore will be stripped from each tag"]});
  
      apiInterface['addUserTags'] = assignHelp((function addUserTags(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>/tags', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('addUserTags', options); delete options.params; return makeRequest.call(this, 'addUserTags', options); }).bind(apiInterface), 'addUserTags', {"description":"This method will add the specified tags to the specified user.","data":[{"property":"tags","type":"Array<string>","description":"Tags to add to the specified user","required":true}],"params":[{"property":"userID","type":"string","description":"ID of user to add tags to","required":true}],"example":"await API.addUserTags({ data: { tags: [ 'tag1', 'tag2', 'tag3' ] }, params: { userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified user","Upon success the tags that were added to the user are returned","Tags that already existed on the user will not be returned... only added tags will be returned","Tags must be only alpha-numeric, plus underscore and hyphen","Any character that isn't alpha-numeric, hyphen, or underscore will be stripped from each tag"]});
  
      apiInterface['assignAdRole'] = assignHelp((function assignAdRole(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/assign-ad-role', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('assignAdRole', options); delete options.params; return makeRequest.call(this, 'assignAdRole', options); }).bind(apiInterface), 'assignAdRole', {});
  
      apiInterface['assignMeetingActions'] = assignHelp((function assignMeetingActions(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/meeting-actions/assign', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('assignMeetingActions', options); delete options.params; return makeRequest.call(this, 'assignMeetingActions', options); }).bind(apiInterface), 'assignMeetingActions', {"description":"This method will assign the specified Meeting Actions to the specified user. If the provided userID is null, then the specified Meeting Actions will be unassigned from currently assigned users","data":[{"property":"meetingActionIDs","type":"Array<string>","description":"List of valid Meeting Actions IDs","required":true},{"property":"userID","type":"string","description":"User to assign Meeting Actions to. If userID is null, then the Meeting Actions will be \"unclaimed\" (any current users assigned to the Meeting Actions will be removed from the specified actions).","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.assignMeetingActions({ data: { meetingActionIDs: ['meeting-action-id-1', ..., 'meeting-action-id-n'], userID: 'some-user-id' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to assign a meeting action","A user must have been invited to the meeting and have a host or viewer role to be able to claim Meeting Actions","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can claim the meeting actions without the 'host' or 'viewer' roles","The owning user can always \"claim\" or \"unclaim\" Meeting Actions that they own","Upon success the updated Meeting Action ids will be returned as the \"meetingActionIDs\" attribute"]});
  
      apiInterface['assignMeetingHighlights'] = assignHelp((function assignMeetingHighlights(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlights/assign', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('assignMeetingHighlights', options); delete options.params; return makeRequest.call(this, 'assignMeetingHighlights', options); }).bind(apiInterface), 'assignMeetingHighlights', {"description":"This method will assign the specified Meeting Highlights to the specified user. If the provided userID is null, then the specified Meeting Highlights will be unassigned from currently assigned users","data":[{"property":"meetingHighlightIDs","type":"Array<string>","description":"List of valid Meeting Highlights IDs","required":true},{"property":"userID","type":"string","description":"User to assign Meeting Highlights to. If userID is null, then the Meeting Highlights will be \"unclaimed\" (any current users assigned to the Meeting Highlights will be removed from the specified highlights).","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.assignMeetingHighlights({ data: { meetingHighlightIDs: ['meeting-highlight-id-1', ..., 'meeting-highlight-id-n'], userID: 'some-user-id' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to assign a meeting highlight","A user must have been invited to the meeting and have a host or viewer role to be able to claim Meeting Highlights","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can claim the meeting highlights without the 'host' or 'viewer' roles","The owning user can always \"claim\" or \"unclaim\" Meeting Highlights that they own","Upon success the updated Meeting Highlight ids will be returned as the \"meetingHighlightIDs\" attribute"]});
  
      apiInterface['assignSupporterToOrganization'] = assignHelp((function assignSupporterToOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/assign-supporter-to-organization', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('assignSupporterToOrganization', options); delete options.params; return makeRequest.call(this, 'assignSupporterToOrganization', options); }).bind(apiInterface), 'assignSupporterToOrganization', {"description":"This method will assign supporter to specific organization","data":[{"property":"userID","type":"string","description":"ID of user to assign (support)","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.assignSupporterToOrganization({ data: { userID: 'support-user-id' }, params: { organizationID: 'some-organization-id' }  });"});
  
      apiInterface['buildGoogleCalendarOAuthUrl'] = assignHelp((function buildGoogleCalendarOAuthUrl(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendars/connect-google', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('buildGoogleCalendarOAuthUrl', options); delete options.params; return makeRequest.call(this, 'buildGoogleCalendarOAuthUrl', options); }).bind(apiInterface), 'buildGoogleCalendarOAuthUrl', {"description":"This method will create Google OAuth calendar url connection.","example":"await API.buildGoogleCalendarOAuthUrl();"});
  
      apiInterface['buildMicrosoftOutlookOAuthUrl'] = assignHelp((function buildMicrosoftOutlookOAuthUrl(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendars/connect-microsoft', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('buildMicrosoftOutlookOAuthUrl', options); delete options.params; return makeRequest.call(this, 'buildMicrosoftOutlookOAuthUrl', options); }).bind(apiInterface), 'buildMicrosoftOutlookOAuthUrl', {"description":"This method will create Microsoft OAuth calendar url connection.","example":"await API.buildMicrosoftOutlookOAuthUrl();"});
  
      apiInterface['createBot'] = assignHelp((function createBot(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/create', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createBot', options); delete options.params; return makeRequest.call(this, 'createBot', options); }).bind(apiInterface), 'createBot', {"description":"This method will return new created recall bot.","data":[{"property":"meetingUrl","type":"string","description":"Link of the meeting to connect bot","required":true},{"property":"meetingID","type":"string","description":"ID of the meeting to connect bot","required":false},{"property":"meetingTitle","type":"string","description":"Name of the meeting","required":false},{"property":"isMeetingExist","type":"boolean","description":"Is meeting exist to connect bot","required":true},{"property":"botName","type":"string","description":"Name of the bot for this meeting","required":false},{"property":"joinAt","type":"string","description":"ISO date string representing bot joining time","required":false},{"property":"recordingMode","type":"string","description":"Recording Mode of the bot","required":false},{"property":"provider","type":"string","description":"Provider of the bot","required":false},{"property":"word_boost","type":"array","description":"Words Boost of the bot","required":false},{"property":"autoChapters","type":"boolean","description":"Auto chapters is on/off","required":false},{"property":"autoHighlights","type":"boolean","description":"Auto highlights is on/off","required":false},{"property":"filterProfanity","type":"boolean","description":"Filter profanity is on/off","required":false},{"property":"formatText","type":"boolean","description":"Format text is on/off","required":false},{"property":"speakerLabels","type":"boolean","description":"Speaker labels is on/off","required":false},{"property":"iabCategories","type":"boolean","description":"Iab Categories is on/off","required":false},{"property":"entityDetection","type":"boolean","description":"Entity detection is on/off","required":false},{"property":"sentimentAnalysis","type":"boolean","description":"Sentiment analysis is on/off","required":false}],"example":"await API.createBot({});","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['createCollection'] = assignHelp((function createCollection(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createCollection', options); delete options.params; return makeRequest.call(this, 'createCollection', options); }).bind(apiInterface), 'createCollection', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['createEvent'] = assignHelp((function createEvent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/analytics', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createEvent', options); delete options.params; return makeRequest.call(this, 'createEvent', options); }).bind(apiInterface), 'createEvent', {"description":"This method will create a new Analytics Event with the attributes specified.","data":[{"property":"name","type":"string","description":"Name of the event, the name must start with \"reelay.\" and followed by the event type, like \"attachment\" or \"video\".","required":true},{"property":"sourceID","type":"string","description":"ID of the model for which we are capturing data.","required":true},{"property":"targetID","type":"string","description":"ID of the model indicate the kind of data we are capturing, like \"attachment\" or \"video\"","required":false},{"property":"data","type":"string","description":"The event data.","required":true}],"example":"await API.createEvent({ data: { name: 'reelay.video', sourceID: 'some-meeting-ID', targetID: 'some-video-id', data: { 'attributes of the event data' } } });","notes":["BadRequestError will be thrown if the \"name\" doesn't follow specified event naming convention.","Upon success the newly created event will be returned."]});
  
      apiInterface['createMeeting'] = assignHelp((function createMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meetings', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeeting', options); delete options.params; return makeRequest.call(this, 'createMeeting', options); }).bind(apiInterface), 'createMeeting', {"description":"This method will create a new meeting with the attributes specified.","data":[{"property":"name","type":"string","description":"Name of the meeting","required":false},{"property":"objective","type":"string (HTML)","description":"Objective of the meeting. HTML is sanitized server-side.","required":false},{"property":"agenda","type":"string (HTML)","description":"Agenda of the meeting. HTML is sanitized server-side.","required":false},{"property":"summary","type":"string (HTML)","description":"Summary of the meeting. HTML is sanitized server-side.","required":false},{"property":"viewingDeadline","type":"string","description":"ISO date string representing the viewing deadline","required":false}],"example":"await API.createMeeting({ data: { name: 'Test Meeting', objective: '<span>A Test objective</span>' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to create a meeting","A user must have the 'create-meeting' role against the organization to be able to create meetings","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can create meetings without the 'create-meeting' role","No users are invited by default to the meeting created","The creating user will be given the 'host' role against the meeting created","Upon success the newly created meeting will be returned","Meetings have a 'friendlyID' attribute that is generated when the meeting is created. This is a short \"human friendly\" ID that will be sharable/placed into the URL."]});
  
      apiInterface['createMeetingChapter'] = assignHelp((function createMeetingChapter(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chapters', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingChapter', options); delete options.params; return makeRequest.call(this, 'createMeetingChapter', options); }).bind(apiInterface), 'createMeetingChapter', {"description":"This method will create chapter for specified meeting.","data":[{"property":"summary","type":"string","description":"summary of chapter","required":true},{"property":"headline","type":"string","description":"headline of chapter","required":true},{"property":"gist","type":"string","description":"gist of chapter","required":true},{"property":"start","type":"number","description":"start time in ms","required":true},{"property":"end","type":"number","description":"end time in ms","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true}],"example":"await API.createMeetingChapter({ data: { summary: 'Summary of chapter', headline: 'Headline of chapter', gist: 'gist of chapter' start: 90,  end: 1700  }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update meeting"]});
  
      apiInterface['createMeetingComment'] = assignHelp((function createMeetingComment(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/comments', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingComment', options); delete options.params; return makeRequest.call(this, 'createMeetingComment', options); }).bind(apiInterface), 'createMeetingComment', {"description":"This method will create a new comment with the attributes specified.","data":[{"property":"content","type":"string","description":"The content of the comment (the message)","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true}],"example":"await API.createComment({ data: { content: 'New message to send' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to create a comment","A user must be allowed to view the meeting in order to create comments","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can always create comments"]});
  
      apiInterface['createMeetingHighlight'] = assignHelp((function createMeetingHighlight(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlights', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingHighlight', options); delete options.params; return makeRequest.call(this, 'createMeetingHighlight', options); }).bind(apiInterface), 'createMeetingHighlight', {"description":"This method will create a new meeting highlight with the attributes specified.","data":[{"property":"content","type":"string","description":"The content of the highlight","required":true},{"property":"timeStartMS","type":"number","description":"The start time of the highlight in milliseconds (video time)","required":true},{"property":"timeEndMS","type":"number","description":"The end time of the highlight in milliseconds (video time)","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true}],"example":"await API.createMeetingHighlight({ data: { content: 'New content for highlight', timeStartMS: 5000, timeEndMS: 15000, }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to create a meeting highlight","A user must have the 'host' role against the organization to be able to create meeting highlights (or be an admin level user)","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can create meeting highlights without the 'host' role"]});
  
      apiInterface['createMeetingShareableLink'] = assignHelp((function createMeetingShareableLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/shareable-links/<<meetingID>>', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingShareableLink', options); delete options.params; return makeRequest.call(this, 'createMeetingShareableLink', options); }).bind(apiInterface), 'createMeetingShareableLink', {"description":"This method will create shareable link.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true}],"example":"await API.createMeetingShareableLink({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to create shareable link for the specified meeting"]});
  
      apiInterface['createMeetingUserLink'] = assignHelp((function createMeetingUserLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-userlinks', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingUserLink', options); delete options.params; return makeRequest.call(this, 'createMeetingUserLink', options); }).bind(apiInterface), 'createMeetingUserLink', {"description":"This method will create meeting user link as a request to join meeting.","params":[{"property":"userLinkID","type":"string","description":"ID of user link to patch","required":true}],"example":"await API.createUserLink({ params: { userLinkID: 'some-user-link-id' } });","notes":[]});
  
      apiInterface['createMeetingUserLinkWithoutShareableLink'] = assignHelp((function createMeetingUserLinkWithoutShareableLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-userlinks-without-shareable-link', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createMeetingUserLinkWithoutShareableLink', options); delete options.params; return makeRequest.call(this, 'createMeetingUserLinkWithoutShareableLink', options); }).bind(apiInterface), 'createMeetingUserLinkWithoutShareableLink', {"description":"This method will create meeting user link as a request to join meeting.","params":[{"property":"userLinkID","type":"string","description":"ID of user link to patch","required":true}],"example":"await API.createUserLink({ params: { userLinkID: 'some-user-link-id' } });","notes":[]});
  
      apiInterface['createOrganization'] = assignHelp((function createOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organizations', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createOrganization', options); delete options.params; return makeRequest.call(this, 'createOrganization', options); }).bind(apiInterface), 'createOrganization', {"description":"This method will create a new organization with the name specified.","data":[{"property":"name","type":"string","description":"Name of the organization","required":true}],"example":"await API.createOrganization({ data: { name: 'Test Organization' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to create an organization","\"masteradmin\" and \"support\" user roles have permission to create organizations","No users are invited by default to the organization created (not even the calling user)","Upon success the newly created organization will be returned"]});
  
      apiInterface['createTeam'] = assignHelp((function createTeam(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/teams', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('createTeam', options); delete options.params; return makeRequest.call(this, 'createTeam', options); }).bind(apiInterface), 'createTeam', {"description":"This method will create a new team with the attributes specified.","data":[{"property":"name","type":"string","description":"Name of the team","required":true},{"property":"emails","type":"Array<string>","description":"List of user emails to be added to the team. Users must already be members of the organization.","required":false}],"example":"await API.createTeam({ data: { name: 'Test Team', emails: [ 'user1@example.com', 'user2@example.com' ] } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to create a team","A user must have the 'create-meeting' role against the organization to be able to create teams (or be an admin level user)","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can create teams without the 'create-meeting' role","No users are added to the team by default if you don't specify the \"emails\" attribute","The creating user will be given the 'host' role against the meeting created","Upon success the newly created team will be returned, including the users for the team"]});
  
      apiInterface['deleteBot'] = assignHelp((function deleteBot(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/delete', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteBot', options); delete options.params; return makeRequest.call(this, 'deleteBot', options); }).bind(apiInterface), 'deleteBot', {"description":"This method will delete recall bot.","params":[{"property":"botID","type":"string","description":"ID of the bot to delete","required":true}],"example":"await API.deleteBot({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['deleteBotMedia'] = assignHelp((function deleteBotMedia(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/delete-media', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteBotMedia', options); delete options.params; return makeRequest.call(this, 'deleteBotMedia', options); }).bind(apiInterface), 'deleteBotMedia', {"description":"This method will delete recall bot media files.","params":[{"property":"botID","type":"string","description":"ID of the bot to delete media files","required":true}],"example":"await API.deleteBotMedia({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['deleteCollection'] = assignHelp((function deleteCollection(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteCollection', options); delete options.params; return makeRequest.call(this, 'deleteCollection', options); }).bind(apiInterface), 'deleteCollection', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['deleteCollectionContent'] = assignHelp((function deleteCollectionContent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>/content/<<contentID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteCollectionContent', options); delete options.params; return makeRequest.call(this, 'deleteCollectionContent', options); }).bind(apiInterface), 'deleteCollectionContent', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['deleteCollectionUser'] = assignHelp((function deleteCollectionUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>/users/<<userID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteCollectionUser', options); delete options.params; return makeRequest.call(this, 'deleteCollectionUser', options); }).bind(apiInterface), 'deleteCollectionUser', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['deleteMeetingShareableLink'] = assignHelp((function deleteMeetingShareableLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/shareable-links/<<meetingID>>/<<linkID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteMeetingShareableLink', options); delete options.params; return makeRequest.call(this, 'deleteMeetingShareableLink', options); }).bind(apiInterface), 'deleteMeetingShareableLink', {"description":"This method will delete shareable link.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true},{"property":"linkID","type":"string","description":"ID of shareable link","required":true}],"example":"await API.deleteMeetingShareableLink({ params: { meetingID: 'some-meeting-id', linkID: 'some-shareable-link-id'  } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to delete shareable link"]});
  
      apiInterface['deleteOrganizationSettings'] = assignHelp((function deleteOrganizationSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/settings', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteOrganizationSettings', options); delete options.params; return makeRequest.call(this, 'deleteOrganizationSettings', options); }).bind(apiInterface), 'deleteOrganizationSettings', {"description":"This method delete organization settings","query":[{"property":"keys","type":"string","description":"Required settings keys to delete, as \"key1,key2,key3\"","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.getOrganizationSettings({ params: { organizationID }, query: { keys: \"key1,key2,key3\" } });"});
  
      apiInterface['deleteUserSettings'] = assignHelp((function deleteUserSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>/settings', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('deleteUserSettings', options); delete options.params; return makeRequest.call(this, 'deleteUserSettings', options); }).bind(apiInterface), 'deleteUserSettings', {"description":"This method delete user settings","query":[{"property":"keys","type":"string","description":"Required settings keys to delete, as \"key1,key2,key3\"","required":true}],"params":[{"property":"userID","type":"string","description":"ID of user","required":true}],"example":"await API.getUserSettings({ params: { userID }, query: { keys: \"key1,key2,key3\" } });"});
  
      apiInterface['destroyMeetingChapter'] = assignHelp((function destroyMeetingChapter(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chapter/<<chapterID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('destroyMeetingChapter', options); delete options.params; return makeRequest.call(this, 'destroyMeetingChapter', options); }).bind(apiInterface), 'destroyMeetingChapter', {"description":"This method will destroy the specified chapter.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"chapterID","type":"string","description":"ID of the chapter","required":true}],"example":"await API.destroyMeetingChapter({ params: { meetingID: 'some-meeting-id', chapterID: 'some-chapter-id (for example index 0 in chatpers array)' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to destroy the specified chapter","You will recieve status 204 (No content) if chapter was deleted"]});
  
      apiInterface['destroyMeetingComment'] = assignHelp((function destroyMeetingComment(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/comment/<<commentID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('destroyMeetingComment', options); delete options.params; return makeRequest.call(this, 'destroyMeetingComment', options); }).bind(apiInterface), 'destroyMeetingComment', {"description":"This method will destroy the specified comment.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"commentID","type":"string","description":"ID (or friendlyID) of the comment","required":true}],"example":"await API.destroyComment({ params: { meetingID: 'some-meeting-id', commentID: 'some-comment-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to destroy the specified comment","The destroyed comment id will be returned as a response"]});
  
      apiInterface['destroyMeetingHighlights'] = assignHelp((function destroyMeetingHighlights(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlights', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('destroyMeetingHighlights', options); delete options.params; return makeRequest.call(this, 'destroyMeetingHighlights', options); }).bind(apiInterface), 'destroyMeetingHighlights', {"description":"This method will remove one or more Meetinghighlights","data":[{"property":"meetingHighlightIDs","type":"Array<string>","description":"List of meeting Highlight IDs to remove","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.destroyMeetingHighlights({ data: { meetingHighlightIDs: ['some-meeting-highlight-id-1', 'some-meeting-highlight-id-2', 'some-meeting-highlight-id-N'] }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the Meeting Highlights","A 201 status code will be returned if nothing has been modified","The response will include the Meeting Highlight IDs that were actually removed"]});
  
      apiInterface['destroyMeetings'] = assignHelp((function destroyMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meetings', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('destroyMeetings', options); delete options.params; return makeRequest.call(this, 'destroyMeetings', options); }).bind(apiInterface), 'destroyMeetings', {"description":"This method will remove one or more meetings","data":[{"property":"meetingIDs","type":"Array<string>","description":"List of meeting IDs to remove","required":true}],"example":"await API.destroyMeetings({ data: { meetingIDs: ['some-meeting-id-1', 'some-meeting-id-2', 'some-meeting-id-N'] } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the meeting","A 201 status code will be returned if nothing has been modified","The response will include the meeting IDs that were actually removed"]});
  
      apiInterface['destroyTeams'] = assignHelp((function destroyTeams(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/teams', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('destroyTeams', options); delete options.params; return makeRequest.call(this, 'destroyTeams', options); }).bind(apiInterface), 'destroyTeams', {"description":"This method will remove one or more Teams","data":[{"property":"teamIDs","type":"Array<string>","description":"List of Team IDs to remove","required":true}],"example":"await API.destroyTeams({ data: { teamIDs: ['some-team-id-1', 'some-team-id-2', 'some-team-id-N'] } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the Teams","A 201 status code will be returned if nothing has been modified","The response will include the Team IDs that were actually removed"]});
  
      apiInterface['ensureCustomRolesExist'] = assignHelp((function ensureCustomRolesExist(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/ensure-custom-roles-exist', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('ensureCustomRolesExist', options); delete options.params; return makeRequest.call(this, 'ensureCustomRolesExist', options); }).bind(apiInterface), 'ensureCustomRolesExist', {});
  
      apiInterface['findAllForOrganization'] = assignHelp((function findAllForOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/find', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('findAllForOrganization', options); delete options.params; return makeRequest.call(this, 'findAllForOrganization', options); }).bind(apiInterface), 'findAllForOrganization', {"description":"This method search for all data matching the provided search term in the organization specified.","data":[{"property":"search","type":"string","description":"Search term","required":true},{"property":"words","type":"boolean","description":"If true, then split the search term into individual words","required":false}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to find data in","required":true}],"example":"await API.findAllForOrganization({ data: { search: 'test', words: false }, params: { organizationID: 'some-organization-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to interact with the organization","The \"words\" parameter, if \"true\" will split the provided search term into individual words, and search on each word, instead of searching against the entire search term"]});
  
      apiInterface['generateMicrosoftOAuthURL'] = assignHelp((function generateMicrosoftOAuthURL(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/microsoft-oauth-url', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('generateMicrosoftOAuthURL', options); delete options.params; return makeRequest.call(this, 'generateMicrosoftOAuthURL', options); }).bind(apiInterface), 'generateMicrosoftOAuthURL', {});
  
      apiInterface['generateTranscript'] = assignHelp((function generateTranscript(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/generate-transcript', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('generateTranscript', options); delete options.params; return makeRequest.call(this, 'generateTranscript', options); }).bind(apiInterface), 'generateTranscript', {"description":"This method will generate a transcript for the specified meeting.","params":["meetingID"],"example":"await API.generateTranscript();","notes":[]});
  
      apiInterface['generateZoomOAuthURL'] = assignHelp((function generateZoomOAuthURL(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/zoom-oauth-url', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('generateZoomOAuthURL', options); delete options.params; return makeRequest.call(this, 'generateZoomOAuthURL', options); }).bind(apiInterface), 'generateZoomOAuthURL', {});
  
      apiInterface['getAllLiveMeetings'] = assignHelp((function getAllLiveMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/all-live-meetings', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getAllLiveMeetings', options); delete options.params; return makeRequest.call(this, 'getAllLiveMeetings', options); }).bind(apiInterface), 'getAllLiveMeetings', {"description":"This method will search list bots.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{fieldName})","required":false}],"example":"await API.searchBots();","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['getAttachmentsForMeeting'] = assignHelp((function getAttachmentsForMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/get-attachments', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getAttachmentsForMeeting', options); delete options.params; return makeRequest.call(this, 'getAttachmentsForMeeting', options); }).bind(apiInterface), 'getAttachmentsForMeeting', {"description":"This method will get the attachments for the specified meeting.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.getAttachmentsForMeeting({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to view the meeting"]});
  
      apiInterface['getBotTranscript'] = assignHelp((function getBotTranscript(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/transcript', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getBotTranscript', options); delete options.params; return makeRequest.call(this, 'getBotTranscript', options); }).bind(apiInterface), 'getBotTranscript', {"description":"This method will get bot transcript.","params":[{"property":"botID","type":"string","description":"ID of the bot to get transcript","required":true}],"example":"await API.getBotTranscript({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['getCalendarEvents'] = assignHelp((function getCalendarEvents(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendar/<<calendarID>>/events', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getCalendarEvents', options); delete options.params; return makeRequest.call(this, 'getCalendarEvents', options); }).bind(apiInterface), 'getCalendarEvents', {"description":"This method will return list of events by specified calendarID.","params":[{"property":"calendarID","type":"string","description":"calendarID","required":true}],"example":"await API.getCalendarEvents({ params: { calendarID: 'some-calendar-id' } });"});
  
      apiInterface['getChaptersForMeeting'] = assignHelp((function getChaptersForMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chapters', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getChaptersForMeeting', options); delete options.params; return makeRequest.call(this, 'getChaptersForMeeting', options); }).bind(apiInterface), 'getChaptersForMeeting', {"description":"This method will return the chapters for the meeting (if available).","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.getChaptersForMeeting({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to view the meeting","A 404 status code will be returned if no chapters is available"]});
  
      apiInterface['getChatForMeeting'] = assignHelp((function getChatForMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chat', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getChatForMeeting', options); delete options.params; return makeRequest.call(this, 'getChatForMeeting', options); }).bind(apiInterface), 'getChatForMeeting', {"description":"This method will return the recallai meeting chat for the meeting (if available).","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.getChatForMeeting({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to view the meeting","A 404 status code will be returned if no getChatForMeeting is available"]});
  
      apiInterface['getCollection'] = assignHelp((function getCollection(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getCollection', options); delete options.params; return makeRequest.call(this, 'getCollection', options); }).bind(apiInterface), 'getCollection', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['getCollectionContent'] = assignHelp((function getCollectionContent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>/users', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getCollectionContent', options); delete options.params; return makeRequest.call(this, 'getCollectionContent', options); }).bind(apiInterface), 'getCollectionContent', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['getCurrentUser'] = assignHelp((function getCurrentUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getCurrentUser', options); delete options.params; return makeRequest.call(this, 'getCurrentUser', options); }).bind(apiInterface), 'getCurrentUser', {"description":"This method will return the user data for the currently logged in user.","example":"await API.getCurrentUser();","notes":["There must be a valid user session for this method to work (specified as a cookie, or an \"Authorization\" header)","The user's current organizationID will be returned as the attribute \"currentOrganizationID\" in the response payload","An organizationID is not required for this endpoint, but can be optionally provided.","If an organizationID can not be found, and was not provided, then the user's \"first\" organizationID will be returned","A user's \"first\" organization is the first organization queried, ordering user organizations by \"name ASC\""]});
  
      apiInterface['getGroupsMicrosoft'] = assignHelp((function getGroupsMicrosoft(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/get-microsoft-groups', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getGroupsMicrosoft', options); delete options.params; return makeRequest.call(this, 'getGroupsMicrosoft', options); }).bind(apiInterface), 'getGroupsMicrosoft', {});
  
      apiInterface['getImageUploadLink'] = assignHelp((function getImageUploadLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/get-image-upload-link', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getImageUploadLink', options); delete options.params; return makeRequest.call(this, 'getImageUploadLink', options); }).bind(apiInterface), 'getImageUploadLink', {});
  
      apiInterface['getLiveMeetings'] = assignHelp((function getLiveMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/live-meetings', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getLiveMeetings', options); delete options.params; return makeRequest.call(this, 'getLiveMeetings', options); }).bind(apiInterface), 'getLiveMeetings', {"description":"This method will search list bots.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{fieldName})","required":false}],"example":"await API.searchBots();","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['getMeeting'] = assignHelp((function getMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeeting', options); delete options.params; return makeRequest.call(this, 'getMeeting', options); }).bind(apiInterface), 'getMeeting', {"description":"This method will return the specified meeting data.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true}],"example":"await API.getMeeting({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified meeting","You can also fetch a meeting by its 'friendlyID', just set the \"meetingID\" param to the 'friendlyID' of the meeting"]});
  
      apiInterface['getMeetingActionsAssigneeOrNot'] = assignHelp((function getMeetingActionsAssigneeOrNot(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-actions-assignee', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingActionsAssigneeOrNot', options); delete options.params; return makeRequest.call(this, 'getMeetingActionsAssigneeOrNot', options); }).bind(apiInterface), 'getMeetingActionsAssigneeOrNot', {"description":"This method will search the meeting actions for the meeting IDs specified","data":[{"property":"isAssignee","type":"boolean","description":"Get list for assignee User or not","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false}],"example":"await API.searchMeetingActions({ data: { isAssignee: true }, limit: 20, offset: 0 } });"});
  
      apiInterface['getMeetingActionsByStatus'] = assignHelp((function getMeetingActionsByStatus(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-actions-status', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingActionsByStatus', options); delete options.params; return makeRequest.call(this, 'getMeetingActionsByStatus', options); }).bind(apiInterface), 'getMeetingActionsByStatus', {"description":"This method will search the meeting actions for the meeting IDs specified","data":[{"property":"isAssignee","type":"boolean","description":"Get list for assignee User or not","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false}],"example":"await API.searchMeetingActions({ data: { isAssignee: true }, limit: 20, offset: 0 } });"});
  
      apiInterface['getMeetingAnalytics'] = assignHelp((function getMeetingAnalytics(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/analytics', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingAnalytics', options); delete options.params; return makeRequest.call(this, 'getMeetingAnalytics', options); }).bind(apiInterface), 'getMeetingAnalytics', {"description":"This method will return the specified meeting analytics data.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to get analytics data","required":true}],"example":"await API.getMeetingAnalytics({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified meeting","You can also fetch a meeting by its 'friendlyID', just set the \"meetingID\" param to the 'friendlyID' of the meeting"]});
  
      apiInterface['getMeetingComment'] = assignHelp((function getMeetingComment(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/comment/<<commentID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingComment', options); delete options.params; return makeRequest.call(this, 'getMeetingComment', options); }).bind(apiInterface), 'getMeetingComment', {"description":"This method will return the specified comment.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"commentID","type":"string","description":"ID (or friendlyID) of the comment","required":true}],"example":"await API.getComment({ params: { meetingID: 'some-meeting-id', commentID: 'some-comment-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified comment"]});
  
      apiInterface['getMeetingComments'] = assignHelp((function getMeetingComments(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/comments', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingComments', options); delete options.params; return makeRequest.call(this, 'getMeetingComments', options); }).bind(apiInterface), 'getMeetingComments', {"description":"This method will list all comments for the meeting specified.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true}],"example":"await API.getComments({ data: { limit: 20, offset: 0, order: \"-Comment:createdAt\" }, params: { meetingID: 'some-meeting-id' } });","notes":["The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Comment:createdAt\" } (DESC)\n    Example 2: { order: \"+Comment:createdAt\" } (ASC)"]});
  
      apiInterface['getMeetingExternalUsers'] = assignHelp((function getMeetingExternalUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/external-users', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingExternalUsers', options); delete options.params; return makeRequest.call(this, 'getMeetingExternalUsers', options); }).bind(apiInterface), 'getMeetingExternalUsers', {"description":"This method will return the specified meeting external users.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to get external users","required":true}],"example":"await API.getMeetingExternalUsers({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified meeting","You can also fetch a meeting by its 'friendlyID', just set the \"meetingID\" param to the 'friendlyID' of the meeting"]});
  
      apiInterface['getMeetingHighlight'] = assignHelp((function getMeetingHighlight(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlight/<<meetingHighlightID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingHighlight', options); delete options.params; return makeRequest.call(this, 'getMeetingHighlight', options); }).bind(apiInterface), 'getMeetingHighlight', {"description":"This method will return the specified meeting highlight.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"meetingHighlightID","type":"string","description":"ID (or friendlyID) of the meeting highlight","required":true}],"example":"await API.getMeetingHighlight({ params: { meetingID: 'some-meeting-id', meetingHighlightID: 'some-meeting-highlight-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified meeting highlight"]});
  
      apiInterface['getMeetingHighlights'] = assignHelp((function getMeetingHighlights(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-highlights', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingHighlights', options); delete options.params; return makeRequest.call(this, 'getMeetingHighlights', options); }).bind(apiInterface), 'getMeetingHighlights', {"description":"This method will get the meeting highlights for the meeting IDs specified","data":[{"property":"meetingIDs","type":"Array","description":"Meeting IDs to fetch highlights for","required":true},{"property":"filter","type":"Object","description":"Filter properties","required":false},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{fieldName})","required":false}],"extra":[{"type":"table","title":"Meeting highlight fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Some Meeting\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Some Meeting\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Meeting%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Meeting%\" }"}]}],"example":"await API.getMeetingHighlights({ data: { meetingIDs: [ 'some-meeting-id1', 'some-meeting-id2' ], filter: { highlights: { content: \"My Action\" }, users: { 'firstName*': '%Bob%' } }, limit: 20, offset: 0, order: '-MeetingAction:createdAt' } });","notes":["The target organization defaults to the calling users current organization, but can be specified as the \"filter.organizationID\" if a masteradmin or support user","Only meeting actions you have permission to view will be returned","The \"filter\" property can contain any of the fields for meeting actions","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on meeting highlight fields you can postfix the field name with an operator... for example: \"createdAt>=\": \"2001-01-01\" to find meetings created on or after 2001-01-01","Pay attention to the table containing a list of usable operators for meeting highlight fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"description\": \"Meeting\", \"createdAt>=\": \"2001-01-01\" }, { \"createdAt>=\": \"2001-01-01\" } ]\n    would result in ((description = 'Meeting' AND createdAt >= '2001-01-01') OR (createdAt >= '2001-01-01'))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-MeetingAction:createdAt\" } (DESC)\n    Example 2: { order: \"+MeetingAction:createdAt\" } (ASC)","The \"filter\" object, if used, must be supplied sub-scopes \"actions\" and \"users\" to target the filter params to the correct model"]});
  
      apiInterface['getMeetingInvitedUsers'] = assignHelp((function getMeetingInvitedUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/invited-users', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingInvitedUsers', options); delete options.params; return makeRequest.call(this, 'getMeetingInvitedUsers', options); }).bind(apiInterface), 'getMeetingInvitedUsers', {"description":"This method will return the specified meeting invited users.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to get invited users","required":true}],"example":"await API.getMeetingInvitedUsers({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified meeting","You can also fetch a meeting by its 'friendlyID', just set the \"meetingID\" param to the 'friendlyID' of the meeting"]});
  
      apiInterface['getMeetingShareableLink'] = assignHelp((function getMeetingShareableLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/shareable-links/slug/<<slug>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetingShareableLink', options); delete options.params; return makeRequest.call(this, 'getMeetingShareableLink', options); }).bind(apiInterface), 'getMeetingShareableLink', {"description":"This method will return shareable link data by its slug","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true},{"property":"slug","type":"string","description":"slug of shareable link","required":true}],"example":"await API.getMeetingShareableLinkBySlug({ params: { meetingID: 'some-meeting-id', slug: 'some-shareable-link-slug'  } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update shareable link"]});
  
      apiInterface['getMeetings'] = assignHelp((function getMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meetings', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getMeetings', options); delete options.params; return makeRequest.call(this, 'getMeetings', options); }).bind(apiInterface), 'getMeetings', {"description":"This method will list all meetings in the organization (for the current user).","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"example":"await API.getMeetings({ data: { limit: 20, offset: 0, order: \"-Meeting:name\" } });","notes":["The target organization is the calling users current organization","Only meetings you have permission to view will be returned","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Meeting:name\" } (DESC)\n    Example 2: { order: \"+Meeting:name\" } (ASC)"]});
  
      apiInterface['getNotesByMeetingID'] = assignHelp((function getNotesByMeetingID(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-highlights-notes', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getNotesByMeetingID', options); delete options.params; return makeRequest.call(this, 'getNotesByMeetingID', options); }).bind(apiInterface), 'getNotesByMeetingID', {"description":"This method will get the meeting highlights with type \"note\" for the meeting IDs specified","data":[{"property":"meetingIDs","type":"Array","description":"Meeting IDs to fetch highlights for","required":true},{"property":"filter","type":"Object","description":"Filter properties","required":false},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{fieldName})","required":false}],"extra":[{"type":"table","title":"Meeting highlight fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Some Meeting\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Some Meeting\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Meeting%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Meeting%\" }"}]}],"example":"await API.getMeetingHighlights({ data: { meetingIDs: [ 'some-meeting-id1', 'some-meeting-id2' ], filter: { highlights: { content: \"My Action\" }, users: { 'firstName*': '%Bob%' } }, limit: 20, offset: 0, order: '-MeetingAction:createdAt' } });","notes":["The target organization defaults to the calling users current organization, but can be specified as the \"filter.organizationID\" if a masteradmin or support user","Only meeting actions you have permission to view will be returned","The \"filter\" property can contain any of the fields for meeting actions","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on meeting highlight fields you can postfix the field name with an operator... for example: \"createdAt>=\": \"2001-01-01\" to find meetings created on or after 2001-01-01","Pay attention to the table containing a list of usable operators for meeting highlight fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"description\": \"Meeting\", \"createdAt>=\": \"2001-01-01\" }, { \"createdAt>=\": \"2001-01-01\" } ]\n    would result in ((description = 'Meeting' AND createdAt >= '2001-01-01') OR (createdAt >= '2001-01-01'))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-MeetingAction:createdAt\" } (DESC)\n    Example 2: { order: \"+MeetingAction:createdAt\" } (ASC)","The \"filter\" object, if used, must be supplied sub-scopes \"actions\" and \"users\" to target the filter params to the correct model"]});
  
      apiInterface['getNotifications'] = assignHelp((function getNotifications(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/notifications', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getNotifications', options); delete options.params; return makeRequest.call(this, 'getNotifications', options); }).bind(apiInterface), 'getNotifications', {"description":"This method will return pending requests for all meetings where user is owner.","params":[],"example":"await API.getMeetingsNotifications();","notes":[]});
  
      apiInterface['getOrganization'] = assignHelp((function getOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getOrganization', options); delete options.params; return makeRequest.call(this, 'getOrganization', options); }).bind(apiInterface), 'getOrganization', {"description":"This method will return the specified organization data.","params":[{"property":"organizationID","type":"string","description":"ID of organization to show","required":true}],"example":"await API.getOrganization({ params: { organizationID: 'some-organization-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified organization"]});
  
      apiInterface['getOrganizationBrand'] = assignHelp((function getOrganizationBrand(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/brand', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getOrganizationBrand', options); delete options.params; return makeRequest.call(this, 'getOrganizationBrand', options); }).bind(apiInterface), 'getOrganizationBrand', {"description":"This method will return organization brand settings","params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.getOrganizationBrand({ params: { organizationID }});"});
  
      apiInterface['getOrganizationSettings'] = assignHelp((function getOrganizationSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/settings', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getOrganizationSettings', options); delete options.params; return makeRequest.call(this, 'getOrganizationSettings', options); }).bind(apiInterface), 'getOrganizationSettings', {"description":"This method will return organization settings","query":[{"property":"keys","type":"string","description":"Optional settings keys to filter, as \"key1,key2,key3\"","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.getOrganizationSettings({ params: { organizationID }, query: { keys: \"key1,key2,key3\" } });"});
  
      apiInterface['getOrganizations'] = assignHelp((function getOrganizations(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organizations', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getOrganizations', options); delete options.params; return makeRequest.call(this, 'getOrganizations', options); }).bind(apiInterface), 'getOrganizations', {"description":"This method will list all organizations.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false},{"property":"userID","type":"string","description":"Get organizations by specific userID","required":false}],"example":"await API.getOrganizations({ data: { limit: 20, offset: 0, order: \"-Organization:name\" } });","notes":["Only organizations you have permission to view will be returned","A user has permission to view an organization if they are a member","\"masteradmin\" and \"support\" user roles have permission to view all organizations","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Organization:name\" } (DESC)\n    Example 2: { order: \"+Organization:name\" } (ASC)"]});
  
      apiInterface['getRolesMicrosoft'] = assignHelp((function getRolesMicrosoft(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/get-microsoft-roles', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getRolesMicrosoft', options); delete options.params; return makeRequest.call(this, 'getRolesMicrosoft', options); }).bind(apiInterface), 'getRolesMicrosoft', {});
  
      apiInterface['getSupportOrganizations'] = assignHelp((function getSupportOrganizations(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/get-support-organizations', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getSupportOrganizations', options); delete options.params; return makeRequest.call(this, 'getSupportOrganizations', options); }).bind(apiInterface), 'getSupportOrganizations', {"description":"This method will return assigned organizations of supporter","data":[{"property":"userID","type":"string","description":"ID of user to assign (support)","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false}],"example":"await API.getSupportOrganizations({ data: { userID: 'support-user-id', limit: 20, offset: 0 } });"});
  
      apiInterface['getSupporters'] = assignHelp((function getSupporters(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/supporters', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getSupporters', options); delete options.params; return makeRequest.call(this, 'getSupporters', options); }).bind(apiInterface), 'getSupporters', {"description":"This method will search across teams and users.","data":[{"property":"filter","type":"Object","description":"Filter properties. Note that this filter, if provided, must contain a \"teams\" and/or \"users\" scope.","required":false},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{name})","required":false}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to search for teams and users in","required":true}],"extra":[{"type":"table","title":"User fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Team Name\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Team Name\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Team 1\", \"Team 2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Team 1\", \"Team 2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Team%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Team%\" }"}]}],"example":"await API.searchTeamsAndUsers({ data: { filter: { teams: { 'name*': '%search term%' }, users: { 'email*': '%search term%' } }, limit: 20, offset: 0, order: [ 'User:firstName', 'User:lastName' ] }, params: { organizationID: 'some-organization-id' } });","notes":["Only teams you have permission to view will be returned","The \"filter.teams\" property can contain any of the fields for teams","The \"filter.users\" property can contain any of the following fields for users: `email`, `firstName`, `lastName`","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on fields you can postfix the field name with an operator... for example: `teams: { \"name*\": \"%Test%\" }` to find teams whose name contains \"Test\"","Pay attention to the table containing a list of usable operators for teams and user fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name*\": \"%Test%\", \"createdAt>\": \"2001-01-01\" }, { \"createdAt>=\": \"2022-01-01\", \"name\": null } ]\n    would result in ((name LIKE '%Bob%' AND createdAt >= '2001-01-01') OR (createdAt >= '2022-01-01' AND name IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Team:name\" } (DESC)\n    Example 2: { order: \"+Team:name\" } (ASC)","The \"filter\" for this endpoint works slightly differently then other filters. It requires a \"teams\" or \"users\" sub-key(s)/scopes if provided. The `teams` scope specifies filter properties for searching teams, and the `users` key should contain filter properties for searching against users. Both can be used at the same time, or one or the other can be specified.","The `limit` and `order` might be a little odd for this endpoint. The limit and order are applied both to the teams and users queries, which are separate. Then the collecting of users for each team is also an extra step. This might mean that your `limit` and `offset` aren't fully respected like you might expect. In short, you might get slightly more data than the provided `limit`. It is recommended that you simply don't supply a limit or offset."]});
  
      apiInterface['getTeam'] = assignHelp((function getTeam(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/team/<<teamID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getTeam', options); delete options.params; return makeRequest.call(this, 'getTeam', options); }).bind(apiInterface), 'getTeam', {"description":"This method will return the specified team.","params":[{"property":"teamID","type":"string","description":"ID of the team to show","required":true}],"example":"await API.getTeam({ params: { teamID: 'some-team-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['getTeams'] = assignHelp((function getTeams(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/teams', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getTeams', options); delete options.params; return makeRequest.call(this, 'getTeams', options); }).bind(apiInterface), 'getTeams', {"description":"This method will list all teams in the organization (for the current user).","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"example":"await API.getTeams({ data: { limit: 20, offset: 0, order: \"-Team:name\" } });","notes":["The target organization is the calling users current organization","Only teams you have permission to view will be returned","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Team:name\" } (DESC)\n    Example 2: { order: \"+Team:name\" } (ASC)","To apply a filter, use \"searchTeams\" instead."]});
  
      apiInterface['getTranscriptionForMeeting'] = assignHelp((function getTranscriptionForMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/transcription', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getTranscriptionForMeeting', options); delete options.params; return makeRequest.call(this, 'getTranscriptionForMeeting', options); }).bind(apiInterface), 'getTranscriptionForMeeting', {"description":"This method will return the transcription for the meeting (if available).","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to remove attachments from","required":true}],"example":"await API.getTranscriptionForMeeting({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to view the meeting","A 404 status code will be returned if no transcription is available"]});
  
      apiInterface['getUpcomingMeetings'] = assignHelp((function getUpcomingMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/upcoming-meetings', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUpcomingMeetings', options); delete options.params; return makeRequest.call(this, 'getUpcomingMeetings', options); }).bind(apiInterface), 'getUpcomingMeetings', {"description":"This method will search the meetings of an organization.","data":[{"property":"filter","type":"Object","description":"Filter properties","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"extra":[{"type":"table","title":"Meeting fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Some Meeting\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Some Meeting\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Meeting%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Meeting%\" }"}]}],"example":"await API.searchMeetings({ data: { filter: { name: \"My Meeting\" }, limit: 20, offset: 0, order: '-Meeting:name' } });","notes":["The target organization is the calling users current organization","Only meetings you have permission to view will be returned","The \"filter\" property can contain any of the fields for meetings","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on meeting fields you can postfix the field name with an operator... for example: \"createdAt>=\": \"2001-01-01\" to find meetings created on or after 2001-01-01","Pay attention to the table containing a list of usable operators for meeting fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name\": \"Meeting\", \"createdAt>=\": \"2001-01-01\" }, { \"createdAt>=\": \"2001-01-01\", \"agenda\": null } ]\n    would result in ((name = 'Meeting' AND createdAt >= '2001-01-01') OR (createdAt >= '2001-01-01' AND agenda IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Meeting:name\" } (DESC)\n    Example 2: { order: \"+Meeting:name\" } (ASC)"]});
  
      apiInterface['getUser'] = assignHelp((function getUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUser', options); delete options.params; return makeRequest.call(this, 'getUser', options); }).bind(apiInterface), 'getUser', {"description":"This method will return the user data for the specified user ID.","params":[{"property":"userID","type":"string","description":"ID of user to fetch","required":true}],"example":"await API.getUser({ params: { userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified user"]});
  
      apiInterface['getUserCalendars'] = assignHelp((function getUserCalendars(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendars/', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUserCalendars', options); delete options.params; return makeRequest.call(this, 'getUserCalendars', options); }).bind(apiInterface), 'getUserCalendars', {"description":"This method will return list of user`s calendars.","data":[{"property":"platform","type":"string","description":"platform value must be either google_calendar or microsoft_outlook","required":false}],"example":"await API.getUserCalendars({ data: { platform: 'google_calendar' } });"});
  
      apiInterface['getUserLink'] = assignHelp((function getUserLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-userlinks/<<userlinkID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUserLink', options); delete options.params; return makeRequest.call(this, 'getUserLink', options); }).bind(apiInterface), 'getUserLink', {"description":"This method return user link to its creator or meeting owner.","params":[{"property":"userLinkID","type":"string","description":"ID of user link to get","required":true}],"example":"await API.getUserLink({ params: { userLinkID: 'some-user-link-id' } });","notes":["User will receive a 403 Forbidden response if they don't have the permission"]});
  
      apiInterface['getUserSettings'] = assignHelp((function getUserSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>/settings', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUserSettings', options); delete options.params; return makeRequest.call(this, 'getUserSettings', options); }).bind(apiInterface), 'getUserSettings', {"description":"This method will return user settings","query":[{"property":"keys","type":"string","description":"Optional settings keys to filter, as \"key1,key2,key3\"","required":true}],"params":[{"property":"userID","type":"string","description":"ID of user","required":true}],"example":"await API.getUserSettings({ params: { userID }, query: { keys: \"key1,key2,key3\" } });"});
  
      apiInterface['getUsers'] = assignHelp((function getUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/users', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('getUsers', options); delete options.params; return makeRequest.call(this, 'getUsers', options); }).bind(apiInterface), 'getUsers', {"description":"This method will list all users in the organization.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"example":"await API.getUsers({ data: { limit: 20, offset: 0, order: \"-User:firstName\" } });","notes":["The target organization is the calling users current organization","Only users you have permission to view will be returned","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-User:firstName\" } (DESC)\n    Example 2: { order: \"+User:firstName\" } (ASC)","Add an \"organizationID\" to the root of the \"filter\" object to filter users by an organization"]});
  
      apiInterface['googleOauthCallback'] = assignHelp((function googleOauthCallback(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendars/google-oauth-callback', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('googleOauthCallback', options); delete options.params; return makeRequest.call(this, 'googleOauthCallback', options); }).bind(apiInterface), 'googleOauthCallback', {"description":"This method is used like callback for Google OAuth calendar connection."});
  
      apiInterface['installZoomApp'] = assignHelp((function installZoomApp(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/install-zoom-app', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('installZoomApp', options); delete options.params; return makeRequest.call(this, 'installZoomApp', options); }).bind(apiInterface), 'installZoomApp', {});
  
      apiInterface['inviteUserToOrganization'] = assignHelp((function inviteUserToOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/invite-user', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('inviteUserToOrganization', options); delete options.params; return makeRequest.call(this, 'inviteUserToOrganization', options); }).bind(apiInterface), 'inviteUserToOrganization', {"description":"This method will invite the specified user to the specified organization.","data":[{"property":"email","type":"string","description":"Email of user to invite","required":true},{"property":"roles","type":"Array<string>","description":"Roles to assign to invited user","required":false}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to invite user to","required":true}],"example":"await API.inviteUserToOrganization({ data: { email: 'some+user+to+invite@example.com', roles: [ 'admin' ] }, params: { organizationID: 'some-organization-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to invite the user to the specified organization","The 'invite-to-organization' role is required to invite a user to an organization, unless the user is permission level 'superadmin' or above","The user does not need to already exist. If they don't already exist, the user will be created via the email provided, and will be sent an invite link to their email"]});
  
      apiInterface['inviteUsersToMeeting'] = assignHelp((function inviteUsersToMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/invite-users', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('inviteUsersToMeeting', options); delete options.params; return makeRequest.call(this, 'inviteUsersToMeeting', options); }).bind(apiInterface), 'inviteUsersToMeeting', {"description":"This method will invite the specified users to the meeting.","data":[{"property":"emails","type":"Array<string>","description":"List of user emails to invite","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to update","required":true}],"example":"await API.inviteUsersToMeeting({ data: { emails: [ 'user1@example.com', 'user2@example.com' ] }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to invite users to the specified meeting","Invited users that aren't currently members of the organization will be invited to the organization automatically","This endpoint is idempotent, meaning it only make changes if something needs to be changed","Users who have already been invited to the meeting will not be re-invited","All notifications will be paused and not sent until this operation completes"]});
  
      apiInterface['listCollections'] = assignHelp((function listCollections(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('listCollections', options); delete options.params; return makeRequest.call(this, 'listCollections', options); }).bind(apiInterface), 'listCollections', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['listMeetingShareableLinks'] = assignHelp((function listMeetingShareableLinks(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/shareable-links/<<meetingID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('listMeetingShareableLinks', options); delete options.params; return makeRequest.call(this, 'listMeetingShareableLinks', options); }).bind(apiInterface), 'listMeetingShareableLinks', {"description":"This method will return list of shareable links for specified meeting.","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true}],"example":"await API.listMeetingShareableLinks({ params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read shareable links of specified meeting"]});
  
      apiInterface['listUserLinks'] = assignHelp((function listUserLinks(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-userlinks', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('listUserLinks', options); delete options.params; return makeRequest.call(this, 'listUserLinks', options); }).bind(apiInterface), 'listUserLinks', {"description":"This method return user list of userlinks to meeting owner or user","params":[],"example":"await API.listUserLink({ } });","notes":[]});
  
      apiInterface['login'] = assignHelp((function login(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/authenticate', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('login', options); delete options.params; return makeRequest.call(this, 'login', options); }).bind(apiInterface), 'login', {"description":"This method will log a user in.","data":[{"property":"magicToken","type":"string","description":"Magic token","required":true}],"example":"await API.login({ data: { magicToken: 'Some Token' } });","notes":["Upon success, if MFA is enabled for the user, an MFA page url will be returned","Upon success, a cookie named \"reelay-auth-token\" will be set to authenticate the user","Upon success, a cookie named \"reelay-refresh-token\" will be set to authenticate the user","Upon success, the session token will be returned","Upon success, the refresh token will be returned"]});
  
      apiInterface['loginByMicrosoft'] = assignHelp((function loginByMicrosoft(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/authenticate-microsoft', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('loginByMicrosoft', options); delete options.params; return makeRequest.call(this, 'loginByMicrosoft', options); }).bind(apiInterface), 'loginByMicrosoft', {"description":"This method will log a user in via Microsoft.","data":[{"property":"code","type":"string","description":"Authorization code from microsoft","required":true}],"example":"await API.loginByMicrosoft({ data: { code: 'Some Code' } });"});
  
      apiInterface['loginByZoom'] = assignHelp((function loginByZoom(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/authenticate-zoom-client', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('loginByZoom', options); delete options.params; return makeRequest.call(this, 'loginByZoom', options); }).bind(apiInterface), 'loginByZoom', {});
  
      apiInterface['loginWithTheCode'] = assignHelp((function loginWithTheCode(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/authenticate-code', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('loginWithTheCode', options); delete options.params; return makeRequest.call(this, 'loginWithTheCode', options); }).bind(apiInterface), 'loginWithTheCode', {"description":"This method will log a user in.","data":[{"property":"code","type":"string","description":"Auth code","required":true},{"property":"email","type":"string","description":"Email address of user","required":true}],"example":"await API.authenticateWithTheCode({ data: { code: 'Some Code' } });","notes":["Upon success, a cookie named \"reelay-auth-token\" will be set to authenticate the user","Upon success, the session token will be returned"]});
  
      apiInterface['logout'] = assignHelp((function logout(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/logout', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('logout', options); delete options.params; return makeRequest.call(this, 'logout', options); }).bind(apiInterface), 'logout', {"description":"This method will log the user out, invalidating their current session token.","example":"await API.logout();","notes":["Upon success, a 200 status code will be returned, and the cookie named \"reelay-auth-token\" will be set to to \"null\" and the \"maxAge\" will be set to \"0\", causing the cookie to be deleted.","If the user session couldn't be found (i.e. the user is not logged in), then a 201 response code will be returned and nothing will have been modified."]});
  
      apiInterface['markMeetingActions'] = assignHelp((function markMeetingActions(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/meeting-actions/mark', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('markMeetingActions', options); delete options.params; return makeRequest.call(this, 'markMeetingActions', options); }).bind(apiInterface), 'markMeetingActions', {"description":"This method will mark the specified Meeting Actions either as \"todo\" or \"in_progress\" or \"done\".","data":[{"property":"meetingActionIDs","type":"Array<string>","description":"List of valid Meeting Actions IDs","required":true},{"property":"actionableStatus","type":"string","description":"The actionableStatus to set the meeting actions to. Must be one of \"todo\" or \"in_progress\" or \"done\".","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.markMeetingActions({ data: { meetingActionIDs: ['meeting-action-id-1', ..., 'meeting-action-id-n'], actionableStatus: 'done' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to mark a meeting action","A user must have been invited to the meeting and have a host or viewer role to be able to mark Meeting Actions","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can mark the meeting actions without the 'host' or 'viewer' roles","The assigned user can always \"mark\" or \"unmark\" Meeting Actions that are assigned to them","Upon success the updated Meeting Action ids will be returned as the \"meetingActionIDs\" attribute"]});
  
      apiInterface['markMeetingHighlights'] = assignHelp((function markMeetingHighlights(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlights/mark', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('markMeetingHighlights', options); delete options.params; return makeRequest.call(this, 'markMeetingHighlights', options); }).bind(apiInterface), 'markMeetingHighlights', {"description":"This method will mark the specified Meeting Highlights either as \"done\" or \"open\" (not done).","data":[{"property":"meetingHighlightIDs","type":"Array<string>","description":"List of valid Meeting Highlights IDs","required":true},{"property":"status","type":"string","description":"The status to set the meeting highlights to. Must be one of \"open\" or \"done\".","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.markMeetingHighlights({ data: { meetingHighlightIDs: ['meeting-highlight-id-1', ..., 'meeting-highlight-id-n'], status: 'done' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to mark a meeting highlight","A user must have been invited to the meeting and have a host or viewer role to be able to mark Meeting Highlights","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can mark the meeting highlights without the 'host' or 'viewer' roles","The assigned user can always \"mark\" or \"unmark\" Meeting Highlights that are assigned to them","Upon success the updated Meeting Highlight ids will be returned as the \"meetingHighlightIDs\" attribute"]});
  
      apiInterface['microsoftOauthCallback'] = assignHelp((function microsoftOauthCallback(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendars/microsoft-oauth-callback', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('microsoftOauthCallback', options); delete options.params; return makeRequest.call(this, 'microsoftOauthCallback', options); }).bind(apiInterface), 'microsoftOauthCallback', {"description":"This method is used like callback for Microsoft OAuth calendar connection."});
  
      apiInterface['patchCollection'] = assignHelp((function patchCollection(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('patchCollection', options); delete options.params; return makeRequest.call(this, 'patchCollection', options); }).bind(apiInterface), 'patchCollection', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['pauseRecording'] = assignHelp((function pauseRecording(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/pause-recording', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('pauseRecording', options); delete options.params; return makeRequest.call(this, 'pauseRecording', options); }).bind(apiInterface), 'pauseRecording', {});
  
      apiInterface['putCollectionContent'] = assignHelp((function putCollectionContent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/collections/<<collectionID>>/content', method: 'PUT' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('putCollectionContent', options); delete options.params; return makeRequest.call(this, 'putCollectionContent', options); }).bind(apiInterface), 'putCollectionContent', {"description":"This method will return list of meeting collections","example":"await API.listCollections();","notes":[]});
  
      apiInterface['refresh'] = assignHelp((function refresh(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/refresh', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('refresh', options); delete options.params; return makeRequest.call(this, 'refresh', options); }).bind(apiInterface), 'refresh', {"description":"This method will refresh sessionToken and return new pair of session and refresh tokens.","example":"await API.refresh();","notes":["Upon success, a cookie named \"reelay-auth-token\" will be set to authenticate the user","Upon success, a cookie named \"reelay-refresh-token\" will be set to authenticate the user","Upon success, the session token will be returned","Upon success, the refresh token will be returned"]});
  
      apiInterface['registerUser'] = assignHelp((function registerUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/register-user', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('registerUser', options); delete options.params; return makeRequest.call(this, 'registerUser', options); }).bind(apiInterface), 'registerUser', {"description":"This method will create a new user and email them a magic login link.","data":[{"property":"email","type":"string","description":"Email address of user","required":true},{"property":"firstName","type":"string","description":"First name of the user","required":false},{"property":"lastName","type":"string","description":"Last name of the user","required":false},{"property":"phone","type":"string","description":"Phone number for the user","required":false},{"property":"dob","type":"string","description":"Date of birth for the user (format yyyy-MM-dd)","required":false}],"example":"await API.registerUser({ data: { email: 'some+user@example.com', firstName: 'Test', lastName: 'User' } });","notes":["Upon success, the specified users data is returned","For security reasons, if the user specified already exists, then a 400 bad request will be returned instead of the users data"]});
  
      apiInterface['remindMeetingActions'] = assignHelp((function remindMeetingActions(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/meeting-actions/remind', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('remindMeetingActions', options); delete options.params; return makeRequest.call(this, 'remindMeetingActions', options); }).bind(apiInterface), 'remindMeetingActions', {"description":"This method will mark the specified Meeting Actions either as \"todo\" or \"in_progress\" or \"done\".","data":[{"property":"meetingActionIDs","type":"Array<string>","description":"List of valid Meeting Actions IDs","required":true},{"property":"actionableStatus","type":"string","description":"The actionableStatus to set the meeting actions to. Must be one of \"todo\" or \"in_progress\" or \"done\".","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting","required":true}],"example":"await API.markMeetingActions({ data: { meetingActionIDs: ['meeting-action-id-1', ..., 'meeting-action-id-n'], actionableStatus: 'done' }, params: { meetingID: 'some-meeting-id' } });","notes":["A 403 Forbidden response will be returned if the calling user doesn't have the permission level needed to mark a meeting action","A user must have been invited to the meeting and have a host or viewer role to be able to mark Meeting Actions","'masteradmin', 'support', 'superadmin', and 'admin' users of an organization can mark the meeting actions without the 'host' or 'viewer' roles","The assigned user can always \"mark\" or \"unmark\" Meeting Actions that are assigned to them","Upon success the updated Meeting Action ids will be returned as the \"meetingActionIDs\" attribute"]});
  
      apiInterface['removeAttachmentsFromMeeting'] = assignHelp((function removeAttachmentsFromMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/remove-attachments', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeAttachmentsFromMeeting', options); delete options.params; return makeRequest.call(this, 'removeAttachmentsFromMeeting', options); }).bind(apiInterface), 'removeAttachmentsFromMeeting', {"description":"This method will remove one or more attachments from the specified meeting.","data":[{"property":"attachmentIDs","type":"Array<string>","description":"List of attachment IDs to remove from the meeting","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to remove attachments from","required":true}],"example":"await API.removeAttachmentsFromMeeting({ data: { attachmentIDs: [ 'meeting-attachment-id-1', 'meeting-attachment-id-2' ] }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove attachments from the meeting","A 201 status code will be returned if nothing has been modified","The response will include the attachment IDs that were actually removed","The server will ensure all attachment ids are for the meeting specified. Any attachment IDs that aren't bound to the specified meeting will be silently ignored."]});
  
      apiInterface['removeBotFromCalendarEvent'] = assignHelp((function removeBotFromCalendarEvent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendar/<<calendarID>>/remove-bot', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeBotFromCalendarEvent', options); delete options.params; return makeRequest.call(this, 'removeBotFromCalendarEvent', options); }).bind(apiInterface), 'removeBotFromCalendarEvent', {"description":"This method will remove scheduled bot from calendar event","data":[{"property":"recallEventID","type":"string","description":"recallEventID","required":true}],"params":[{"property":"calendarID","type":"string","description":"calendarID","required":true}],"example":"await API.removeBotFromCalendarEvent({ data: { recallEventID: 'some-recall-event-id' }  params: { calendarID: 'some-calendar-id' } });"});
  
      apiInterface['removeBotFromCall'] = assignHelp((function removeBotFromCall(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/remove-from-call', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeBotFromCall', options); delete options.params; return makeRequest.call(this, 'removeBotFromCall', options); }).bind(apiInterface), 'removeBotFromCall', {"description":"This method will remove Bot from call recall bot.","params":[{"property":"botID","type":"string","description":"ID of the bot to remove from call","required":true}],"example":"await API.removeBotFromCall({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['removeCalendar'] = assignHelp((function removeCalendar(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendar/<<calendarID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeCalendar', options); delete options.params; return makeRequest.call(this, 'removeCalendar', options); }).bind(apiInterface), 'removeCalendar', {"description":"This method will remove calendar by specified calendarID","params":[{"property":"calendarID","type":"string","description":"calendarID","required":true}],"example":"await API.removeCalendar({ params: { calendarID: 'some_calendar_id' } });"});
  
      apiInterface['removeHighlightTags'] = assignHelp((function removeHighlightTags(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/<<meetingHighlightID>>/tags', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeHighlightTags', options); delete options.params; return makeRequest.call(this, 'removeHighlightTags', options); }).bind(apiInterface), 'removeHighlightTags', {"description":"This method will remove the specified tags from the specified highlight.","data":[{"property":"tags","type":"Array<string>","description":"Tags to remove from the specified highlight","required":true}],"params":[{"property":"meetingHighlightID","type":"string","description":"ID of highlight to remove tags from","required":true}],"example":"await API.removeHighlightTags({ data: { tags: [ 'tag1', 'tag2', 'tag3' ] }, params: { meetingHighlightID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified highlight","Upon success the remaining tags for the highlight are returned","Tags that don't exist on the highlight will not be ignored","Tags must be only alpha-numeric, plus underscore and hyphen","Any character that isn't alpha-numeric, hyphen, or underscore will be stripped from each tag"]});
  
      apiInterface['removeUser'] = assignHelp((function removeUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeUser', options); delete options.params; return makeRequest.call(this, 'removeUser', options); }).bind(apiInterface), 'removeUser', {"description":"This method will remove the specified user completely","params":[{"property":"userID","type":"string","description":"ID of user to remove ","required":true}],"example":"await API.removeUser({ params: { userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the specified user"]});
  
      apiInterface['removeUserFromAllOrganizations'] = assignHelp((function removeUserFromAllOrganizations(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organizations/user/<<userID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeUserFromAllOrganizations', options); delete options.params; return makeRequest.call(this, 'removeUserFromAllOrganizations', options); }).bind(apiInterface), 'removeUserFromAllOrganizations', {"description":"This method will remove the specified user from all related organization.","params":[{"property":"userID","type":"string","description":"ID of user to remove from organization","required":true}],"example":"await API.removeUserFromAll({ params: { userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the user from the specified organization"]});
  
      apiInterface['removeUserFromOrganization'] = assignHelp((function removeUserFromOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/user/<<userID>>', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeUserFromOrganization', options); delete options.params; return makeRequest.call(this, 'removeUserFromOrganization', options); }).bind(apiInterface), 'removeUserFromOrganization', {"description":"This method will remove the specified user from the specified organization.","params":[{"property":"organizationID","type":"string","description":"ID of organization to remove user from","required":true},{"property":"userID","type":"string","description":"ID of user to remove from organization","required":true}],"example":"await API.removeUserFromOrganization({ params: { organizationID: 'some-organization-id', userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove the user from the specified organization"]});
  
      apiInterface['removeUserTags'] = assignHelp((function removeUserTags(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>/tags', method: 'DELETE' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeUserTags', options); delete options.params; return makeRequest.call(this, 'removeUserTags', options); }).bind(apiInterface), 'removeUserTags', {"description":"This method will remove the specified tags from the specified user.","data":[{"property":"tags","type":"Array<string>","description":"Tags to remove from the specified user","required":true}],"params":[{"property":"userID","type":"string","description":"ID of user to remove tags from","required":true}],"example":"await API.removeUserTags({ data: { tags: [ 'tag1', 'tag2', 'tag3' ] }, params: { userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified user","Upon success the remaining tags for the user are returned","Tags that don't exist on the user will not be ignored","Tags must be only alpha-numeric, plus underscore and hyphen","Any character that isn't alpha-numeric, hyphen, or underscore will be stripped from each tag"]});
  
      apiInterface['removeUsersFromMeeting'] = assignHelp((function removeUsersFromMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/remove-users', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('removeUsersFromMeeting', options); delete options.params; return makeRequest.call(this, 'removeUsersFromMeeting', options); }).bind(apiInterface), 'removeUsersFromMeeting', {"description":"This method will remove the specified users from the meeting.","data":[{"property":"emails","type":"Array<string>","description":"List of user emails to remove","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to update","required":true}],"example":"await API.removeUsersFromMeeting({ data: { emails: [ 'user1@example.com', 'user2@example.com' ] }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to remove users from the specified meeting","This endpoint is idempotent, meaning it only make changes if something needs to be changed","It isn't possible to remove the meeting host from the meeting","If the meeting host's email is provided it will be silently ignored"]});
  
      apiInterface['renameTranscriptSpeakers'] = assignHelp((function renameTranscriptSpeakers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/rename-transcript-speakers', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('renameTranscriptSpeakers', options); delete options.params; return makeRequest.call(this, 'renameTranscriptSpeakers', options); }).bind(apiInterface), 'renameTranscriptSpeakers', {"description":"This method will edit speakers' labels in transcript of the specified meeting.","data":[{"property":"speakerEdits","type":"Object","description":"Speakers' edits. Can contain from 0 to transcript's speakers amount of key-value pairs. For example \"speakerEdits: { A: 'Alice', B: 'Bob' }\"","required":true}],"params":["meetingID"],"example":"await API.renameTranscriptSpeakers();","notes":[]});
  
      apiInterface['restart'] = assignHelp((function restart(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/restartServer', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('restart', options); delete options.params; return makeRequest.call(this, 'restart', options); }).bind(apiInterface), 'restart', {});
  
      apiInterface['resumeRecording'] = assignHelp((function resumeRecording(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/resume-recording', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('resumeRecording', options); delete options.params; return makeRequest.call(this, 'resumeRecording', options); }).bind(apiInterface), 'resumeRecording', {});
  
      apiInterface['retrieveBot'] = assignHelp((function retrieveBot(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/<<botID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('retrieveBot', options); delete options.params; return makeRequest.call(this, 'retrieveBot', options); }).bind(apiInterface), 'retrieveBot', {"description":"This method will retrieve recall bot.","params":[{"property":"botID","type":"string","description":"ID of the bot to retrieve","required":false},{"property":"meetingLink","type":"string","description":"Meeting link of the bot to retrieve","required":false},{"property":"joinAt","type":"string","description":"Join at time of the bot to retrieve","required":false}],"example":"await API.retrieveBot({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['retrieveRecallBotEvent'] = assignHelp((function retrieveRecallBotEvent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/event/<<recallEventID>>', method: 'GET' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('retrieveRecallBotEvent', options); delete options.params; return makeRequest.call(this, 'retrieveRecallBotEvent', options); }).bind(apiInterface), 'retrieveRecallBotEvent', {"description":"This method will retrieve recall bot's event.","params":[{"property":"botID","type":"string","description":"ID of the bot whose event to retrieve","required":true}],"example":"await API.retrieveBotEvent({ params: { botID: 'some-bot-id' } });"});
  
      apiInterface['saveGroupsToSync'] = assignHelp((function saveGroupsToSync(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/save-groups-to-sync', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('saveGroupsToSync', options); delete options.params; return makeRequest.call(this, 'saveGroupsToSync', options); }).bind(apiInterface), 'saveGroupsToSync', {});
  
      apiInterface['saveOrganizationSettings'] = assignHelp((function saveOrganizationSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/settings', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('saveOrganizationSettings', options); delete options.params; return makeRequest.call(this, 'saveOrganizationSettings', options); }).bind(apiInterface), 'saveOrganizationSettings', {"description":"This method will save organization settings","data":[{"property":"key","type":"string","description":"Setting key","required":true},{"property":"value","type":"boolean|number|string|object","description":"Setting payload","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.saveOrganizationSettings({ params: { organizationID }, body: [{ key: \"key1\", value: 12345 }] });"});
  
      apiInterface['saveUserSettings'] = assignHelp((function saveUserSettings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>/settings', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('saveUserSettings', options); delete options.params; return makeRequest.call(this, 'saveUserSettings', options); }).bind(apiInterface), 'saveUserSettings', {"description":"This method will save user settings","data":[{"property":"key","type":"string","description":"Setting key","required":true},{"property":"value","type":"boolean|number|string|object","description":"Setting payload","required":true}],"params":[{"property":"userID","type":"string","description":"ID of user","required":true}],"example":"await API.saveUserSettings({ params: { userID }, body: [{ key: \"key1\", value: 12345 }] });"});
  
      apiInterface['scheduleBotForCalendarEvent'] = assignHelp((function scheduleBotForCalendarEvent(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendar/<<calendarID>>/schedule-bot', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('scheduleBotForCalendarEvent', options); delete options.params; return makeRequest.call(this, 'scheduleBotForCalendarEvent', options); }).bind(apiInterface), 'scheduleBotForCalendarEvent', {"description":"This method will schedule recall bot for specified calendar event.","data":[{"property":"recallEventID","type":"string","description":"recallEventID","required":true},{"property":"meetingID","type":"string","description":"if meetingID provided, bot will be saved for that specified meetingID (if exists)","required":false}],"params":[{"property":"calendarID","type":"string","description":"calendarID","required":true}],"example":"await API.scheduleBotForCalendarEvent({ data: { recallEventID: 'some-recall-event-id' }, params: { calendarID: 'some-calendar-id' } });"});
  
      apiInterface['scheduledMeetingCheck'] = assignHelp((function scheduledMeetingCheck(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/scheduled-check', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('scheduledMeetingCheck', options); delete options.params; return makeRequest.call(this, 'scheduledMeetingCheck', options); }).bind(apiInterface), 'scheduledMeetingCheck', {});
  
      apiInterface['searchBots'] = assignHelp((function searchBots(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/list', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchBots', options); delete options.params; return makeRequest.call(this, 'searchBots', options); }).bind(apiInterface), 'searchBots', {"description":"This method will search list bots.","data":[{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{fieldName})","required":false}],"example":"await API.searchBots();","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['searchMeetings'] = assignHelp((function searchMeetings(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meetings', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchMeetings', options); delete options.params; return makeRequest.call(this, 'searchMeetings', options); }).bind(apiInterface), 'searchMeetings', {"description":"This method will search the meetings of an organization.","data":[{"property":"filter","type":"Object","description":"Filter properties","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"extra":[{"type":"table","title":"Meeting fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Some Meeting\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Some Meeting\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Meeting1\", \"Meeting2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Meeting%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Meeting%\" }"}]}],"example":"await API.searchMeetings({ data: { filter: { name: \"My Meeting\" }, limit: 20, offset: 0, order: '-Meeting:name' } });","notes":["The target organization is the calling users current organization","Only meetings you have permission to view will be returned","The \"filter\" property can contain any of the fields for meetings","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on meeting fields you can postfix the field name with an operator... for example: \"createdAt>=\": \"2001-01-01\" to find meetings created on or after 2001-01-01","Pay attention to the table containing a list of usable operators for meeting fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name\": \"Meeting\", \"createdAt>=\": \"2001-01-01\" }, { \"createdAt>=\": \"2001-01-01\", \"agenda\": null } ]\n    would result in ((name = 'Meeting' AND createdAt >= '2001-01-01') OR (createdAt >= '2001-01-01' AND agenda IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Meeting:name\" } (DESC)\n    Example 2: { order: \"+Meeting:name\" } (ASC)"]});
  
      apiInterface['searchOrganizations'] = assignHelp((function searchOrganizations(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organizations', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchOrganizations', options); delete options.params; return makeRequest.call(this, 'searchOrganizations', options); }).bind(apiInterface), 'searchOrganizations', {"description":"This method will search organizations.","data":[{"property":"filter","type":"Object","description":"Filter properties","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{name})","required":false}],"extra":[{"type":"table","title":"User fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Bob\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Bob\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Bob\", \"John\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Bob\", \"John\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Bob%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Bob%\" }"}]}],"example":"await API.searchOrganizations({ data: { filter: { name: 'Some Organization', 'createdAt>=': '2001-01-01', }, limit: 20, offset: 0, order: '-Organization:name' } });","notes":["Only organizations you have permission to view will be returned","The \"filter\" property can contain any of the fields for organizations","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on organization fields you can postfix the field name with an operator... for example: \"name*\": \"%Test%\" to find organizations whose name contains \"Test\"","Pay attention to the table containing a list of usable operators for organization fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name*\": \"%Test%\", \"createdAt>\": \"2001-01-01\" }, { \"createdAt>=\": \"2022-01-01\", \"name\": null } ]\n    would result in ((name LIKE '%Bob%' AND createdAt >= '2001-01-01') OR (createdAt >= '2022-01-01' AND name IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Organization:name\" } (DESC)\n    Example 2: { order: \"+Organization:name\" } (ASC)"]});
  
      apiInterface['searchTeams'] = assignHelp((function searchTeams(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/teams', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchTeams', options); delete options.params; return makeRequest.call(this, 'searchTeams', options); }).bind(apiInterface), 'searchTeams', {"description":"This method will search the teams of the current user. Pay attention to the discussion about the \"filter\" attribute, as this filter is slightly different than other filters in the API.","data":[{"property":"filter","type":"Object","description":"Filter properties. This can include \"groups\" or \"scopes\" for the filter. For example \"filter: { teams: { ... }, users: { ... } }\"","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"extra":[{"type":"table","title":"Team fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Some Team\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Some Team\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Team1\", \"Team2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Team1\", \"Team2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Team%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Team%\" }"}]}],"example":"await API.searchTeams({ data: { filter: { teams: { name: \"My Meeting\" }, users: { 'email*': '%searchTerm%' } }, limit: 20, offset: 0, order: '-Team:name' } });","notes":["The target organization is the calling users current organization","Only teams you have permission to view will be returned","The \"filter\" property can contain the fields \"name\", \"createdAt\", or \"updatedAt\" for the team","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on team fields you can postfix the field name with an operator... for example: \"createdAt>=\": \"2001-01-01\" to find teams created on or after 2001-01-01","Pay attention to the table containing a list of usable operators for team fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name\": \"Team\", \"createdAt>=\": \"2001-01-01\" }, { \"createdAt>=\": \"2001-01-01\", \"team\": null } ]\n    would result in ((name = 'Team' AND createdAt >= '2001-01-01') OR (createdAt >= '2001-01-01' AND name IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Team:name\" } (DESC)\n    Example 2: { order: \"+Team:name\" } (ASC)","With the \"filter\" you will likely want to specify the \"groups\" for the filter. The groups available for this filter are \"teams\" and \"users\". For example:\n    filter = { teams: { name: 'Team Name' }, users: { email: 'user1@example.com' } }","The \"filter\" doesn't have to contain \"groups\", but if it doesn't, then you are limited on how you can filter. For example,\n    \"filter = { name: 'Team Name', email: [ 'user1@example.com', 'user2@example.com' ] }\"\nwill work, along with other simple queries. However, to get more complex, you MUST use the filter groups/scopes \"teams\" and \"users\", example:\n    \"filter = { teams: [ { name: 'Team 1' }, { name: 'Team 2' } ], users: [ { lastName: 'Brown' }, { lastName: 'Smith' } ] ] }\""]});
  
      apiInterface['searchTeamsAndUsers'] = assignHelp((function searchTeamsAndUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/search-teams-and-users', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchTeamsAndUsers', options); delete options.params; return makeRequest.call(this, 'searchTeamsAndUsers', options); }).bind(apiInterface), 'searchTeamsAndUsers', {"description":"This method will search across teams and users.","data":[{"property":"filter","type":"Object","description":"Filter properties. Note that this filter, if provided, must contain a \"teams\" and/or \"users\" scope.","required":false},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{name})","required":false}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to search for teams and users in","required":true}],"extra":[{"type":"table","title":"User fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"name=\": \"Team Name\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"name!=\": \"Team Name\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"name=\": [ \"Team 1\", \"Team 2\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"name!=\": [ \"Team 1\", \"Team 2\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"createdAt>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"createdAt>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"createdAt<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"createdAt<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"createdAt><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"createdAt<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"name*\": \"%Team%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"name!*\": \"%Team%\" }"}]}],"example":"await API.searchTeamsAndUsers({ data: { filter: { teams: { 'name*': '%search term%' }, users: { 'email*': '%search term%' } }, limit: 20, offset: 0, order: [ 'User:firstName', 'User:lastName' ] }, params: { organizationID: 'some-organization-id' } });","notes":["Only teams you have permission to view will be returned","The \"filter.teams\" property can contain any of the fields for teams","The \"filter.users\" property can contain any of the following fields for users: `email`, `firstName`, `lastName`","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on fields you can postfix the field name with an operator... for example: `teams: { \"name*\": \"%Test%\" }` to find teams whose name contains \"Test\"","Pay attention to the table containing a list of usable operators for teams and user fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"name*\": \"%Test%\", \"createdAt>\": \"2001-01-01\" }, { \"createdAt>=\": \"2022-01-01\", \"name\": null } ]\n    would result in ((name LIKE '%Bob%' AND createdAt >= '2001-01-01') OR (createdAt >= '2022-01-01' AND name IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-Team:name\" } (DESC)\n    Example 2: { order: \"+Team:name\" } (ASC)","The \"filter\" for this endpoint works slightly differently then other filters. It requires a \"teams\" or \"users\" sub-key(s)/scopes if provided. The `teams` scope specifies filter properties for searching teams, and the `users` key should contain filter properties for searching against users. Both can be used at the same time, or one or the other can be specified.","The `limit` and `order` might be a little odd for this endpoint. The limit and order are applied both to the teams and users queries, which are separate. Then the collecting of users for each team is also an extra step. This might mean that your `limit` and `offset` aren't fully respected like you might expect. In short, you might get slightly more data than the provided `limit`. It is recommended that you simply don't supply a limit or offset."]});
  
      apiInterface['searchUsers'] = assignHelp((function searchUsers(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/users', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('searchUsers', options); delete options.params; return makeRequest.call(this, 'searchUsers', options); }).bind(apiInterface), 'searchUsers', {"description":"This method will search the users of an organization.","data":[{"property":"filter","type":"Object","description":"Filter properties","required":true},{"property":"limit","type":"number","description":"Limit returned records","required":false},{"property":"offset","type":"number","description":"Offset in records to start searching","required":false},{"property":"order","type":"string","description":"Order results by specified field (format [+-]{ModelName}:{fieldName})","required":false}],"extra":[{"type":"table","title":"User fields filter operators","columns":["operator","name","description","example"],"rows":[{"operator":"=","name":"equals","description":"Match against field value equals specified value","example":"filter: { \"firstName=\": \"Bob\" }"},{"operator":"!=","name":"not equals","description":"Match against field value not equals specified value","example":"filter: { \"firstName!=\": \"Bob\" }"},{"operator":"=","name":"in","description":"Match against field value that is any of the specified values","example":"filter: { \"firstName=\": [ \"Bob\", \"John\" ] }"},{"operator":"!=","name":"not in","description":"Match against field value that is not any of the specified values","example":"filter: { \"firstName!=\": [ \"Bob\", \"John\" ] }"},{"operator":">","name":"greater than","description":"Match against field value is greater than specified value","example":"filter: { \"dob>\": \"2001-01-01\" }"},{"operator":">=","name":"greater than or equal","description":"Match against field value is greater than or equal to specified value","example":"filter: { \"dob>=\": \"2001-01-01\" }"},{"operator":"<","name":"less than","description":"Match against field value is less than specified value","example":"filter: { \"dob<\": \"2001-01-01\" }"},{"operator":"<=","name":"less than or equal","description":"Match against field value is less than or equal to specified value","example":"filter: { \"dob<=\": \"2001-01-01\" }"},{"operator":"><","name":"between","description":"Match against field value is between specified values","example":"filter: { \"dob><\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"<>","name":"not between","description":"Match against field value is not between specified values","example":"filter: { \"dob<>\": [ \"2001-01-01\", \"2022-01-01\" ] }"},{"operator":"*","name":"like","description":"Match against field value is like specified value (wildcard match)","example":"filter: { \"firstName*\": \"%Bob%\" }"},{"operator":"!*","name":"not like","description":"Match against field value is not like specified value (wildcard match)","example":"filter: { \"firstName!*\": \"%Bob%\" }"}]}],"example":"await API.searchUsers({ data: { filter: { tags: [ 'tag1', 'tag2' ], roles: [ 'role1', 'role2' ], firstName: 'Bob' }, limit: 20, offset: 0, order: '-User:firstName' } });","notes":["The target organization is the calling users current organization","Only users you have permission to view will be returned","The \"filter\" property can contain any of the fields for users, along with \"tags\" and \"roles\"","\"tags\" and \"role\" filters must fully match all specified values","\"=\" and \"!=\" operators switch automatically to \"IN\" and \"NOT IN\" operators if the specified value is an array","When filtering on user fields you can postfix the field name with an operator... for example: \"dob>=\": \"2001-01-01\" to find users born on or after 2001-01-01","Pay attention to the table containing a list of usable operators for user fields","If no field operator is specified for filter fields, then the equals (=) operator is assumed","\"filter\" can contain AND and OR operations. For this to work, you simply need to use an array (OR) or an object (AND).\n    An array specifies an \"OR\" context.\n    An object specifies an \"AND\" context.\n    For example: \"filter\": [ { \"firstName\": \"Bob\", \"lastName\": \"Brown\" }, { \"dob>=\": \"2001-01-01\", \"firstName\": null } ]\n    would result in ((firstName = 'Bob' AND lastName = 'Brown') OR (dob >= '2001-01-01' AND firstName IS NULL))","The \"order\" field can specify the sort direction.\n    For ASC order, simply prefix the field with \"+\" (default).\n    For DESC order, simply prefix the field with \"-\".\n    Example 1: { order: \"-User:firstName\" } (DESC)\n    Example 2: { order: \"+User:firstName\" } (ASC)"]});
  
      apiInterface['sendAuthCode'] = assignHelp((function sendAuthCode(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/send-code', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('sendAuthCode', options); delete options.params; return makeRequest.call(this, 'sendAuthCode', options); }).bind(apiInterface), 'sendAuthCode', {"description":"This method will send the specified user an email containing login code.","data":[{"property":"email","type":"string","description":"Email address of user","required":true}],"example":"await API.sendAuthCode({ data: { email: 'some+user@example.com' } });","notes":["If the specified user is not found, then a 404 response will be returned"]});
  
      apiInterface['sendMagicLoginLink'] = assignHelp((function sendMagicLoginLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/send-magic-link', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('sendMagicLoginLink', options); delete options.params; return makeRequest.call(this, 'sendMagicLoginLink', options); }).bind(apiInterface), 'sendMagicLoginLink', {"description":"This method will send the specified user an email containing a magic login link.","data":[{"property":"email","type":"string","description":"Email address of user","required":true}],"example":"await API.sendMagicLink({ data: { email: 'some+user@example.com' } });","notes":["If the specified user is not found, then a 404 response will be returned"]});
  
      apiInterface['sendMagicLoginLinkForExtension'] = assignHelp((function sendMagicLoginLinkForExtension(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/send-magic-link-extension', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('sendMagicLoginLinkForExtension', options); delete options.params; return makeRequest.call(this, 'sendMagicLoginLinkForExtension', options); }).bind(apiInterface), 'sendMagicLoginLinkForExtension', {"description":"This method will send the specified user an email containing a magic login link.","data":[{"property":"email","type":"string","description":"Email address of user","required":true}],"example":"await API.sendMagicLink({ data: { email: 'some+user@example.com' } });","notes":["If the specified user is not found, then a 404 response will be returned"]});
  
      apiInterface['sendMinutesEmail'] = assignHelp((function sendMinutesEmail(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/send-minutes-email', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('sendMinutesEmail', options); delete options.params; return makeRequest.call(this, 'sendMinutesEmail', options); }).bind(apiInterface), 'sendMinutesEmail', {"description":"This method will invite the specified users to the meeting.","data":[{"property":"emails","type":"Array<string>","description":"List of user emails to invite","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to update","required":true}],"example":"await API.inviteUsersToMeeting({ data: { emails: [ 'user1@example.com', 'user2@example.com' ] }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to invite users to the specified meeting","Invited users that aren't currently members of the organization will be invited to the organization automatically","This endpoint is idempotent, meaning it only make changes if something needs to be changed","Users who have already been invited to the meeting will not be re-invited","All notifications will be paused and not sent until this operation completes"]});
  
      apiInterface['setCurrentOrganization'] = assignHelp((function setCurrentOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/set-current-organization', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('setCurrentOrganization', options); delete options.params; return makeRequest.call(this, 'setCurrentOrganization', options); }).bind(apiInterface), 'setCurrentOrganization', {"description":"This method will set the user's \"current organization\" on the user's Session.","data":[{"property":"organizationID","type":"string","description":"The organizationID to set as the user's \"current organization\"","required":true}],"example":"await API.setCurrentOrganization({ data: { organizationID: \"some-organization-id\" } });","notes":["There must be a valid user session for this method to work (specified as a cookie, or an \"Authorization\" header)","The user's current organizationID will be returned as the attribute \"currentOrganizationID\" in the response payload","Setting the \"current organization\" for a user will set the \"currentOrganizationID\" on the user's Session, which will be used when they \"reload\" or come back to the page"]});
  
      apiInterface['signUp'] = assignHelp((function signUp(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/sign-up', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('signUp', options); delete options.params; return makeRequest.call(this, 'signUp', options); }).bind(apiInterface), 'signUp', {"description":"This method will create a new organization, register all the users added (if not registered already) then invite them to the organization.","data":[{"property":"orgName","type":"string","description":"Name of the organization","required":true},{"property":"firstName","type":"string","description":"First name of the person creating organization.","required":true},{"property":"lastName","type":"string","description":"Last name of the person creating organization.","required":true},{"property":"email","type":"string","description":"Email of person creating organization.","required":true},{"property":"phone","type":"string","description":"Phone number of person creating organization","required":false},{"property":"invitees","type":"array","description":"{ email: alden@gmail.com, key: 1232kdfhjd }[]","required":false}],"example":"await API.signUp({ data: { orgName: 'New Organization Name' firstName: \"Alden\", lastName: \"Ho\", email: \"alden@reelay.ai, phone: \"123445354\", invitees: [{ email: \"dog@gmail.com\", key: \"1\" }, { email: \"cat@gmail.com\", key: \"2\" }] } });","notes":["Upon success, the specified users data is returned","For security reasons, if the user specified already exists, then a 400 bad request will be returned instead of the users data"]});
  
      apiInterface['syncGroups'] = assignHelp((function syncGroups(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/auth/sync-groups', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('syncGroups', options); delete options.params; return makeRequest.call(this, 'syncGroups', options); }).bind(apiInterface), 'syncGroups', {});
  
      apiInterface['transferMeetingOwner'] = assignHelp((function transferMeetingOwner(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/transfer-owner', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('transferMeetingOwner', options); delete options.params; return makeRequest.call(this, 'transferMeetingOwner', options); }).bind(apiInterface), 'transferMeetingOwner', {"description":"This method send transfer the meeting owner to another user. It is used by support users on the audit page.","data":[{"property":"userID","type":"string","description":"userID of new meeting owner.","required":true}],"params":["meetingID"],"example":"await API.transferMeetingOwner();","notes":[]});
  
      apiInterface['unassignSupporterFromOrganization'] = assignHelp((function unassignSupporterFromOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/unassign-supporter-from-organization', method: 'POST' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('unassignSupporterFromOrganization', options); delete options.params; return makeRequest.call(this, 'unassignSupporterFromOrganization', options); }).bind(apiInterface), 'unassignSupporterFromOrganization', {"description":"This method will unassign supporter from specific organization","data":[{"property":"userID","type":"string","description":"ID of user to assign (support)","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization","required":true}],"example":"await API.unassignSupporterFromOrganization({ data: { userID: 'support-user-id' }, params: { organizationID: 'some-organization-id' }  });"});
  
      apiInterface['update'] = assignHelp((function update(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/notification-emails/<<notificationID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('update', options); delete options.params; return makeRequest.call(this, 'update', options); }).bind(apiInterface), 'update', {"description":"This method will update the notification email, primarily its status.","data":[{"property":"status","type":"string","description":"Status of the notification email - \"sent\", \"seen\"","required":true}],"params":[{"property":"notificationID","type":"string","description":"ID of the notification email to update","required":true}],"example":"await API.updateNotificationEmail({ data: { status: 'sent' }, params: { notificationID: 'some-notification-email-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified notification email","The updated notification email will be returned as the response"]});
  
      apiInterface['updateBot'] = assignHelp((function updateBot(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/recall-ai/bot/<<botID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateBot', options); delete options.params; return makeRequest.call(this, 'updateBot', options); }).bind(apiInterface), 'updateBot', {"description":"This method will update recall bot.","params":[{"property":"botID","type":"string","description":"ID of the bot to update","required":true}],"data":[{"property":"botName","type":"string","description":"Name of the bot for this meeting","required":false},{"property":"joinAt","type":"date","description":"Time when bot will join for a meeting","required":false},{"property":"meetingLink","type":"string","description":"Meeting link of Google meet, zoom, teams, etc.","required":false}],"example":"await API.updateBot({ params: { botID: 'some-bot-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to read the specified team"]});
  
      apiInterface['updateCalendar'] = assignHelp((function updateCalendar(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/calendar/<<calendarID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateCalendar', options); delete options.params; return makeRequest.call(this, 'updateCalendar', options); }).bind(apiInterface), 'updateCalendar', {"description":"This method will update calendar.","data":[{"property":"autoRecordAllEvents","type":"boolean","description":"Record all events from calendar.","required":false},{"property":"autoRecordInternalEvents","type":"boolean","description":"Record only internal events.","required":false},{"property":"autoRecordExternalEvents","type":"boolean","description":"Record only external events.","required":false}],"params":[{"property":"calendarID","type":"string","description":"calendarID","required":true}],"example":"await API.updateCalendar({ data: { autoRecordAllEvents: true }, params: { calendarID: 'some-calendar-id' } });"});
  
      apiInterface['updateCurrentUser'] = assignHelp((function updateCurrentUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateCurrentUser', options); delete options.params; return makeRequest.call(this, 'updateCurrentUser', options); }).bind(apiInterface), 'updateCurrentUser', {"description":"This method will update the currently logged-in user's data. This method will update the demographics directly on the User model, instead of the UserOrganizationLink model. To update the user's demographics for a specific organization use the \"updateOrganizationUser\" method instead.","example":"await API.updateCurrentUser({ data: { firstName: 'New', lastName: 'Name' } });","notes":["Only the \"current user\" is allowed to call this method. If another user (i.e. admin) calls this method then the result will be a 403 Forbidden response","Use the \"updateOrganizationUser\" method instead to update the user's demographics for a specific organization"]});
  
      apiInterface['updateMeeting'] = assignHelp((function updateMeeting(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeeting', options); delete options.params; return makeRequest.call(this, 'updateMeeting', options); }).bind(apiInterface), 'updateMeeting', {"description":"This method will update the specified meeting with the data provided.","data":[{"property":"name","type":"string","description":"Name of the meeting","required":false},{"property":"objective","type":"string (HTML)","description":"Objective of the meeting. HTML is sanitized server-side.","required":false},{"property":"agenda","type":"string (HTML)","description":"Agenda of the meeting. HTML is sanitized server-side.","required":false},{"property":"summary","type":"string (HTML)","description":"Summary of the meeting. HTML is sanitized server-side.","required":false},{"property":"viewingDeadline","type":"string","description":"ISO date string representing the viewing deadline","required":false},{"property":"meetingDate","type":"string","description":"ISO date string representing the meeting date","required":false},{"property":"thumbnailTime","type":"number","description":"Time in seconds of video to get MUX thumbnail","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to update","required":true}],"example":"await API.updateMeeting({ data: { name: 'New Name of Meeting' }, params: { meetingID: 'some-meeting-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified meeting","You can also update a meeting by its 'friendlyID', just set the \"meetingID\" param to the 'friendlyID' of the meeting","The updated meeting will be returned as the response"]});
  
      apiInterface['updateMeetingChapter'] = assignHelp((function updateMeetingChapter(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chapter/<<chapterID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeetingChapter', options); delete options.params; return makeRequest.call(this, 'updateMeetingChapter', options); }).bind(apiInterface), 'updateMeetingChapter', {"description":"This method will update the specified meeting chapter with the data provided.","data":[{"property":"summary","type":"string","description":"summary of chapter","required":false},{"property":"headline","type":"string","description":"headline of chapter","required":false},{"property":"gist","type":"string","description":"gist of chapter","required":false},{"property":"start","type":"number","description":"start time in ms","required":false},{"property":"end","type":"number","description":"end time in ms","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"chapterID","type":"string","description":"ID of the chapter","required":true}],"example":"await API.updateMeetingChapter({ data: { summary: 'Some summary' }, params: { meetingID: 'some-meeting-id', chapterID: 'some-chapter-id (for example index 0 in chatpers array)' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified chapter"]});
  
      apiInterface['updateMeetingChapters'] = assignHelp((function updateMeetingChapters(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/chapters', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeetingChapters', options); delete options.params; return makeRequest.call(this, 'updateMeetingChapters', options); }).bind(apiInterface), 'updateMeetingChapters', {"description":"This method will update the specified meeting chapter with the data provided.","data":[{"property":"summary","type":"string","description":"summary of chapter","required":false},{"property":"headline","type":"string","description":"headline of chapter","required":false},{"property":"gist","type":"string","description":"gist of chapter","required":false},{"property":"start","type":"number","description":"start time in ms","required":false},{"property":"end","type":"number","description":"end time in ms","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"chapterID","type":"string","description":"ID of the chapter","required":true}],"example":"await API.updateMeetingChapter({ data: { summary: 'Some summary' }, params: { meetingID: 'some-meeting-id', chapterID: 'some-chapter-id (for example index 0 in chatpers array)' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified chapter"]});
  
      apiInterface['updateMeetingComment'] = assignHelp((function updateMeetingComment(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/comment/<<commentID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeetingComment', options); delete options.params; return makeRequest.call(this, 'updateMeetingComment', options); }).bind(apiInterface), 'updateMeetingComment', {"description":"This method will update the specified comment with the data provided.","data":[{"property":"content","type":"string","description":"The content of the highlight","required":true}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"commentID","type":"string","description":"ID (or friendlyID) of the comment","required":true}],"example":"await API.updateComment({ data: { content: 'New content for highlight' }, params: { meetingID: 'some-meeting-id', commentID: 'some-comment-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified comment","The updated comment will be returned as the response","A 201 status code along with the comment will be returned if nothing was updated"]});
  
      apiInterface['updateMeetingHighlight'] = assignHelp((function updateMeetingHighlight(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting/<<meetingID>>/highlight/<<meetingHighlightID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeetingHighlight', options); delete options.params; return makeRequest.call(this, 'updateMeetingHighlight', options); }).bind(apiInterface), 'updateMeetingHighlight', {"description":"This method will update the specified meeting highlight with the data provided.","data":[{"property":"content","type":"string","description":"The content of the highlight","required":false},{"property":"timeStartMS","type":"number","description":"The start time of the highlight in milliseconds (video time)","required":false},{"property":"timeEndMS","type":"number","description":"The end time of the highlight in milliseconds (video time)","required":false}],"params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of the meeting","required":true},{"property":"meetingHighlightID","type":"string","description":"ID (or friendlyID) of the meeting highlight","required":true}],"example":"await API.updateMeetingHighlight({ data: { content: 'New content for highlight', timeStartMS: 5000, timeEndMS: 15000, }, params: { meetingID: 'some-meeting-id', meetingHighlightID: 'some-meeting-highlight-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified meeting highlight","The updated meeting highlight will be returned as the response","A 201 status code along with the meeting highlight will be returned if nothing was updated"]});
  
      apiInterface['updateMeetingShareableLink'] = assignHelp((function updateMeetingShareableLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/shareable-links/<<meetingID>>/<<linkID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateMeetingShareableLink', options); delete options.params; return makeRequest.call(this, 'updateMeetingShareableLink', options); }).bind(apiInterface), 'updateMeetingShareableLink', {"description":"This method will update shareable link","params":[{"property":"meetingID","type":"string","description":"ID (or friendlyID) of meeting to show","required":true},{"property":"linkID","type":"string","description":"ID of shareable link","required":true}],"example":"await API.updateMeetingShareableLink({ params: { meetingID: 'some-meeting-id', linkID: 'some-shareable-link-id'  } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update shareable link"]});
  
      apiInterface['updateOrganization'] = assignHelp((function updateOrganization(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateOrganization', options); delete options.params; return makeRequest.call(this, 'updateOrganization', options); }).bind(apiInterface), 'updateOrganization', {"description":"This method will update the specified organization with the data provided.","data":[{"property":"name","type":"string","description":"Name of the organization","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to update","required":true}],"example":"await API.updateOrganization({ data: { name: 'New Name of Organization' }, params: { organizationID: 'some-organization-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified organization","The updated organization will be returned as the response"]});
  
      apiInterface['updateOrganizationUser'] = assignHelp((function updateOrganizationUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/user/<<userID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateOrganizationUser', options); delete options.params; return makeRequest.call(this, 'updateOrganizationUser', options); }).bind(apiInterface), 'updateOrganizationUser', {"description":"This method will update the user with the data provided. This will update the user's demographics ONLY for the specified organization!","data":[{"property":"email","type":"string","description":"Email address of user","required":true},{"property":"firstName","type":"string","description":"First name of the user","required":false},{"property":"lastName","type":"string","description":"Last name of the user","required":false},{"property":"phone","type":"string","description":"Phone number for the user","required":false}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to update user demographics for","required":true},{"property":"userID","type":"string","description":"ID of user to update","required":true}],"example":"await API.updateOrganizationUser({ data: { email: 'some+user@example.com', firstName: 'Test', lastName: 'User' }, params: { organizationID: 'some-organization-id', userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified user","Upon success the updated user will be returned","This will update the user's demographics FOR A SPECIFIED ORGANIZATION. To update the User model directly for a user, use the \"updateCurrentUser\", or \"updateUser\" (only masteradmin and support roles) methods instead.","Unlike the \"updateCurrentUser\" method, this method can be called by other user's on behalf of the specified user (i.e. admin users)","The specified user can update themselves via this method"]});
  
      apiInterface['updateTeam'] = assignHelp((function updateTeam(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/team/<<teamID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateTeam', options); delete options.params; return makeRequest.call(this, 'updateTeam', options); }).bind(apiInterface), 'updateTeam', {"description":"This method will update the specified team with the data provided.","data":[{"property":"name","type":"string","description":"Name of the team","required":false},{"property":"emails","type":"Array<string>","description":"An array of emails for users to REPLACE all current users of the team","required":false}],"params":[{"property":"teamID","type":"string","description":"ID of the team to update","required":true}],"example":"await API.updateTeam({ data: { name: 'New Name of Team', emails: [ 'user1@example.com', 'user2@example.com' ] }, params: { teamID: 'some-team-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the specified team","The updated team will be returned as the response","If you pass an \"emails\" attribute along with the request, then the users for the team with be SET to the specified users. This means that all current users of the team will be removed, and the users specified in the \"emails\" attribute will be added. In short, this REPLACES the users for a team.","Any user that doesn't already belong to the organization that owns the team will be silently ignored (users must already exist in the organization to be added to the team)","If no \"emails\" attribute is provided, or is empty, then the users for the team will not be updated"]});
  
      apiInterface['updateUser'] = assignHelp((function updateUser(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/user/<<userID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateUser', options); delete options.params; return makeRequest.call(this, 'updateUser', options); }).bind(apiInterface), 'updateUser', {"description":"This method will update the specified user's data. This method will update the demographics directly on the User model, instead of the UserOrganizationLink model. To update the user's demographics for a specific organization use the \"updateOrganizationUser\" method instead.","example":"await API.updateUser({ data: { firstName: 'New', lastName: 'Name' } });","notes":["Only the \"current user\", \"masteradmin\" users, and \"support\" users are allowed to call this method. If another user (i.e. admin) calls this method then the result will be a 403 Forbidden response","Use the \"updateOrganizationUser\" method instead to update the user's demographics for a specific organization"]});
  
      apiInterface['updateUserAvatar'] = assignHelp((function updateUserAvatar(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/organization/<<organizationID>>/user/<<userID>>/avatar', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateUserAvatar', options); delete options.params; return makeRequest.call(this, 'updateUserAvatar', options); }).bind(apiInterface), 'updateUserAvatar', {"description":"This method will update the specified user's avatar for the specified organization. FormData or JSON formats are both accepted. For JSON payloads, the \"file\" property must be a base64 encoded image.","data":[{"property":"file","type":"FormData->file | base64 encoded image","description":"Avatar image file","required":true},{"property":"fileName","type":"string","description":"Name of file. The file extension is used to detect the Content-Type","required":true}],"params":[{"property":"organizationID","type":"string","description":"ID of organization to update avatar on","required":true},{"property":"userID","type":"string","description":"ID of user to update avatar for","required":true}],"example":"await API.updateUserAvatar({ data: FormData || JSON, params: { organizationID: 'some-organization-id', userID: 'some-user-id' } });","notes":["You will receive a 403 Forbidden response if you don't have the permission level to update the user's avatar","You can optionally use FormData with a file attachment, or you can use a JSON payload to upload the attachment.\n    If JSON is used, then the \"file\" property should be a base64 encoded image.","User avatar's are per-organization, which is why you must go through the organization controller to update a user's avatar","\"dob\" for a user can not be updated via this method. \"dob\" can only be updated by the user themselves through the \"updateCurrentUser\" method"]});
  
      apiInterface['updateUserLink'] = assignHelp((function updateUserLink(_options) { var clientOptions = {"credentials":"same-origin","headers":{"Content-Type":"application/json"}}; var options = Object.assign({ url: '/api/v1/meeting-userlinks/<<userlinkID>>', method: 'PATCH' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('updateUserLink', options); delete options.params; return makeRequest.call(this, 'updateUserLink', options); }).bind(apiInterface), 'updateUserLink', {"description":"This method patch user link.","params":[{"property":"userLinkID","type":"string","description":"ID of user link to get","required":true}],"example":"await API.getUserLink({ params: { userLinkID: 'some-user-link-id' } });","notes":["User will receive a 403 Forbidden response if they don't have the permission"]});
  
      return apiInterface;
    }


  var APIInterface = generateAPIInterface(globalScope, environmentType);

  globalScope['API'] = APIInterface

  return APIInterface;
}).call(this, (typeof window === 'undefined') ? global : window, (typeof window !== 'undefined') ? 'browser' : 'node');