docs: function(params, callback) {
                  var fileName,
                      fileType,
                      fileSize,
                      fileExtension,
                      uploadUniqueId,
                      uploadThreadId;
  
                  fileName = params.image.name;
                  fileType = params.image.type;
                  fileSize = params.image.size;
                  fileExtension = params.image.name.split('.')
                      .pop();
  
                  if (imageMimeTypes.indexOf(fileType) > 0 || imageExtentions.indexOf(fileExtension) > 0) {
                      uploadImageData = {};
  
                      if (params) {
                          if (typeof params.image !== 'undefined') {
                              uploadImageData.image = params.image;
                              uploadImageData.file = params.image;
                          }
  
                          if (typeof params.fileName == 'string') {
                              uploadImageData.fileName = params.fileName;
                          }
                          else {
                              uploadImageData.fileName = Utility.generateUUID() + '.' + fileExtension;
                          }
  
                          uploadImageData.fileSize = fileSize;
  
                          if (parseInt(params.threadId) > 0) {
                              uploadThreadId = params.threadId;
                              uploadImageData.threadId = params.threadId;
                          }
                          else {
                              uploadThreadId = 0;
                              uploadImageData.threadId = 0;
                          }
  
                          if (typeof params.uniqueId == 'string') {
                              uploadUniqueId = params.uniqueId;
                              uploadImageData.uniqueId = params.uniqueId;
                          }
                          else {
                              uploadUniqueId = Utility.generateUUID();
                              uploadImageData.uniqueId = uploadUniqueId;
                          }
  
                          if (typeof params.originalFileName == 'string') {
                              uploadImageData.originalFileName = params.originalFileName;
                          }
                          else {
                              uploadImageData.originalFileName = fileName;
                          }
  
                          if (parseInt(params.xC) > 0) {
                              uploadImageData.xC = params.xC;
                          }
  
                          if (parseInt(params.yC) > 0) {
                              uploadImageData.yC = params.yC;
                          }
  
                          if (parseInt(params.hC) > 0) {
                              uploadImageData.hC = params.hC;
                          }
  
                          if (parseInt(params.wC) > 0) {
                              uploadImageData.wC = params.wC;
                          }
                      }
  
                      httpRequest({
                          url: SERVICE_ADDRESSES.FILESERVER_ADDRESS + SERVICES_PATH.UPLOAD_IMAGE,
                          method: 'POST',
                          headers: {
                              '_token_': token,
                              '_token_issuer_': 1
                          },
                          data: uploadImageData,
                          uniqueId: uploadUniqueId
                      }, function(result) {
                          if (!result.hasError) {
                              try {
                                  var response = (typeof result.result.responseText == 'string')
                                      ? JSON.parse(result.result.responseText)
                                      : result.result.responseText;
                                  if (typeof response.hasError !== 'undefined' && !response.hasError) {
                                      callback({
                                          hasError: response.hasError,
                                          result: response.result
                                      });
                                  }
                                  else {
                                      callback({
                                          hasError: true,
                                          errorCode: response.errorCode,
                                          errorMessage: response.message
                                      });
                                  }
                              }
                              catch (e) {
                                  callback({
                                      hasError: true,
                                      errorCode: 6300,
                                      errorMessage: CHAT_ERRORS[6300]
                                  });
                              }
                          }
                          else {
                              callback({
                                  hasError: true,
                                  errorCode: result.errorCode,
                                  errorMessage: result.errorMessage
                              });
                          }
                      });
  
                      return {
                          uniqueId: uploadUniqueId,
                          threadId: uploadThreadId,
                          participant: userInfo,
                          content: {
                              caption: params.content,
                              file: {
                                  uniqueId: uploadUniqueId,
                                  fileName: fileName,
                                  fileSize: fileSize,
                                  fileObject: params.file
                              }
                          }
                      };
                  }
                  else {
                      callback({
                          hasError: true,
                          errorCode: 6301,
                          errorMessage: CHAT_ERRORS[6301]
                      });
                  }
              }