text: /**
   * meraki
   *
   * This file was automatically generated for meraki by APIMATIC v2.0 ( https://apimatic.io ).
   */
  
  'use strict';
  
  const _request = require('../Http/Client/RequestClient');
  const _configuration = require('../configuration');
  const _apiHelper = require('../APIHelper');
  const _baseController = require('./BaseController');
  
  class SwitchSettingsController {
      /**
       * Returns the switch network settings
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettings(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update switch network settings
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsModel} input['updateNetworkSwitchSettings'] (optional)
       * TODO: type
       * description
       * here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettings(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettings),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return the DHCP server policy
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsDhcpServerPolicy(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/dhcpServerPolicy';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update the DHCP server policy
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsDhcpServerPolicyModel} input['updateNetworkSwitchSettingsDhcpServerPolicy'] (optional) TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsDhcpServerPolicy(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/dhcpServerPolicy';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsDhcpServerPolicy),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return the DSCP to CoS mappings
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsDscpToCosMappings(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/dscpToCosMappings';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update the DSCP to CoS mappings
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsDscpToCosMappingsModel} input['updateNetworkSwitchSettingsDscpToCosMappings'] TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsDscpToCosMappings(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.updateNetworkSwitchSettingsDscpToCosMappings === null || input.updateNetworkSwitchSettingsDscpToCosMappings === undefined) {
              const _err = { errorMessage: 'The property `updateNetworkSwitchSettingsDscpToCosMappings` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/dscpToCosMappings';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsDscpToCosMappings),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return the MTU configuration
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsMtu(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/mtu';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update the MTU configuration
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsMtuModel} input['updateNetworkSwitchSettingsMtu'] (option
       * al)
       * TODO:
       * type
       * descrip
       * tion
       * here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsMtu(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/mtu';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsMtu),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return multicast settings for a network
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsMulticast(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/multicast';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update multicast settings for a network
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsMulticastModel} input['updateNetworkSwitchSettingsMulticast'] (optional) TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsMulticast(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/multicast';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsMulticast),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * List quality of service rules
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsQosRules(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Add a quality of service rule
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {CreateNetworkSwitchSettingsQosRuleModel} input['createNetworkSwitchSettingsQosRule'] TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static createNetworkSwitchSettingsQosRule(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.createNetworkSwitchSettingsQosRule === null || input.createNetworkSwitchSettingsQosRule === undefined) {
              const _err = { errorMessage: 'The property `createNetworkSwitchSettingsQosRule` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'POST',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.createNetworkSwitchSettingsQosRule),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return the quality of service rule IDs by order in which they will be processed by the
       * switch
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsQosRulesOrder(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules/order';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update the order in which the rules should be processed by the switch
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsQosRulesOrderModel} input['updateNetworkSwitchSettingsQosRulesOrder'] TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsQosRulesOrder(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.updateNetworkSwitchSettingsQosRulesOrder === null || input.updateNetworkSwitchSettingsQosRulesOrder === undefined) {
              const _err = { errorMessage: 'The property `updateNetworkSwitchSettingsQosRulesOrder` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules/order';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsQosRulesOrder),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return a quality of service rule
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {string} input['qosRuleId'] TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsQosRule(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.qosRuleId === null || input.qosRuleId === undefined) {
              const _err = { errorMessage: 'The property `qosRuleId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules/{qosRuleId}';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
              qosRuleId: input.qosRuleId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Delete a quality of service rule
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {string} input['qosRuleId'] TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static deleteNetworkSwitchSettingsQosRule(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.qosRuleId === null || input.qosRuleId === undefined) {
              const _err = { errorMessage: 'The property `qosRuleId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules/{qosRuleId}';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
              qosRuleId: input.qosRuleId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'DELETE',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      _callback(null, null, _context);
                      _fulfill();
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update a quality of service rule
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {string} input['qosRuleId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsQosRuleModel} input['updateNetworkSwitchSettingsQosRule'] (optional) TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsQosRule(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          } else if (input.qosRuleId === null || input.qosRuleId === undefined) {
              const _err = { errorMessage: 'The property `qosRuleId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/qosRules/{qosRuleId}';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
              qosRuleId: input.qosRuleId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsQosRule),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Return the storm control configuration for a switch network
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsStormControl(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/stormControl';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Update the storm control configuration for a switch network
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsStormControlModel} input['updateNetworkSwitchSettingsStormControl'] (optional) TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsStormControl(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/stormControl';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsStormControl),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Returns STP settings
       *
       * @param {string} networkId TODO: type description here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static getNetworkSwitchSettingsStp(networkId, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (networkId === null || networkId === undefined) {
              const _err = { errorMessage: 'The parameter `networkId` is a required parameter and cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/stp';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'GET',
              headers: _headers,
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
      /**
       * Updates STP settings
       *
       * @param  {array}  input    Array with all options for search
       * @param {string} input['networkId'] TODO: type description here
       * @param {UpdateNetworkSwitchSettingsStpModel} input['updateNetworkSwitchSettingsStp'] (option
       * al)
       * TODO:
       * type
       * descrip
       * tion
       * here
       *
       * @callback    The callback function that returns response from the API call
       *
       * @returns {Promise}
       */
      static updateNetworkSwitchSettingsStp(input, callback) {
          // create empty callback if absent
          const _callback = typeof callback === 'function' ? callback : () => undefined;
  
          // validating required parameters
          if (input.networkId === null || input.networkId === undefined) {
              const _err = { errorMessage: 'The property `networkId` in the input object cannot be null.',
                  errorCode: -1 };
              _callback(_err, null, null);
              return Promise.reject(_err);
          }
          // prepare query string for API call
          const _baseUri = _configuration.BASEURI;
  
          let _pathUrl = '/networks/{networkId}/switch/settings/stp';
          // process template parameters
          _pathUrl = _apiHelper.appendUrlWithTemplateParameters(_pathUrl, {
              networkId: input.networkId,
          });
  
          const _queryBuilder = `${_baseUri}${_pathUrl}`;
  
          // validate and preprocess url
          const _queryUrl = _apiHelper.cleanUrl(_queryBuilder);
  
          // prepare headers
          const _headers = {
              accept: 'application/json',
              'content-type': 'application/json; charset=utf-8',
              'X-Cisco-Meraki-API-Key': _configuration.xCiscoMerakiAPIKey,
              'user-agent': 'APIMATIC 2.0',
          };
  
          // construct the request
          const _options = {
              queryUrl: _queryUrl,
              method: 'PUT',
              headers: _headers,
              body: _apiHelper.jsonSerialize(input.updateNetworkSwitchSettingsStp),
          };
  
          // build the response processing.
          return new Promise((_fulfill, _reject) => {
              _request(_options, (_error, _response, _context) => {
                  let errorResponse;
                  if (_error) {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                      const parsed = JSON.parse(_response.body);
                      _callback(null, parsed, _context);
                      _fulfill(parsed);
                  } else {
                      errorResponse = _baseController.validateResponse(_context);
                      _callback(errorResponse.error, errorResponse.response, errorResponse.context);
                      _reject(errorResponse.error);
                  }
              });
          });
      }
  }
  module.exports = SwitchSettingsController;
  