/****************************************************************************************************
*																									*
*									Google Maps Intellisence										*
*																									*
*			Documentation from: http://code.google.com/apis/maps/documentation/reference.html		*
*						Developed by: Roger Chapman (http://blog.rodj.org)							*
*				Adapted for API Loader by: Richard Kimber (http://blog.dogma.co.uk)					*
*																									*
*																									*
*****************************************************************************************************/

var google = function() {
};
google.load = function (moduleName, moduleVersion, optionalSettings) {
	/// <summary>
	///	Returns named API.
	/// </summary>
	/// <param name="moduleName" type="String" domElement="false">The name of the API (e.g., "maps" or "search"). The module name also serves as the namespace of the API once it is loaded.</param>
	/// <param name="moduleVersion" type="String" optional="false">The version of the API module.</param>
	/// <param name="optionalSettings" type="Object" optional="true">All optional configuration options for the API you are loading as a JavaScript object literal.</param>
};
google.setOnLoadCallback = function(callback) {
	/// <summary>
	///	Sets callback function for load method.
	/// </summary>
};
google.maps = function() {
};

//class google.maps.Map2

// Constructor
google.maps.Map2 = function (container, opts) {
	/// <summary>
	///	Creates a new map inside of the given HTML container, which is typically a DIV element. If no set of map types is given in the optional argument opts.mapTypes, the default set google.maps.DEFAULT_MAP_TYPES is used. If no size is given in the optional argument opts.size, then the size of the container is used. If opts.size  is given, then the container element of the map is resized accordingly.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="container" domElement="true">The container (DIV element)</param>
	/// <param name="opts" type="google.maps.MapOptions" optional="true"> (optional) The google.maps.Map2 options as javascript object literal. Options are:
	/// 1. size: google.maps.Size - Sets the size in pixels of the map. The container that is passed to the map constructor will be resized to the given size. By default, the map will assume the size of its container.
	/// 2. mapTypes: google.maps.MapType[] - Array of map types to be used by this map. By default, google.maps.DEFAULT_MAP_TYPES is used. You can use this option to restrict the set of predefined map types that is displayed on the map, or to pass your own map types to the map. See also google.maps.Map2.addMapType().
	///	3. draggableCursor: String - The cursor to display when the map is draggable. (Since 2.59)
	/// 4. draggingCursor: String - The cursor to display while dragging the map. (Since 2.59)
	/// 5. googleBarOptions: google.maps.GoogleBarOptions - his property specifies the options to configure the google.maps.GoogleBar search control. These options are passed to the google.maps.MapOptions object literal when the map is constructed, and are used to construct the local google.maps.GoogleBar control when google.maps.Map2.enableGoogleBar() is called. (Since 2.95)
	/// </param>
};

//Methods
google.maps.Map2.prototype = {

// Configuration

	enableDragging: function() {
		/// <summary>
		///	Enables the dragging of the map (enabled by default).
		/// </summary>
	},
	disableDragging: function() {
		/// <summary>
		///	Disables the dragging of the map.
		/// </summary>
	},
	draggingEnabled: function() {
		/// <summary>
		///	Returns true if the dragging of the map is enabled.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	enableInfoWindow: function() {
		/// <summary>
		///	Enables info window operations on the map (enabled by default).
		/// </summary>
	},
	disableInfoWindow: function() {
		/// <summary>
		///	Closes the info window, if it is open, and disables the opening of a new info window.
		/// </summary>
	},
	infoWindowEnabled: function() {
		/// <summary>
		///	Returns true iff the info window is enabled.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	enableDoubleClickZoom: function() {
		/// <summary>
		///	Enables double click to zoom in and out (disabled by default). (Since 2.58)
		/// </summary>
	},
	disableDoubleClickZoom: function() {
		/// <summary>
		///	Disables double click to zoom in and out. (Since 2.58)
		/// </summary>
	},
	doubleClickZoomEnabled: function() {
		/// <summary>
		///	Returns true iff double click to zoom is enabled. (Since 2.58)
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	enableContinuousZoom: function() {
		/// <summary>
		///	Enables continuous smooth zooming for select browsers (disabled by default). (Since 2.58)
		/// </summary>
	},
	disableContinuousZoom: function() {
		/// <summary>
		///	Disables continuous smooth zooming. (Since 2.58)
		/// </summary>
	},
	continuousZoomEnabled: function() {
		/// <summary>
		///	Returns true if continuous smooth zooming is enabled. (Since 2.58)
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	enableGoogleBar: function() {
		/// <summary>
		///	Enables the GoogleBar, an integrated search control, to the map. When enabled, this control takes the place of the default Powered By Google logo. Note that this control is not enabled by default. (Since 2.92)
		/// </summary>
	},
	disableGoogleBar: function() {
		/// <summary>
		///	Disables the GoogleBar integrated search control. When disabled, the default Powered by Google logo occupies the position formerly containing this control. Note that this control is already disabled by default. (Since 2.92)
		/// </summary>
	},
	enableScrollWheelZoom: function() {
		/// <summary>
		///	Enables zooming using a mouse's scroll wheel. Note: scroll wheel zoom is disabled by default. (Since 2.78)
		/// </summary>
	},
	disableScrollWheelZoom: function() {
		/// <summary>
		///	Disables zooming using a mouse's scroll wheel. Note: scroll wheel zoom is disabled by default. (Since 2.78)
		/// </summary>
	},
	scrollWheelZoomEnabled: function() {
		/// <summary>
		///	Returns a Boolean indicating whether scroll wheel zooming is enabled. (Since 2.78)
		/// </summary>
		/// <returns type="Boolean"></returns>
	},

// Controls

	addControl: function(control,  position) {
		/// <summary>
		///	Adds the control to the map. The position on the map is determined by the optional position argument. If this argument is absent, the default position of the control is used, as determined by the google.maps.Control.getDefaultPosition() method. A control instance must not be added more than once to the map.
		/// </summary>
		/// <param name="control" type="google.maps.Control">The control to add</param>
		/// <param name="position" type="google.maps.ControlPosition" optional="true">(optional) The position of the control</param>
	},
	removeControl: function(control) {
		/// <summary>
		///	Removes the control from the map. It does nothing if the control was never added to the map.
		/// </summary>
		/// <param name="control" type="google.maps.Control">The control to remove</param>
	},
	getContainer: function() {
		/// <summary>
		///	Returns the DOM object that contains the map. Used by google.maps.Control.initialize().
		/// </summary>
		/// <returns domElement="true"></returns>
	},

// Map Types

	getMapTypes: function() {
		/// <summary>
		///	Returns the array of map types registered with this map.
		/// </summary>
		/// <returns type="google.maps.MapType[]"></returns>
	},
	getCurrentMapType: function() {
		/// <summary>
		///	Returns the currently selected map type.
		/// </summary>
		/// <returns type="google.maps.MapType"></returns>
	},
	setMapType: function(type) {
		/// <summary>
		///Selects the given new map type. The type must be known to the map. See the constructor, and the method addMapType().
		/// </summary>
		/// <param name="type" type="google.maps.MapType">The map type to set</param>
	},
	addMapType: function(type) {
		/// <summary>
		///	Adds a new map type to the map. See section google.maps.MapType for how to define custom map types.
		/// </summary>
		/// <param name="type" type="google.maps.MapType">The map type to add</param>
	},
	removeMapType: function(type) {
		/// <summary>
		///	Removes the map type from the map. Will update the set of buttons displayed by the google.maps.MapTypeControl or GHierarchicalMapTypeControl and fire the removemaptype event.
		/// </summary>
		/// <param name="type" type="google.maps.MapType">The map type to remove</param>
	},

// Map State

	isLoaded: function() {
		/// <summary>
		///	Returns true iff the map was initialized by setCenter() since it was created.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	getCenter: function() {
		/// <summary>
		///	Returns the geographical coordinates of the center point of the map view.
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
	},
	getBounds: function() {
		/// <summary>
		///	Returns the the visible rectangular region of the map view in geographical coordinates.
		/// </summary>
		/// <returns type="google.maps.LatLngBounds"></returns>
	},
	getBoundsZoomLevel: function(bounds) {
		/// <summary>
		///Returns the zoom level at which the given rectangular region fits in the map view. The zoom level is computed for the currently selected map type. If no map type is selected yet, the first on the list of map types is used.
		/// </summary>
		/// <returns type="Number" integer="true"></returns>
		/// <param name="bounds" type="google.maps.LatLngBounds">The lat/long bounds</param>
	},
	getSize: function() {
		/// <summary>
		///	Returns the size of the map view in pixels.
		/// </summary>
		/// <returns type="google.maps.Size"></returns>
	},
	getZoom: function() {
		/// <summary>
		///	Returns the current zoom level.
		/// </summary>
		/// <returns type="Number"></returns>
	},
	getDragObject: function() {
		/// <summary>
		///	Returns the draggable object used by this map. (Since 2.93)
		/// </summary>
		/// <returns type="google.maps.DraggableObject"></returns>
	},	

// Modify the Map State

	setCenter: function(center, zoom, type) {
		/// <summary>
		///	Sets the map view to the given center. Optionally, also sets zoom level and map type. The map type must be known to the map. See the constructor, and the method addMapType(). This method must be called first after construction to set the initial state of the map. It is an error to call other operations on the map after construction.
		/// </summary>
		/// <param name="center" type="google.maps.LatLng">The lat/long of the central point</param>
	},
	panTo: function(center) {
		/// <summary>
		///	Changes the center point of the map to the given point. If the point is already visible in the current map view, change the center in a smooth animation.
		/// </summary>
		/// <param name="center" type="google.maps.LatLng">The lat/long of the central point</param>
	},
	panBy: function(distance) {
		/// <summary>
		///	Starts a pan animation by the given distance in pixels.
		/// </summary>
		/// <param name="distance" type="Number" integer="true">The distance in pixels</param>
	},
	panDirection: function(dx, dy) {
		/// <summary>
		///	Starts a pan animation by half the width of the map in the indicated directions. +1 is right and down, -1 is left and up, respectively.
		/// </summary>
		/// <param name="dx" type="Number" integer="true">distance along x-axis</param>
		/// <param name="dy" type="Number" integer="true">distance along y-axis</param>
	},
	setZoom: function(level) {
		/// <summary>
		///	Sets the zoom level to the given new value.
		/// </summary>
		/// <param name="level" type="Number" integer="true">Zoom level</param>
	},
	zoomIn: function() {
		/// <summary>
		///	Increments zoom level by one.
		/// </summary>
	},
	zoomOut: function() {
		/// <summary>
		///	Decrements zoom level by one.
		/// </summary>
	},
	savePosition: function() {
		/// <summary>
		///	Stores the current map position and zoom level for later recall by returnToSavedPosition().
		/// </summary>
	},
	returnToSavedPosition: function() {
		/// <summary>
		///	Restores the map view that was saved by savePosition().
		/// </summary>
	},
	checkResize: function() {
		/// <summary>
		///	Notifies the map of a change of the size of its container. Call this method after the size of the container DOM object has changed, so that the map can adjust itself to fit the new size.
		/// </summary>
	},

// Overlays

	addOverlay: function(overlay) {
		/// <summary>
		///	Adds an overlay to the map and fires the addoverlay event.
		/// </summary>
		/// <param name="overlay" type="google.maps.Overlay">The overlay to add</param>
	},
	removeOverlay: function(overlay) {
		/// <summary>
		///	Removes the overlay from the map. If the overlay was on the map, it fires the removeoverlay event.
		/// </summary>
		/// <param name="overlay" type="google.maps.Overlay"></param>
	},
	clearOverlays: function() {
		/// <summary>
		///	Removes all overlay from the map, and fires the clearoverlays event.
		/// </summary>
	},
	getPane: function(pane) {
		/// <summary>
		///	Returns a DIV that holds the object in the layer identified by pane. Used by google.maps.Overlay instances in method google.maps.Overlay.initialize() instances to draw themselves on the map.
		/// </summary>
		/// <returns domElement="true"></returns>
		/// <param name="pane" type="google.maps.MapPane"></param>
	},	

//Info Window

	openInfoWindow: function(latlong, node, opts) {
		/// <summary>
		///	Opens a simple info window at the given point. Pans the map such that the opened info window is fully visible. The content of the info window is given as a DOM node.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The point to open the window</param>
		/// <param name="node" domElement="true">The DOM node for the contents of the window.</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	openInfoWindowHtml: function(latlong, html, opts) {
		/// <summary>
		///	Opens a simple info window at the given point. Pans the map such that the opened info window is fully visible. The content of the info window is given as HTML text.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The point to open the window</param>
		/// <param name="html" type="String">The html text contents</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	openInfoWindowTabs: function(latlong, tabs, opts) {
		/// <summary>
		///	Opens a tabbed info window at the given point. Pans the map such that the opened info window is fully visible. The content of the info window is given as DOM nodes.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The point to open the window</param>
		/// <param name="tabs" type="google.maps.InfoWindowTab">The DOM elements for the contents</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	openInfoWindowTabsHtml: function(latlong, html, opts) {
		/// <summary>
		///	Opens a tabbed info window at the given point. Pans the map such that the opened info window is fully visible. The content of the info window is given as HTML text.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The point to open the window</param>
		/// <param name="html" type="String">The html text contents</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	showMapBlowup: function(latlong, opts) {
		/// <summary>
		///	Opens an info window at the given point that contains a closeup view on the map around this point.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The point to open the window</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	updateInfoWindow: function(tabs, onupdate) {
		/// <summary>
		///	Updates the content of the currently open google.maps.InfoWindow  object, without repositioning. The info window is resized to fit the new content. The optional onupdate callback function is called after the info window content is actually changed. (Since 2.85)
		/// </summary>
		/// <param name="tabs" type="google.maps.InfoWindowTab">The DOM elements for the contents</param>
		/// <param name="onupdate" type="function" optional="true">(optional) callback function</param>
	},
	updateCurrentTab: function(modifier, onupdate) {
		/// <summary>
		///	Updates the currently selected tab, causing a resize of the google.maps.InfoWindow object, without repositioning. The modifier function is used to modify the currently selected tab and is passed a google.maps.InfoWindowTab as an argument. The optional onupdate callback function is called after the info window displays the new content. (Since 2.85)
		/// </summary>
		/// <param name="modifier" type="function">modify function</param>
		/// <param name="onupdate" type="function" optional="true">(optional) callback function</param>
	},
	closeInfoWindow: function() {
		/// <summary>
		///	Closes the currently open info window.
		/// </summary>
	},
	getInfoWindow: function() {
		/// <summary>
		///	Returns the info window object of this map. If no info window exists yet, it is created, but not displayed. This operation is not influenced by enableInfoWindow().
		/// </summary>
		/// <returns type="google.maps.InfoWindow"></returns>
	},	

// Coordinate Transformations

	fromContainerPixelToLatLng: function(pixel) {
		/// <summary>
		///	Computes the geographical coordinates of the point at the given pixel coordinates in the DOM element that contains the map on the page. This is helpful for when you implement interaction of custom controls with the map.
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
		/// <param name="pixel" type="google.maps.Point">The point in the DOM element</param>
	},
	fromLatLngToContainerPixel: function(latlong) {
		/// <summary>
		///	Computes the pixel coordinates of the given geographical point in the DOM element that contains the map on the page. (Since 2.100)
		/// </summary>
		/// <returns type="google.maps.Point"></returns>
		/// <param name="latlong" type="google.maps.LatLng">The Lat/Long</param>
	},
	fromLatLngToDivPixel: function(latlong) {
		/// <summary>
		///	Computes the pixel coordinates of the given geographical point in the DOM element that holds the draggable map. You need this method to position a custom overlay when you implement the google.maps.Overlay.redraw() method for a custom overlay.
		/// </summary>
		/// <returns type="google.maps.Point"></returns>
		/// <param name="latlong" type="google.maps.LatLng">The Lat/Long</param>
	},
	fromDivPixelToLatLng: function(pixel) {
		/// <summary>
		///	Computes the geographical coordinates from pixel coordinates in the div that holds the draggable map. This may be helpful for when you implement interaction with custom overlays that don't extend the google.maps.Overlay interface. If this doesn't give you the expected output, try the fromContainerPixelToLatLng method instead.
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
		/// <param name="pixel" type="google.maps.Point">The point in the DOM element</param>
	}
};

// enum GGoogleBarLinkTarget
google.maps.GOOGLEBAR_LINK_TARGET_BLANK = {};
google.maps.GOOGLEBAR_LINK_TARGET_PARENT = {};
google.maps.GOOGLEBAR_LINK_TARGET_SELF = {};
google.maps.GOOGLEBAR_LINK_TARGET_TOP = {};

//enum GGoogleBarResultList
google.maps.GOOGLEBAR_RESULT_LIST_INLINE = {};
google.maps.GOOGLEBAR_RESULT_LIST_SUPPRESS = {};

//enum GMapPane 
google.maps.MAP_MAP_PANE = {};
google.maps.MAP_MARKER_SHADOW_PANE = {};
google.maps.MAP_MARKER_PANE = {};
google.maps.MAP_FLOAT_SHADOW_PANE = {};
google.maps.MAP_MARKER_MOUSE_TARGET_PANE = {};
google.maps.MAP_FLOAT_PANE = {};

// class google.maps.KeyboardHandler
google.maps.KeyboardHandler = function(map) {
	/// <summary>
	///	Instantiate this class to add keyboard bindings to a map. The key bindings are the same as for the maps application.
	/// </summary>
	/// <param name="map" type="google.maps.Map2">The Google map object</param>
};

// interface google.maps.Overlay
google.maps.Overlay = function() {
	/// <summary>
	///	This interface is implemented by the google.maps.Marker, google.maps.Polyline, google.maps.TileLayerOverlay  and google.maps.InfoWindow classes in the maps API library. You can implement it if you want to display custom types of overlay objects on the map. An instance of google.maps.Overlay can be put on the map with the method google.maps.Map2.addOverlay(). The map will then call the method google.maps.Overlay.initialize() on the overlay instance to display itself on the map initially. Whenever the map display changes, the map will call google.maps.Overlay.redraw() so that the overlay can reposition itself if necessary. The overlay instance can use the method google.maps.Map2.getPane() to get hold of one or more DOM container elements to attach itself to.
	/// </summary>
	/// <returns type="Object"></returns>
};

google.maps.Overlay.prototype = {
	getZIndex: function(latitude) {
		/// <summary>
		///	Returns a CSS z-index value for a given latitude. It computes a z index such that overlays further south are on top of overlays further north, thus creating the 3D appearance of marker overlays.
		/// </summary>
		/// <returns type="Number" integer="true"></returns>
	}
};

// class google.maps.InfoWindow
google.maps.InfoWindow = function() {
	/// <summary>
	///	google.maps.InfoWindow has no constructor. It is created by the map and accessed by its method google.maps.Map2.getInfoWindow().
	/// </summary>	
};

google.maps.InfoWindow.prototype = {
	selectTab: function(index) {
		/// <summary>
		///	Selects the tab with the given index. This has the same effect as clicking on the corresponding tab.
		/// </summary>
		/// <param name="index" type="Number" integer="true">The index to select</param>
	},
	hide: function() {
		/// <summary>
		///	Makes the info window invisible. NOTE: This doesn't close the info window. It can be made visible again using show().
		/// </summary>
	},
	show: function() {
		/// <summary>
		///	Makes the info window visible if its currently invisible.
		/// </summary>
	},
	isHidden: function() {
		/// <summary>
		///	Returns true if the info window is hidden. This includes the state that it's closed.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	reset: function(latlong, tabs, size, offset, selectedTab) {
		/// <summary>
		///	Resets the state of the info window. Each argument may be null and then its value will not be changed from the current value.
		/// </summary>
		/// <param name="latlong" type="google.maps.LatLng">The Lat/Long to reset</param>
		/// <param name="tabs" type="google.maps.InfoWindowTab">The tabs to reset</param>
		/// <param name="size" type="google.maps.Size">The size to reset</param>
		/// <param name="offset" type="google.maps.Size" optional="true">(optional) The offset to reset</param>
		/// <param name="selectedTab" type="Number" integer="true">The selected index to reset</param>
	},
	getPoint: function() {
		/// <summary>
		///	Returns the geographical point at which the info window is anchored. The tip of the window points to this point on the map, modulo the pixel offset.
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
	},
	getPixelOffset: function() {
		/// <summary>
		///	Returns the offset, in pixels, of the tip of the info window from the point on the map at whose geographical coordinates the info window is anchored.
		/// </summary>
		/// <returns type="google.maps.Size"></returns>
	},
	getSelectedTab: function() {
		/// <summary>
		///	Returns the index, starting at 0, of the current selected tab.
		/// </summary>
		/// <returns type="Number" integer="true"></returns>
	},
	getTabs: function() {
		/// <summary>
		///	Returns the array of tabs in this info window. (Since 2.59)
		/// </summary>
		/// <returns type="google.maps.InfoWindowTabs[]"></returns>
	},
	getContentContainers: function() {
		/// <summary>
		///	Returns the array of DOM nodes that hold the content of the tabs of this info window. (Since 2.59)
		/// </summary>
		/// <returns type="elementDomElement"></returns>
	},
	enableMaximize: function() {
		/// <summary>
		///	Enables maximization of the info window. A maximizable info window expands to fill most of the map with contents specified via the maxContent and maxTitle  properties of google.maps.InfoWindowOptions. The info window must have been opened with maxContent or maxTitle options in order for enableMaximize() or disableMaximize  to have any effect. An info window opened with maxContent or maxTitle will have maximization enabled by default. (Since 2.93)
		/// </summary>
	},
	disableMaximize: function() {
		/// <summary>
		///	Disables maximization of the info window. The infowindow must have been opened with maxContent or maxTitle options. Note that if the info window is currently opened, this function will remove the maximize buton but will not restore the window to its minimized state. (Since 2.93)
		/// </summary>
	},
	maximize: function() {
		/// <summary>
		///	Maximizes the infowindow. The infowindow must have been opened with maxContent or maxTitle options, and it must not have had its maximization disabled through disableMaximize. (Since 2.93).
		/// </summary>
	},
	restore: function() {
		/// <summary>
		///	Restores the info window to its default (non-maximized) state. The infowindow must have been opened with maxContent or maxTitle options. (Since 2.93).
		/// </summary>
	}
};

// class google.maps.InfoWindowTab
google.maps.InfoWindowTab = function(label, content) {
	/// <summary>
	///	Creates an info window tab data structure that can be passed in the tabs argument to openInfoWindowTabs*() methods.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="label" type="String" >The tab label</param>
	/// <param name="content" domElement="true">The tab contents</param>
};

// class google.maps.Marker
google.maps.Marker = function(latlong, opts) {
	/// <summary>
	///	1. google.maps.Marker(latlng, opts) - Creates a marker at the latlng with options specified in google.maps.MarkerOptions. By default markers are clickable & have the default icon google.maps.DEFAULT_ICON. (Since 2.50).
	///	2. google.maps.Marker(latlong, icon, inert) - Creates a marker at the passed latlng of either google.maps.Point or google.maps.LatLng with icon or the google.maps.DEFAULT_ICON. If the inert flag is true, then the marker is not clickable and will not fire any events. (Deprecated since 2.50).
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="latlong" type="google.maps.LatLng" >The Lat/Long of the marker</param>
	/// <param name="opts" type="google.maps.MarkerOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. icon: google.maps.Icon - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. dragCrossMove: Boolean - Maximum width of the info window content, in pixels.
		/// 3. title: String - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. clickable: Boolean - Function is called after the info window is opened and the content is displayed.
		/// 5. draggable: Boolean - Function is called when the info window is closed.
		/// 6. bouncy: Boolean - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. bounceGravity: Number - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. autoPan: Boolean - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. zIndexProcess: function - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// </param>
};

google.maps.Marker.prototype = {
	openInfoWindow: function(content, opts) {
		/// <summary>
		///	Opens the map info window over the icon of the marker. The content of the info window is given as a DOM node. Only option google.maps.InfoWindowOptions.maxWidth is applicable.
		/// </summary>
		/// <param name="content" domElement="true">The contents of the window</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// </param>
	},
	openInfoWindowHtml: function(content, opts) {
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as DOM nodes. Only options google.maps.InfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="content" type="String">The contents of the window as html text</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	openInfoWindowTabs: function(tabs, opts) {
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as DOM nodes. Only options google.maps.InfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="tabs" type="google.maps.InfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	openInfoWindowTabsHtml: function(tabs, opts) {
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as Strings that contain HTML text. Only options InfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="tabs" type="google.maps.InfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	bindInfoWindow: function(content, opts) {
		/// <summary>
		///	Binds the given DOM node to this marker. The content within this node will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85).
		/// </summary>
		/// <param name="content" domElement="true">The contents</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	bindInfoWindowHtml: function(content, opts) {
		/// <summary>
		///	Binds the given HTML to this marker. The HTML content will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85)
		/// </summary>
		/// <param name="content" type="String">The contents as HTML text.</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	bindInfoWindowTabs: function(tabs, opts) {
		/// <summary>
		///	Binds the given google.maps.InfoWindowTabs (provided as DOM nodes) to this marker. The content within these tabs' nodes will be automatically displayed in the info window when the marker is clicked. Pass tabs as null to unbind. (Since 2.85).
		/// </summary>
		/// <param name="tabs" type="google.maps.InfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	bindInfoWindowTabsHtml: function(tabs, opts) {
		/// <summary>
		///	Binds the given google.maps.InfoWindowTabs (provided as strings of HTML) to this marker. The HTML content within these tabs will be automatically displayed in the info window when the marker is clicked. Pass tabs as null  to unbind. (Since 2.85).
		/// </summary>
		/// <param name="tabs" type="google.maps.InfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: google.maps.Size - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given google.maps.LatLng. (Since 2.98).
		/// </param>
	},
	closeInfoWindow: function() {
		/// <summary>
		///	Closes the info window only if it belongs to this marker. (Since 2.85).
		/// </summary>
	},
	showMapBlowup: function(opts) {
		/// <summary>
		///		Opens the map info window over the icon of the marker. The content of the info window is a closeup map around the marker position. Only options InfoWindowOptions.zoomLevel  and InfoWindowOptions.mapType are applicable.
		/// </summary>
		/// <param name="opts" type="google.maps.InfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 2. mapType: google.maps.MapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// </param>
	},
	getIcon: function() {
		/// <summary>
		///	Returns the icon of this marker, as set by the constructor.
		/// </summary>
		/// <returns type="google.maps.Icon"></returns>
	},
	getTitle: function() {
		/// <summary>
		///	Returns the title of this marker, as set by the constructor via the google.maps.MarkerOptions.title property. Returns undefined if no title is passed in. (Since 2.85)
		/// </summary>
		/// <returns type="String"></returns>
	},
	getPoint: function() {
		/// <summary>
		///	Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setPoint(). (Deprecated since 2.88).
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
	},
	getLatLng: function() {
		/// <summary>
		///	Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setLatLng(). (Since 2.88).
		/// </summary>
		/// <returns type="google.maps.LatLng"></returns>
	},
	setPoint: function(latlng) {
		/// <summary>
		///	Sets the geographical coordinates of the point at which this marker is anchored. (Deprecated since 2.88).
		/// </summary>
		/// <param name="latlng" type="google.maps.LatLng">The Lat/Long to set.</param>
	},
	setLatLng: function(latlng) {
		/// <summary>
		///	Sets the geographical coordinates of the point at which this marker is anchored. (Since 2.88).
		/// </summary>
		/// <param name="latlng" type="google.maps.LatLng">The Lat/Long to set.</param>
	},
	enableDragging: function() {
		/// <summary>
		///	Enables the marker to be dragged and dropped around the map. To function, the marker must have been initialized with google.maps.MarkerOptions.draggable = true.
		/// </summary>
	},
	disableDragging: function() {
		/// <summary>
		///	Disables the marker from being dragged and dropped around the map.
		/// </summary>
	},
	draggable: function() {
		/// <summary>
		///	Returns true if the marker has been initialized via the constructor using google.maps.MarkerOptions.draggable = true. Otherwise, returns false.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	draggingEnabled: function() {
		/// <summary>
		///	Returns true if the marker is currently enabled for the user to drag on the map.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	setImage: function(url) {
		/// <summary>
		///	Requests the image specified by the url to be set as the foreground image for this marker. Note that neither the print image nor the shadow image are adjusted. Therefore this method is primarily intended to implement highlighting or dimming effects, rather than drastic changes in marker's appearances. (Since 2.75).
		/// </summary>
		/// <param name="url" type="String">The url of the image.</param>
	},
	hide: function() {
		/// <summary>
		///	Hides the marker if it is currently visible. Note that this function triggers the event google.maps.Marker.visibilitychanged in case the marker is currently visible. (Since 2.77).
		/// </summary>
	},
	show: function() {
		/// <summary>
		///	Shows the marker if it is currently hidden. Note that this function triggers the event google.maps.Marker.visibilitychanged in case the marker is currently hidden. (Since 2.77).
		/// </summary>
	},
	isHidden: function() {
		/// <summary>
		///	Returns true if the marker is currently hidden. Otherwise returns false. (Since 2.77)
		/// </summary>
	}
};

// TODO: class google.maps.Polyline
// TODO: class google.maps.Polygon
// TODO: class google.maps.ScreenOverlay
// TODO: class google.maps.ScreenPoint
// TODO: class google.maps.ScreenSize
// TODO: class google.maps.GroundOverlay

//class google.maps.Icon
google.maps.Icon = function(copy, image) {
	/// <summary>
	///	Creates a new icon object. If another icon is given in the optional copy argument, its properties are copied, otherwise they are left empty. The optional argument image sets the value of the image  property.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="copy" type="google.maps.Icon" optional="true">(optional) The icon to copy. Note that you can use the default Maps icon google.maps.DEFAULT_ICON if you don't want to specify your own.</param>
	/// <param name="image" type="String" optional="true">(optional) The foreground image URL of the icon.</param>
	/// <field name="image" type="String">The foreground image URL of the icon.</field>
	/// <field name="shadow" type="String">The shadow image URL of the icon.</field>
	/// <field name="iconSize" type="google.maps.Size">The pixel size of the foreground image of the icon.</field>
	/// <field name="shadowSize" type="google.maps.Size">The pixel size of the shadow image.</field>
	/// <field name="iconAnchor" type="google.maps.Point">The pixel coordinate relative to the top left corner of the icon image at which this icon is anchored to the map.</field>
	/// <field name="infoWindowAnchor" type="google.maps.Point">The pixel coordinate relative to the top left corner of the icon image at which the info window is anchored to this icon.</field>
	/// <field name="printImage" type="String">The URL of the foreground icon image used for printed maps. It must be the same size as the main icon image given by image.</field>
	/// <field name="mozPrintImage" type="String">The URL of the foreground icon image used for printed maps in Firefox/Mozilla. It must be the same size as the main icon image given by image.</field>
	/// <field name="printShadow" type="String">The URL of the shadow image used for printed maps. It should be a google.maps.IF image since most browsers cannot print PNG images.</field>
	/// <field name="transparent" type="String">The URL of a virtually transparent version of the foreground icon image used to capture click events in Internet Explorer. This image should be a 24-bit PNG version of the main icon image with 1% opacity, but the same shape and size as the main icon.</field>
	/// <field name="imageMap" type="elementInteger">An array of integers representing the x/y coordinates of the image map we should use to specify the clickable part of the icon image in browsers other than Internet Explorer.</field>
	/// <field name="maxHeight" type="Number" integer="true">An array of integers representing the x/y coordinates of the image map we should use to specify the clickable part of the icon image in browsers other than Internet Explorer.</field>
	/// <field name="dragCrossImage" type="String">Specifies the cross image URL when an icon is dragged. (Since 2.79)</field>
	/// <field name="dragCrossSize" type="google.maps.Size">Specifies the pixel size of the cross image when an icon is dragged. (Since 2.79)</field>
	/// <field name="dragCrossAnchor" type="google.maps.Point">Specifies the pixel coordinate offsets (relative to the iconAnchor) of the cross image when an icon is dragged. (Since 2.79)</field>
};

google.maps.DEFAULT_ICON = {};

google.maps.Icon.prototype = {
	image: {},
	shadow: {},
	iconSize: {},
	shadowSize: {},
	iconAnchor: {},
	infoWindowAnchor: {},
	printImage: {},
	mozPrintImage: {},
	printShadow: {},
	transparent: {},
	imageMap: {},
	maxHeight: {},
	dragCrossImage: {},
	dragCrossSize: {},
	dragCrossAnchor: {}
};

// class google.maps.Point
google.maps.Point = function(x, y) {
	/// <summary>
	///	Creates a google.maps.Point object.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="x" type="Number" integer="true"> x coordinate. (This value increases to the right in the Google Maps coordinate system.)</param>
	/// <param name="y" type="Number" integer="true">y coordinate. (This value increases downwards in the Google Maps coordinate system.)</param>
	/// <field name="x" type="Number" integer="true"> x coordinate. (This value increases to the right in the Google Maps coordinate system.)</field>
	/// <field name="y" type="Number" integer="true">y coordinate. (This value increases downwards in the Google Maps coordinate system.)</field>
};

google.maps.Point.prototype = {
	x: {},
	y: {},
	equals: function(other) {
		/// <summary>
		///	Returns true if the other point has equal coordinates.
		/// </summary>
		/// <returns type="Boolean"></returns>
		/// <param name="other" type="google.maps.Point">The point to compare.</param>
	},
	toString: function() {
		/// <summary>
		///	Returns a string that contains the x and y coordinates, in this order, separated by a comma.
		/// </summary>
		/// <returns type="String"></returns>
	}
};

//class google.maps.Size
google.maps.Size = function(width, height) {
	/// <summary>
	///	Creates a google.maps.Size object.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="width" type="Number" integer="true">The width parameter.</param>
	/// <param name="height" type="Number" integer="true">The height parameter.</param>
	/// <field name="width" type="Number" integer="true">The width parameter.</field>
	/// <field name="height" type="Number" integer="true">The height parameter.</field>
};

google.maps.Size.prototype = {
	width: {},
	height: {},
	equals: function(other) {
		/// <summary>
		///	Returns true iff the other size has exactly equal components.
		/// </summary>
		/// <returns type="Boolean"></returns>
		/// <param name="other" type="google.maps.Size">The size to compare.</param>
	},
	toString: function() {
		/// <summary>
		///	Returns a string that contains the wdith and height parameter, in this order, separated by a comma.
		/// </summary>
		/// <returns type="String"></returns>
	}
};



// TODO: class google.maps.Bounds
	
// class google.maps.LatLng
google.maps.LatLng = function(lat, lng, unbounded) {
	/// <summary>
	///	google.maps.LatLng is a point in geographical coordinates longitude and latitude. Notice the ordering of latitude and longitude. If the unbounded flag is true, then the numbers will be used as passed, otherwise latitude will be clamped to lie between -90 degrees and +90 degrees, and longitude will be wrapped to lie between -180 degrees and +180 degrees.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="lat" type="Number" >The latitude coordinate in degrees, as a number between -90 and +90.</param>
	/// <param name="lng" type="Number" >The longitude coordinate in degrees, as a number between -180 and +180.</param>
	// <param name="unbounded" type="Boolean" >(optional) If true, then the numbers will be used as passed, otherwise latitude will be clamped to lie between -90 degrees and +90 degrees, and longitude will be wrapped to lie between -180 degrees and +180 degrees.</param>

};

google.maps.LatLng.prototype = {
	lat: function() {
		/// <summary>
		///	Returns the latitude coordinate in degrees, as a number between -90 and +90. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.
		/// </summary>
		/// <returns type="Number"></returns>
	},
	lng: function() {
		/// <summary>
		///	Returns the longitude coordinate in degrees, as a number between -180 and +180. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.
		/// </summary>
		/// <returns type="Number"></returns>
	},
	latRadians: function() {
		/// <summary>
		///	Returns the latitude coordinate in radians, as a number between -PI/2 and +PI/2. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.
		/// </summary>
		/// <returns type="Number"></returns>
	},
	lngRadians: function() {
		/// <summary>
		///	Returns the longitude coordinate in radians, as a number between -PI and +PI. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.
		/// </summary>
		/// <returns type="Number"></returns>
	},
	equals: function(other) {
		/// <summary>
		///	Returns true iff the other size has equal components, within certain roundoff margins.
		/// </summary>
		/// <returns type="Boolean"></returns>
		/// <param name="other" type="google.maps.LatLng">The Lat/Long to compare.</param>
	},
	distanceFrom: function(other, radius) {
		/// <summary>
		///	Returns the distance, in meters, from this point to the given point. By default, this distance is calculated given the default equatorial earth radius of 6378137 meters. The earth is approximated as a sphere, hence the distance could be off as much as 0.3%, especially in the polar extremes. You may also pass an optional radius  argument to calculate distances between google.maps.LatLng coordinates on spheres of a different radius than earth. (Since 2.89).
		/// </summary>
		/// <returns type="Number"></returns>
		/// <param name="other" type="google.maps.LatLng">The Lat/Long to compare.</param>
		/// <param name="radius" type="Number" optional="true">(optional) The radus to calculate distances between.</param>
	},
	toUrlValue: function(precision) {
		/// <summary>
		///	Returns a string that represents this point in a format suitable for use as a URL parameter value, separated by a comma, without whitespace. By default, precision is returned to 6 digits, which corresponds to a resolution to 4 inches/ 11 centimeters. An optional precision  parameter allows you to specify a lower precision to reduce server load. Note: prior to 2.78, this  precision parameter was not available. (Since 2.78).
		/// </summary>
		/// <returns type="String"></returns>
		/// <param name="precision" type="Number" optional="true">(optional) The precision to return.</param>
	}
};

// TODO: class google.maps.LatLngBounds

// interface google.maps.Control
google.maps.Control = function(printable, selectable) {
	/// <summary>
	///	Creates the prototype instance for a new control class. Flag printable indicates that the control should be visible in the print output of the map. Flag selectable indicates that the control will contain text that should be selectable.
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="printable" type="Boolean" optional="true">(optional) Is control printable?</param>
	/// <param name="selectable" type="Boolean" optional="true">(optional) Is control selectable?</param>
};

google.maps.Control.prototype = {
	printable: function() {
		/// <summary>
		///	Returns to the map if the control should be printable.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	selectable: function() {
		/// <summary>
		///	Returns to the map if the control contains selectable text.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	initialize: function(map) {
		/// <summary>
		///	Will be called by the map so the control can initialize itself. The control will use the method google.maps.Map2.getContainer() to get hold of the DOM element that contains the map, and add itself to it. It returns the added element.
		/// </summary>
		/// <returns domElement="true"></returns>
		/// <param name="map" type="google.maps.Map2">The map to initialize.</param>
	},
	getDefaultPosition: function() {
		/// <summary>
		///	Returns to the map the position in the map view at which the control appears by default. This will be overridden by the second argument to google.maps.Map2.addControl().
		/// </summary>
		/// <returns type="	google.maps.ControlPosition"></returns>
	}
};

//class google.maps.Control
google.maps.SmallMapControl = function() {
	/// <summary>
	///	Creates a control with buttons to pan in four directions, and zoom in and zoom out.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
};
google.maps.SmallMapControl.prototype = new google.maps.Control();

google.maps.LargeMapControl = function() {
	/// <summary>
	///	Creates a control with buttons to pan in four directions, and zoom in and zoom out, and a zoom slider.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
};
google.maps.LargeMapControl.prototype = new google.maps.Control();

google.maps.SmallZoomControl = function() {
	/// <summary>
	///	Creates a control with buttons to zoom in and zoom out.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
};
google.maps.SmallZoomControl.prototype = new google.maps.Control();

google.maps.ScaleControl = function() {
	/// <summary>
	///	Creates a control that displays the map scale.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
};
google.maps.ScaleControl.prototype = new google.maps.Control();

// class google.maps.MapTypeControl
google.maps.MapTypeControl = function(useShortNames) {
	/// <summary>
	///	Creates a standard map type control for selecting and switching between supported map types via buttons.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
	/// <param name="useShortNames" type="Boolean" optional="true">(Optional) If true use the short (alt) names for the map types else long names by default.</param>
};
google.maps.MapTypeControl.prototype = new google.maps.Control();

// class google.maps.MenuMapTypeControl
google.maps.MenuMapTypeControl = function(useShortNames) {
	/// <summary>
	///	Creates a drop-down map type control for switching between supported map types.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
	/// <param name="useShortNames" type="Boolean" optional="true">(Optional) If true use the short (alt) names for the map types else long names by default.</param>
};
google.maps.MenuMapTypeControl.prototype = new google.maps.Control();


// class GHierarchicalMapTypeControl
GHierarchicalMapTypeControl = function() {
	/// <summary>
	///	Creates a "nested" map type control for selecting and switching between supported map types via buttons and nested checkboxes.
	/// </summary>
	/// <returns type="google.maps.Control"></returns>
};
GHierarchicalMapTypeControl.prototype = {
	addRelationship: function(parentType,  childType, childText, isDefault) {
		/// <summary>
		///	Registers a parent/child relationship between map types with the control. If childText is given, it will be displayed next to the checkbox for the child map type instead of its name. If isDefault is true, the child map type will be selected by default. Note that all relationships must be set up before the control is added. (Adding relationships after the control is added will have no effect.) (Since 2.94).
		/// </summary>
		/// <param name="parentType" type="google.maps.MapType">The parent map type.</param>
		/// <param name="childType" type="google.maps.MapType">The child map type.</param>
		/// <param name="childText" type="String" optional="true">(optional) Text to be displayed next to the checkbox for the child map type instead of its name.</param>
		/// <param name="isDefault" type="Boolean" optional="true">(optional) If true, the child map type will be selected by default.</param>
	},
	removeRelationship: function(mapType) {
		/// <summary>
		///	Removes all relationships involving a map type from the control. (Since 2.94)
		/// </summary>
		/// <param name="mapType" type="google.maps.MapType">The map type to remove.</param>
	},
	clearRelationships: function() {
		/// <summary>
		///	Removes all relationships from the control. (Since 2.94)
		/// </summary>
	},
	printable: function() {
		/// <summary>
		///	Returns to the map if the control should be printable.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	selectable: function() {
		/// <summary>
		///	Returns to the map if the control contains selectable text.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	initialize: function(map) {
		/// <summary>
		///	Will be called by the map so the control can initialize itself. The control will use the method google.maps.Map2.getContainer() to get hold of the DOM element that contains the map, and add itself to it. It returns the added element.
		/// </summary>
		/// <returns domElement="true"></returns>
		/// <param name="map" type="google.maps.Map2">The map to initialize.</param>
	},
	getDefaultPosition: function() {
		/// <summary>
		///	Returns to the map the position in the map view at which the control appears by default. This will be overridden by the second argument to google.maps.Map2.addControl().
		/// </summary>
		/// <returns type="google.maps.ControlPosition"></returns>
	}
};

google.maps.OverviewMapControl = function() {
	/// <summary>
	///	Creates a collapsible overview mini-map in the corner of the main map for reference location and navigation (through dragging). The google.maps.OverviewMapControl creates an overview map with a one-pixel black border.
	/// </summary>
	/// <returns type="Object"></returns>
};
google.maps.OverviewMapControl.prototype = new google.maps.Control();

// TODO: class google.maps.TileLayerOptions

google.maps.Event = function() {
	/// <summary>
	/// This namespace contains functions that you use to register event handlers, both for custom events and for DOM events, and to fire custom events. All the events defined by this API are custom events that are internally fired by GEvent.trigger().
	/// </summary>
	/// <returns type="Object"></returns>
};
google.maps.Event.addListener = function(source, event, handler) {
	/// <summary>
	///	Registers an event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler. The event handler will be called with this set to the source object.
	/// </summary>
	/// <returns type="google.maps.EventListener"></returns>
};
google.maps.Event.addDomListener = function(source, event, handler) {
	/// <summary>
	///	Registers an event handler for a DOM event on the source object. The source object must be a DOM Node. Returns a handle that can be used to eventually deregister the handler. The event handler will be called with this set to the source object. This function uses the DOM methods for the current browser to register the event handler.
	/// </summary>
	/// <returns type="google.maps.EventListener"></returns>
};
google.maps.Event.removeListener = function(handle) {
	/// <summary>
	///	Removes a handler that was installed using addListener() or addDomListener().
	/// </summary>
};
google.maps.Event.clearListeners = function(source, event) {
	/// <summary>
	///	Removes all handlers on the given object for the given event that were installed using addListener() or addDomListener().
	/// </summary>
};
google.maps.Event.clearInstanceListeners = function(source) {
	/// <summary>
	///	Removes all handlers on the given object for all events that were installed using addListener() or addDomListener().
	/// </summary>
};
google.maps.Event.clearNode = function(source) {
	/// <summary>
	///	Calls clearInstanceListeners on a node and all of its child nodes, recursively.
	/// </summary>
};
google.maps.Event.trigger = function(source, event) {
	/// <summary>
	///	Fires a custom event on the source object. All remaining optional arguments after event are passed in turn as arguments to the event handler functions.
	/// </summary>
};
google.maps.Event.bind = function(source, event, object, method) {
	/// <summary>
	///	Registers an invocation of the method on the given object as the event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler.
	/// </summary>
	/// <returns type="google.maps.EventListener"></returns>
};
google.maps.Event.bindDom = function(source, event, object, method) {
	/// <summary>
	///	Registers an invocation of the method on the given object as the event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler.
	/// </summary>
	/// <returns type="google.maps.EventListener"></returns>
};
google.maps.Event.callback = function(object, method) {
	/// <summary>
	///	Returns a closure that calls method on object.
	/// </summary>
	/// <returns type="Object"></returns>
};
google.maps.Event.callbackArgs = function(object, method) {
	/// <summary>
	///	Returns a closure that calls method on object. All remaining optional arguments after method are passed in turn as arguments method when the returned function is invoked.
	/// </summary>
	/// <returns type="Object"></returns>
};

google.maps.EventListener = function() {
	/// <summary>
	/// This class is opaque. It has no methods and no constructor. Its instances are returned from GEvent.addListener() or GEvent.addDomListener() and are eventually passed back to GEvent.removeListener().
	/// </summary>
};

// TODO: class google.maps.XmlHttp
// TODO: class google.maps.Xml
// TODO: class google.maps.Xslt
// TODO: class google.maps.Log
// TODO: class google.maps.DraggableObject
// TODO: class google.maps.DraggableObjectOptions
// TODO: class google.maps.GeoStatusCode
// TODO: class google.maps.GeoAddressAccuracy
// TODO: class google.maps.ClientGeocoder
// TODO: class google.maps.GeocodeCache
// TODO: class google.maps.FactualGeocodeCache
// TODO: class google.maps.MarkerManager
// TODO: class google.maps.MarkerManagerOptions
// TODO: class google.maps.GeoXml
// TODO: class google.maps.DownloadUrl
// TODO: class google.maps.BrowserIsCompatible
// TODO: class google.maps.Directions
// TODO: class google.maps.DirectionsOptions
// TODO: class google.maps.Route
// TODO: class google.maps.Step
// TODO: class google.maps.TrafficOverlay
// TODO: class google.maps.AdsManager
// TODO: class google.maps.AdsManagerOptions
// TODO: class google.maps.StreetviewPanorama
// TODO: class google.maps.StreetviewPanoramaOptions
// TODO: class google.maps.StreetviewOverlay
// TODO: class google.maps.StreetviewClient
// TODO: class google.maps.StreetviewClient.ReturnValues
// TODO: class google.maps.StreetviewData
// TODO: class google.maps.StreetviewLocation
// TODO: class google.maps.StreetviewLink
// TODO: class google.maps.Pov
// TODO: class google.maps.StreetviewPanorama.ErrorValues

// TODO: class google.maps.GoogleBarLinkTarget
// TODO: class google.maps.GoogleBarResultList
// TODO: class google.maps.MapPane
// TODO: class google.maps.Overlay
// TODO: class google.maps.Control
// TODO: class google.maps.ControlPosition
	
// TODO: class google.maps.ControlAnchor
// TODO: class google.maps.MapType
// TODO: class google.maps.MapTypeOptions
	
// TODO: class google.maps.TileLayer
// TODO: class google.maps.TileLayerOverlay
// TODO: class google.maps.CopyrightCollection
// TODO: class google.maps.Copyright
// TODO: class google.maps.Projection
// TODO: class google.maps.MercatorProjection