docs: function(event, callback, force) {
  		
  		var self = this,
  			ok = true;
  		
  		self._trigger({
  			type: 'close',
  			event: event,
  			stop: function() {
  				ok = false;
  			}
  		});
  		
  		// a destroying tooltip (force == true) may not refuse to close
  		if (ok || force) {
  			
  			// save the method custom callback and cancel any open method custom callbacks
  			if (callback) self.__callbacks.close.push(callback);
  			self.__callbacks.open = [];
  			
  			// clear open/close timeouts
  			self.__timeoutsClear();
  			
  			var finishCallbacks = function() {
  				
  				// trigger any close method custom callbacks and reset them
  				$.each(self.__callbacks.close, function(i,c) {
  					c.call(self, self, {
  						event: event,
  						origin: self._$origin[0]
  					});
  				});
  				
  				self.__callbacks.close = [];
  			};
  			
  			if (self.__state != 'closed') {
  				
  				var necessary = true,
  					d = new Date(),
  					now = d.getTime(),
  					newClosingTime = now + self.__options.animationDuration[1];
  				
  				// the tooltip may already already be disappearing, but if a new
  				// call to close() is made after the animationDuration was changed
  				// to 0 (for example), we ought to actually close it sooner than
  				// previously scheduled. In that case it should be noted that the
  				// browser will not adapt the animation duration to the new
  				// animationDuration that was set after the start of the closing
  				// animation.
  				// Note: the same thing could be considered at opening, but is not
  				// really useful since the tooltip is actually opened immediately
  				// upon a call to _open(). Since it would not make the opening
  				// animation finish sooner, its sole impact would be to trigger the
  				// state event and the open callbacks sooner than the actual end of
  				// the opening animation, which is not great.
  				if (self.__state == 'disappearing') {
  					
  					if (	newClosingTime > self.__closingTime
  						// in case closing is actually overdue because the script
  						// execution was suspended. See #679
  						&&	self.__options.animationDuration[1] > 0
  					) {
  						necessary = false;
  					}
  				}
  				
  				if (necessary) {
  					
  					self.__closingTime = newClosingTime;
  					
  					if (self.__state != 'disappearing') {
  						self.__stateSet('disappearing');
  					}
  					
  					var finish = function() {
  						
  						// stop the tracker
  						clearInterval(self.__tracker);
  						
  						// a "beforeClose" option has been asked several times but would
  						// probably useless since the content element is still accessible
  						// via ::content(), and because people can always use listeners
  						// inside their content to track what's going on. For the sake of
  						// simplicity, this has been denied. Bur for the rare people who
  						// really need the option (for old browsers or for the case where
  						// detaching the content is actually destructive, for file or
  						// password inputs for example), this event will do the work.
  						self._trigger({
  							type: 'closing',
  							event: event
  						});
  						
  						// unbind listeners which are no longer needed
  						
  						self._$tooltip
  							.off('.'+ self.__namespace +'-triggerClose')
  							.removeClass('tooltipster-dying');
  						
  						// orientationchange, scroll and resize listeners
  						$(env.window).off('.'+ self.__namespace +'-triggerClose');
  						
  						// scroll listeners
  						self.__$originParents.each(function(i, el) {
  							$(el).off('scroll.'+ self.__namespace +'-triggerClose');
  						});
  						// clear the array to prevent memory leaks
  						self.__$originParents = null;
  						
  						$(env.window.document.body).off('.'+ self.__namespace +'-triggerClose');
  						
  						self._$origin.off('.'+ self.__namespace +'-triggerClose');
  						
  						self._off('dismissable');
  						
  						// a plugin that would like to remove the tooltip from the
  						// DOM when closed should bind on this
  						self.__stateSet('closed');
  						
  						// trigger event
  						self._trigger({
  							type: 'after',
  							event: event
  						});
  						
  						// call our constructor custom callback function
  						if (self.__options.functionAfter) {
  							self.__options.functionAfter.call(self, self, {
  								event: event,
  								origin: self._$origin[0]
  							});
  						}
  						
  						// call our method custom callbacks functions
  						finishCallbacks();
  					};
  					
  					if (env.hasTransitions) {
  						
  						self._$tooltip.css({
  							'-moz-animation-duration': self.__options.animationDuration[1] + 'ms',
  							'-ms-animation-duration': self.__options.animationDuration[1] + 'ms',
  							'-o-animation-duration': self.__options.animationDuration[1] + 'ms',
  							'-webkit-animation-duration': self.__options.animationDuration[1] + 'ms',
  							'animation-duration': self.__options.animationDuration[1] + 'ms',
  							'transition-duration': self.__options.animationDuration[1] + 'ms'
  						});
  						
  						self._$tooltip
  							// clear both potential open and close tasks
  							.clearQueue()
  							.removeClass('tooltipster-show')
  							// for transitions only
  							.addClass('tooltipster-dying');
  						
  						if (self.__options.animationDuration[1] > 0) {
  							self._$tooltip.delay(self.__options.animationDuration[1]);
  						}
  						
  						self._$tooltip.queue(finish);
  					}
  					else {
  						
  						self._$tooltip
  							.stop()
  							.fadeOut(self.__options.animationDuration[1], finish);
  					}
  				}
  			}
  			// if the tooltip is already closed, we still need to trigger
  			// the method custom callbacks
  			else {
  				finishCallbacks();
  			}
  		}
  		
  		return self;
  	}