EVEESIService.cfc

/**
*
* @file  EVEESIService.cfc
* @author  Denard Springle (denard.springle@gmail.com)
* @description I provide a CFC interface for the Eve Online ESI API
*
*/

component displayname="EVEESIService" accessors="true" {

	property dsn;
	property emdpoint;
	property userAgent;

	/**
	* @displayname	init
	* @description	I am the components constructor
	* @param		dsn {String} - I am the datasource to use: tranquility (default) or singularity 
	* @param		endpoint {String} - I am the base URL endpoint for the EvE ESI API
	*/
	public function init( 
		string dsn = 'tranquility',
		string endpoint = 'https://esi.tech.ccp.is/latest',
		string userAgent = 'CFESI v1.0 (author: Silly Noob - denard.springle@gmail.com) [host: http://#CGI.HTTP_HOST#/]'
	) {
		variables.dsn = arguments.dsn;
		variables.endpoint = arguments.endpoint;
		variables.userAgent = arguments.userAgent;
		return this;
	}
	
	/**
	* @displayname	getAlliances
	* @description	List all active player alliances  ---  Alternate route: `/v1/alliances/`  Alternate route: `/legacy/alliances/`  Alternate route: `/dev/alliances/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getAlliances() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/alliances';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getAllianceNames
	* @description	Resolve a set of alliance IDs to alliance names  ---  Alternate route: `/v1/alliances/names/`  Alternate route: `/legacy/alliances/names/`  Alternate route: `/dev/alliances/names/`   ---  This route is cached for up to 3600 seconds
	* @param		allianceIds {String} required - A comma separated list of alliance IDs
	* @return		struct
	*/
	public struct function getAllianceNames( required string allianceIds ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/alliances/names';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'alliance_ids' ] = arguments.allianceIds;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getAllianceByAllianceId
	* @description	Public information about an alliance  ---  Alternate route: `/v2/alliances/{alliance_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		allianceId {Numeric} required - An Eve alliance ID
	* @return		struct
	*/
	public struct function getAllianceByAllianceId( required numeric allianceId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/alliances/#arguments.allianceId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getAllianceCorporationsByAllianceId
	* @description	List all current member corporations of an alliance  ---  Alternate route: `/v1/alliances/{alliance_id}/corporations/`  Alternate route: `/legacy/alliances/{alliance_id}/corporations/`  Alternate route: `/dev/alliances/{alliance_id}/corporations/`   ---  This route is cached for up to 3600 seconds
	* @param		allianceId {Numeric} required - An EVE alliance ID
	* @return		struct
	*/
	public struct function getAllianceCorporationsByAllianceId( required numeric allianceId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/alliances/#arguments.allianceId#/corporations';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getAllianceIconsByAllianceId
	* @description	Get the icon urls for a alliance  ---  Alternate route: `/v1/alliances/{alliance_id}/icons/`  Alternate route: `/legacy/alliances/{alliance_id}/icons/`  Alternate route: `/dev/alliances/{alliance_id}/icons/`   ---  This route is cached for up to 3600 seconds
	* @param		allianceId {Numeric} required - An EVE alliance ID
	* @return		struct
	*/
	public struct function getAllianceIconsByAllianceId( required numeric allianceId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/alliances/#arguments.allianceId#/icons';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	postCharacterAffiliation
	* @description	Bulk lookup of character IDs to corporation, alliance and faction  ---  Alternate route: `/v1/characters/affiliation/`  Alternate route: `/legacy/characters/affiliation/`  Alternate route: `/dev/characters/affiliation/`   ---  This route is cached for up to 3600 seconds
	* @param		characters {Any} required - The character IDs to fetch affiliations for
	* @return		struct
	*/
	public struct function postCharacterAffiliation( required any characters ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/affiliation';
		// set the http method for this request
		var apiMethod = 'POST';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterNames
	* @description	Resolve a set of character IDs to character names  ---  Alternate route: `/v1/characters/names/`  Alternate route: `/legacy/characters/names/`  Alternate route: `/dev/characters/names/`   ---  This route is cached for up to 3600 seconds
	* @param		characterIds {String} required - A comma separated list of character IDs
	* @return		struct
	*/
	public struct function getCharacterNames( required string characterIds ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/names';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'character_ids' ] = arguments.characterIds;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterByCharacterId
	* @description	Public information about a character  ---  Alternate route: `/v4/characters/{character_id}/`  Alternate route: `/dev/characters/{character_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @return		struct
	*/
	public struct function getCharacterByCharacterId( required numeric characterId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterAgentsResearchByCharacterId
	* @description	Return a list of agents research information for a character. The formula for finding the current research points with an agent is: currentPoints = remainderPoints + pointsPerDay * days(currentTime - researchStartDate)  ---  Alternate route: `/v1/characters/{character_id}/agents_research/`  Alternate route: `/legacy/characters/{character_id}/agents_research/`  Alternate route: `/dev/characters/{character_id}/agents_research/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_agents_research.v1
	* @return		struct
	*/
	public struct function getCharacterAgentsResearchByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/agents_research';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterAssetsByCharacterId
	* @description	Return a list of the characters assets  ---  Alternate route: `/v1/characters/{character_id}/assets/`  Alternate route: `/legacy/characters/{character_id}/assets/`  Alternate route: `/dev/characters/{character_id}/assets/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - Character id of the target character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-assets.read_assets.v1
	* @return		struct
	*/
	public struct function getCharacterAssetsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/assets';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterBlueprintsByCharacterId
	* @description	Return a list of blueprints the character has  ---  Alternate route: `/v1/characters/{character_id}/blueprints/`  Alternate route: `/legacy/characters/{character_id}/blueprints/`  Alternate route: `/dev/characters/{character_id}/blueprints/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_blueprints.v1
	* @return		struct
	*/
	public struct function getCharacterBlueprintsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/blueprints';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterBookmarksByCharacterId
	* @description	List your character's personal bookmarks  ---  Alternate route: `/v1/characters/{character_id}/bookmarks/`  Alternate route: `/legacy/characters/{character_id}/bookmarks/`  Alternate route: `/dev/characters/{character_id}/bookmarks/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-bookmarks.read_character_bookmarks.v1
	* @return		struct
	*/
	public struct function getCharacterBookmarksByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/bookmarks';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterBookmarksFoldersByCharacterId
	* @description	List your character's personal bookmark folders  ---  Alternate route: `/v1/characters/{character_id}/bookmarks/folders/`  Alternate route: `/legacy/characters/{character_id}/bookmarks/folders/`  Alternate route: `/dev/characters/{character_id}/bookmarks/folders/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-bookmarks.read_character_bookmarks.v1
	* @return		struct
	*/
	public struct function getCharacterBookmarksFoldersByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/bookmarks/folders';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterCalendarByCharacterId
	* @description	Get 50 event summaries from the calendar. If no event ID is given, the resource will return the next 50 chronological event summaries from now. If an event ID is specified, it will return the next 50 chronological event summaries from after that event.   ---  Alternate route: `/v1/characters/{character_id}/calendar/`  Alternate route: `/legacy/characters/{character_id}/calendar/`  Alternate route: `/dev/characters/{character_id}/calendar/`   ---  This route is cached for up to 5 seconds
	* @param		characterId {Numeric} required - The character to retrieve events from
	* @param		fromEvent {Numeric} required - The event ID to retrieve events from
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-calendar.read_calendar_events.v1
	* @return		struct
	*/
	public struct function getCharacterCalendarByCharacterId( required numeric characterId, required numeric fromEvent, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/calendar';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'from_event' ] = arguments.fromEvent;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	getCharacterCalendarByCharacterIdAndEventId
	* @description	Get all the information for a specific event  ---  Alternate route: `/v3/characters/{character_id}/calendar/{event_id}/`  Alternate route: `/dev/characters/{character_id}/calendar/{event_id}/`   ---  This route is cached for up to 5 seconds
	* @param		characterId {Numeric} required - The character id requesting the event
	* @param		eventId {Numeric} required - The id of the event requested
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-calendar.read_calendar_events.v1
	* @return		struct
	*/
	public struct function getCharacterCalendarByCharacterIdAndEventId( required numeric characterId, required numeric eventId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/calendar/#arguments.eventId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	putCharacterCalendarByCharacterIdAndEventId
	* @description	Set your response status to an event  ---  Alternate route: `/v3/characters/{character_id}/calendar/{event_id}/`  Alternate route: `/dev/characters/{character_id}/calendar/{event_id}/` 
	* @param		characterId {Numeric} required - The character ID requesting the event
	* @param		eventId {Numeric} required - The ID of the event requested
	* @param		response {Any} required - The response value to set, overriding current value.. One of: accepted, declined, tentative
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-calendar.respond_calendar_events.v1
	* @return		struct
	*/
	public struct function putCharacterCalendarByCharacterIdAndEventId( required numeric characterId, required numeric eventId, required any response, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/calendar/#arguments.eventId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.response;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getCharacterChatChannelsByCharacterId
	* @description	Return chat channels that a character is the owner or an operator of  ---  Alternate route: `/v1/characters/{character_id}/chat_channels/`  Alternate route: `/legacy/characters/{character_id}/chat_channels/`  Alternate route: `/dev/characters/{character_id}/chat_channels/`   ---  This route is cached for up to 300 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_chat_channels.v1
	* @return		struct
	*/
	public struct function getCharacterChatChannelsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/chat_channels';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getCharacterClonesByCharacterId
	* @description	A list of the character's clones  ---  Alternate route: `/v2/characters/{character_id}/clones/`  Alternate route: `/dev/characters/{character_id}/clones/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-clones.read_clones.v1
	* @return		struct
	*/
	public struct function getCharacterClonesByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/clones';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	deleteCharacterContactsByCharacterId
	* @description	Bulk delete contacts  ---  Alternate route: `/v1/characters/{character_id}/contacts/`  Alternate route: `/legacy/characters/{character_id}/contacts/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		contactIds {Any} required - A list of contacts to delete
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.write_contacts.v1
	* @return		struct
	*/
	public struct function deleteCharacterContactsByCharacterId( required numeric characterId, required any contactIds, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/contacts';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.contactIds;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getCharacterContactsByCharacterId
	* @description	Return contacts of a character  ---  Alternate route: `/v1/characters/{character_id}/contacts/`  Alternate route: `/legacy/characters/{character_id}/contacts/`  Alternate route: `/dev/characters/{character_id}/contacts/`   ---  This route is cached for up to 300 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		page {Numeric} required - page integer
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_contacts.v1
	* @return		struct
	*/
	public struct function getCharacterContactsByCharacterId( required numeric characterId, required numeric page, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/contacts';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'page' ] = arguments.page;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	postCharacterContactsByCharacterId
	* @description	Bulk add contacts with same settings  ---  Alternate route: `/v1/characters/{character_id}/contacts/`  Alternate route: `/legacy/characters/{character_id}/contacts/`  Alternate route: `/dev/characters/{character_id}/contacts/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		contactIds {Any} required - A list of contacts to add
	* @param		labelId {Numeric} required - Add a custom label to the new contact
	* @param		standing {Numeric} required - Standing for the new contact
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		watched {Boolean} required - Whether the new contact should be watched, note this is only effective on characters
	* @scope		esi-characters.write_contacts.v1
	* @return		struct
	*/
	public struct function postCharacterContactsByCharacterId( required numeric characterId, required any contactIds, required numeric labelId, required numeric standing, string token = '', required boolean watched ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/contacts';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.contactIds;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'label_id' ] = arguments.labelId;
		apiParams[ 'standing' ] = arguments.standing;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}
		apiParams[ 'watched' ] = arguments.watched;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	putCharacterContactsByCharacterId
	* @description	Bulk edit contacts with same settings  ---  Alternate route: `/v1/characters/{character_id}/contacts/`  Alternate route: `/legacy/characters/{character_id}/contacts/`  Alternate route: `/dev/characters/{character_id}/contacts/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		contactIds {Any} required - A list of contacts to edit
	* @param		labelId {Numeric} required - Add a custom label to the contact, use 0 for clearing label
	* @param		standing {Numeric} required - Standing for the contact
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		watched {Boolean} required - Whether the contact should be watched, note this is only effective on characters
	* @scope		esi-characters.write_contacts.v1
	* @return		struct
	*/
	public struct function putCharacterContactsByCharacterId( required numeric characterId, required any contactIds, required numeric labelId, required numeric standing, string token = '', required boolean watched ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/contacts';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.contactIds;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'label_id' ] = arguments.labelId;
		apiParams[ 'standing' ] = arguments.standing;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}
		apiParams[ 'watched' ] = arguments.watched;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getCharacterContactsLabelsByCharacterId
	* @description	Return custom labels for contacts the character defined  ---  Alternate route: `/v1/characters/{character_id}/contacts/labels/`  Alternate route: `/legacy/characters/{character_id}/contacts/labels/`  Alternate route: `/dev/characters/{character_id}/contacts/labels/`   ---  This route is cached for up to 300 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_contacts.v1
	* @return		struct
	*/
	public struct function getCharacterContactsLabelsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/contacts/labels';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getCharacterCorporationhistoryByCharacterId
	* @description	Get a list of all the corporations a character has been a member of  ---  Alternate route: `/v1/characters/{character_id}/corporationhistory/`  Alternate route: `/legacy/characters/{character_id}/corporationhistory/`  Alternate route: `/dev/characters/{character_id}/corporationhistory/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @return		struct
	*/
	public struct function getCharacterCorporationhistoryByCharacterId( required numeric characterId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/corporationhistory';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	postCharacterCspaByCharacterId
	* @description	Takes a source character ID in the url and a set of target character ID's in the body, returns a CSPA charge cost  ---  Alternate route: `/v3/characters/{character_id}/cspa/`  Alternate route: `/legacy/characters/{character_id}/cspa/`  Alternate route: `/dev/characters/{character_id}/cspa/` 
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		characters {Any} required - The target characters to calculate the charge for
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_contacts.v1
	* @return		struct
	*/
	public struct function postCharacterCspaByCharacterId( required numeric characterId, required any characters, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/cspa';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterFittingsByCharacterId
	* @description	Return fittings of a character  ---  Alternate route: `/v1/characters/{character_id}/fittings/`  Alternate route: `/legacy/characters/{character_id}/fittings/`  Alternate route: `/dev/characters/{character_id}/fittings/`   ---  This route is cached for up to 300 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fittings.read_fittings.v1
	* @return		struct
	*/
	public struct function getCharacterFittingsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/fittings';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	postCharacterFittingsByCharacterId
	* @description	Save a new fitting for a character  ---  Alternate route: `/v1/characters/{character_id}/fittings/`  Alternate route: `/legacy/characters/{character_id}/fittings/`  Alternate route: `/dev/characters/{character_id}/fittings/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		fitting {Any} - Details about the new fitting
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fittings.write_fittings.v1
	* @return		struct
	*/
	public struct function postCharacterFittingsByCharacterId( required numeric characterId, any fitting = '', string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/fittings';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	deleteCharacterFittingsByCharacterIdAndFittingId
	* @description	Delete a fitting from a character  ---  Alternate route: `/v1/characters/{character_id}/fittings/{fitting_id}/`  Alternate route: `/legacy/characters/{character_id}/fittings/{fitting_id}/`  Alternate route: `/dev/characters/{character_id}/fittings/{fitting_id}/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		fittingId {Numeric} required - ID for a fitting of this character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fittings.write_fittings.v1
	* @return		struct
	*/
	public struct function deleteCharacterFittingsByCharacterIdAndFittingId( required numeric characterId, required numeric fittingId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/fittings/#arguments.fittingId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterIndustryJobsByCharacterId
	* @description	List industry jobs placed by a character  ---  Alternate route: `/v1/characters/{character_id}/industry/jobs/`  Alternate route: `/legacy/characters/{character_id}/industry/jobs/`  Alternate route: `/dev/characters/{character_id}/industry/jobs/`   ---  This route is cached for up to 300 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		includeCompleted {Boolean} required - Whether retrieve completed character industry jobs as well
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-industry.read_character_jobs.v1
	* @return		struct
	*/
	public struct function getCharacterIndustryJobsByCharacterId( required numeric characterId, required boolean includeCompleted, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/industry/jobs';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'include_completed' ] = arguments.includeCompleted;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getCharacterKillmailsRecentByCharacterId
	* @description	Return a list of character's recent kills and losses  ---  Alternate route: `/v1/characters/{character_id}/killmails/recent/`  Alternate route: `/legacy/characters/{character_id}/killmails/recent/`  Alternate route: `/dev/characters/{character_id}/killmails/recent/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		maxCount {Numeric} required - How many killmails to return at maximum
	* @param		maxKillId {Numeric} required - Only return killmails with ID smaller than this. 
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-killmails.read_killmails.v1
	* @return		struct
	*/
	public struct function getCharacterKillmailsRecentByCharacterId( required numeric characterId, required numeric maxCount, required numeric maxKillId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/killmails/recent';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'max_count' ] = arguments.maxCount;
		apiParams[ 'max_kill_id' ] = arguments.maxKillId;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	getCharacterLocationByCharacterId
	* @description	Information about the characters current location. Returns the current solar system id, and also the current station or structure ID if applicable.  ---  Alternate route: `/v1/characters/{character_id}/location/`  Alternate route: `/legacy/characters/{character_id}/location/`  Alternate route: `/dev/characters/{character_id}/location/`   ---  This route is cached for up to 5 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-location.read_location.v1
	* @return		struct
	*/
	public struct function getCharacterLocationByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/location';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	getCharacterLoyaltyPointsByCharacterId
	* @description	Return a list of loyalty points for all corporations the character has worked for  ---  Alternate route: `/v1/characters/{character_id}/loyalty/points/`  Alternate route: `/legacy/characters/{character_id}/loyalty/points/`  Alternate route: `/dev/characters/{character_id}/loyalty/points/` 
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_loyalty.v1
	* @return		struct
	*/
	public struct function getCharacterLoyaltyPointsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/loyalty/points';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterMailByCharacterId
	* @description	Return the 50 most recent mail headers belonging to the character that match the query criteria. Queries can be filtered by label, and last_mail_id can be used to paginate backwards.  ---  Alternate route: `/v1/characters/{character_id}/mail/`  Alternate route: `/legacy/characters/{character_id}/mail/`  Alternate route: `/dev/characters/{character_id}/mail/`   ---  This route is cached for up to 30 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		labels {String} required - Fetch only mails that match one or more of the given labels
	* @param		lastMailId {Numeric} - List only mail with an ID lower than the given ID, if present
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.read_mail.v1
	* @return		struct
	*/
	public struct function getCharacterMailByCharacterId( required numeric characterId, required string labels, numeric lastMailId = '', string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'labels' ] = arguments.labels;
		if( structKeyExists( arguments, 'lastMailId' ) and len( arguments.lastMailId ) ) {
			apiParams[ 'last_mail_id' ] = arguments.lastMailId;
		}
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 30 ) );

	}

	/**
	* @displayname	postCharacterMailByCharacterId
	* @description	Create and send a new mail  ---  Alternate route: `/v1/characters/{character_id}/mail/`  Alternate route: `/legacy/characters/{character_id}/mail/`  Alternate route: `/dev/characters/{character_id}/mail/` 
	* @param		characterId {Numeric} required - The sender's character ID
	* @param		mail {Any} required - The mail to send
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.send_mail.v1
	* @return		struct
	*/
	public struct function postCharacterMailByCharacterId( required numeric characterId, required any mail, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterMailLabelsByCharacterId
	* @description	Return a list of the users mail labels, unread counts for each label and a total unread count.  ---  Alternate route: `/v3/characters/{character_id}/mail/labels/`  Alternate route: `/dev/characters/{character_id}/mail/labels/`   ---  This route is cached for up to 30 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.read_mail.v1
	* @return		struct
	*/
	public struct function getCharacterMailLabelsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/labels';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 30 ) );

	}

	/**
	* @displayname	postCharacterMailLabelsByCharacterId
	* @description	Create a mail label  ---  Alternate route: `/v2/characters/{character_id}/mail/labels/`  Alternate route: `/legacy/characters/{character_id}/mail/labels/`  Alternate route: `/dev/characters/{character_id}/mail/labels/` 
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		label {Any} - Label to create
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.organize_mail.v1
	* @return		struct
	*/
	public struct function postCharacterMailLabelsByCharacterId( required numeric characterId, any label = '', string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/labels';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	deleteCharacterMailLabelsByCharacterIdAndLabelId
	* @description	Delete a mail label  ---  Alternate route: `/v1/characters/{character_id}/mail/labels/{label_id}/`  Alternate route: `/legacy/characters/{character_id}/mail/labels/{label_id}/`  Alternate route: `/dev/characters/{character_id}/mail/labels/{label_id}/` 
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		labelId {Numeric} required - An EVE label id
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.organize_mail.v1
	* @return		struct
	*/
	public struct function deleteCharacterMailLabelsByCharacterIdAndLabelId( required numeric characterId, required numeric labelId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/labels/#arguments.labelId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterMailListsByCharacterId
	* @description	Return all mailing lists that the character is subscribed to   ---  Alternate route: `/v1/characters/{character_id}/mail/lists/`  Alternate route: `/legacy/characters/{character_id}/mail/lists/`  Alternate route: `/dev/characters/{character_id}/mail/lists/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.read_mail.v1
	* @return		struct
	*/
	public struct function getCharacterMailListsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/lists';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	deleteCharacterMailByCharacterIdAndMailId
	* @description	Delete a mail  ---  Alternate route: `/v1/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/legacy/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/dev/characters/{character_id}/mail/{mail_id}/` 
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		mailId {Numeric} required - An EVE mail ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.organize_mail.v1
	* @return		struct
	*/
	public struct function deleteCharacterMailByCharacterIdAndMailId( required numeric characterId, required numeric mailId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/#arguments.mailId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getCharacterMailByCharacterIdAndMailId
	* @description	Return the contents of an EVE mail  ---  Alternate route: `/v1/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/legacy/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/dev/characters/{character_id}/mail/{mail_id}/`   ---  This route is cached for up to 30 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		mailId {Numeric} required - An EVE mail ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.read_mail.v1
	* @return		struct
	*/
	public struct function getCharacterMailByCharacterIdAndMailId( required numeric characterId, required numeric mailId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/#arguments.mailId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 30 ) );

	}

	/**
	* @displayname	putCharacterMailByCharacterIdAndMailId
	* @description	Update metadata about a mail  ---  Alternate route: `/v1/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/legacy/characters/{character_id}/mail/{mail_id}/`  Alternate route: `/dev/characters/{character_id}/mail/{mail_id}/` 
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		contents {Any} required - Data used to update the mail
	* @param		mailId {Numeric} required - An EVE mail ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-mail.organize_mail.v1
	* @return		struct
	*/
	public struct function putCharacterMailByCharacterIdAndMailId( required numeric characterId, required any contents, required numeric mailId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/mail/#arguments.mailId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.contents;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getCharacterMedalsByCharacterId
	* @description	Return a list of medals the character has  ---  Alternate route: `/v1/characters/{character_id}/medals/`  Alternate route: `/legacy/characters/{character_id}/medals/`  Alternate route: `/dev/characters/{character_id}/medals/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_medals.v1
	* @return		struct
	*/
	public struct function getCharacterMedalsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/medals';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterOnlineByCharacterId
	* @description	Checks if the character is currently online  ---  Alternate route: `/v1/characters/{character_id}/online/`  Alternate route: `/legacy/characters/{character_id}/online/`   ---  This route is cached for up to 60 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-location.read_online.v1
	* @return		struct
	*/
	public struct function getCharacterOnlineByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/online';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 60 ) );

	}

	/**
	* @displayname	getCharacterOpportunitiesByCharacterId
	* @description	Return a list of tasks finished by a character  ---  Alternate route: `/v1/characters/{character_id}/opportunities/`  Alternate route: `/legacy/characters/{character_id}/opportunities/`  Alternate route: `/dev/characters/{character_id}/opportunities/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_opportunities.v1
	* @return		struct
	*/
	public struct function getCharacterOpportunitiesByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/opportunities';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterOrdersByCharacterId
	* @description	List market orders placed by a character  ---  Alternate route: `/v1/characters/{character_id}/orders/`  Alternate route: `/legacy/characters/{character_id}/orders/`  Alternate route: `/dev/characters/{character_id}/orders/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-markets.read_character_orders.v1
	* @return		struct
	*/
	public struct function getCharacterOrdersByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/orders';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterPlanetsByCharacterId
	* @description	Returns a list of all planetary colonies owned by a character.  ---  Alternate route: `/v1/characters/{character_id}/planets/`  Alternate route: `/legacy/characters/{character_id}/planets/`  Alternate route: `/dev/characters/{character_id}/planets/`   ---  This route is cached for up to 600 seconds
	* @param		characterId {Numeric} required - Character id of the target character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-planets.manage_planets.v1
	* @return		struct
	*/
	public struct function getCharacterPlanetsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/planets';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 600 ) );

	}

	/**
	* @displayname	getCharacterPlanetsByCharacterIdAndPlanetId
	* @description	Returns full details on the layout of a single planetary colony, including links, pins and routes. Note: Planetary information is only recalculated when the colony is viewed through the client. Information on this endpoint will not update until this criteria is met.  ---  Alternate route: `/v2/characters/{character_id}/planets/{planet_id}/`  Alternate route: `/dev/characters/{character_id}/planets/{planet_id}/`   ---  This route is cached for up to 600 seconds
	* @param		characterId {Numeric} required - Character id of the target character
	* @param		planetId {Numeric} required - Planet id of the target planet
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-planets.manage_planets.v1
	* @return		struct
	*/
	public struct function getCharacterPlanetsByCharacterIdAndPlanetId( required numeric characterId, required numeric planetId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/planets/#arguments.planetId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 600 ) );

	}

	/**
	* @displayname	getCharacterPortraitByCharacterId
	* @description	Get portrait urls for a character  ---  Alternate route: `/v2/characters/{character_id}/portrait/`  Alternate route: `/dev/characters/{character_id}/portrait/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @return		struct
	*/
	public struct function getCharacterPortraitByCharacterId( required numeric characterId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/portrait';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterRolesByCharacterId
	* @description	Returns a character's corporation roles  ---  Alternate route: `/v1/characters/{character_id}/roles/`  Alternate route: `/legacy/characters/{character_id}/roles/`  Alternate route: `/dev/characters/{character_id}/roles/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - A character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_corporation_roles.v1
	* @return		struct
	*/
	public struct function getCharacterRolesByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/roles';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterSearchByCharacterId
	* @description	Search for entities that match a given sub-string.  ---  Alternate route: `/v2/characters/{character_id}/search/`   ---  This route is cached for up to 3600 seconds
	* @param		categories {String} required - Type of entities to search for
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		language {String} - Search locale
	* @param		search {String} required - The string to search on
	* @param		strict {Boolean} - Whether the search should be a strict match
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-search.search_structures.v1
	* @return		struct
	*/
	public struct function getCharacterSearchByCharacterId( required string categories, required numeric characterId, string language = '', required string search, boolean strict = false, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/search';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'categories' ] = arguments.categories;
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}
		if( structKeyExists( arguments, 'strict' ) and len( arguments.strict ) ) {
			apiParams[ 'strict' ] = arguments.strict;
		}
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterShipByCharacterId
	* @description	Get the current ship type, name and id  ---  Alternate route: `/v1/characters/{character_id}/ship/`  Alternate route: `/legacy/characters/{character_id}/ship/`  Alternate route: `/dev/characters/{character_id}/ship/`   ---  This route is cached for up to 5 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-location.read_ship_type.v1
	* @return		struct
	*/
	public struct function getCharacterShipByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/ship';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	getCharacterSkillqueueByCharacterId
	* @description	List the configured skill queue for the given character  ---  Alternate route: `/v2/characters/{character_id}/skillqueue/`  Alternate route: `/legacy/characters/{character_id}/skillqueue/`  Alternate route: `/dev/characters/{character_id}/skillqueue/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - Character id of the target character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-skills.read_skillqueue.v1
	* @return		struct
	*/
	public struct function getCharacterSkillqueueByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/skillqueue';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	getCharacterSkillsByCharacterId
	* @description	List all trained skills for the given character  ---  Alternate route: `/v3/characters/{character_id}/skills/`  Alternate route: `/dev/characters/{character_id}/skills/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-skills.read_skills.v1
	* @return		struct
	*/
	public struct function getCharacterSkillsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/skills';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	getCharacterStandingsByCharacterId
	* @description	Return character standings from agents, NPC corporations, and factions  ---  Alternate route: `/v1/characters/{character_id}/standings/`  Alternate route: `/legacy/characters/{character_id}/standings/`  Alternate route: `/dev/characters/{character_id}/standings/`   ---  This route is cached for up to 3600 seconds
	* @param		characterId {Numeric} required - ID for a character
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-characters.read_standings.v1
	* @return		struct
	*/
	public struct function getCharacterStandingsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/standings';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCharacterWalletsByCharacterId
	* @description	List your wallets and their balances. Characters typically have only one wallet, with wallet_id 1000 being the master wallet.  ---  Alternate route: `/v1/characters/{character_id}/wallets/`  Alternate route: `/legacy/characters/{character_id}/wallets/`  Alternate route: `/dev/characters/{character_id}/wallets/`   ---  This route is cached for up to 120 seconds
	* @param		characterId {Numeric} required - An EVE character ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-wallet.read_character_wallet.v1
	* @return		struct
	*/
	public struct function getCharacterWalletsByCharacterId( required numeric characterId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/characters/#arguments.characterId#/wallets';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	getCorporationNames
	* @description	Resolve a set of corporation IDs to corporation names  ---  Alternate route: `/v1/corporations/names/`  Alternate route: `/legacy/corporations/names/`  Alternate route: `/dev/corporations/names/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationIds {String} required - A comma separated list of corporation IDs
	* @return		struct
	*/
	public struct function getCorporationNames( required string corporationIds ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/names';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'corporation_ids' ] = arguments.corporationIds;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationNpccorps
	* @description	Get a list of npc corporations  ---  Alternate route: `/v1/corporations/npccorps/`  Alternate route: `/legacy/corporations/npccorps/`  Alternate route: `/dev/corporations/npccorps/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getCorporationNpccorps() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/npccorps';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationByCorporationId
	* @description	Public information about a corporation  ---  Alternate route: `/v3/corporations/{corporation_id}/`  Alternate route: `/dev/corporations/{corporation_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - An Eve corporation ID
	* @return		struct
	*/
	public struct function getCorporationByCorporationId( required numeric corporationId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationAlliancehistoryByCorporationId
	* @description	Get a list of all the alliances a corporation has been a member of  ---  Alternate route: `/v1/corporations/{corporation_id}/alliancehistory/`  Alternate route: `/legacy/corporations/{corporation_id}/alliancehistory/`  Alternate route: `/dev/corporations/{corporation_id}/alliancehistory/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - An EVE corporation ID
	* @return		struct
	*/
	public struct function getCorporationAlliancehistoryByCorporationId( required numeric corporationId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/alliancehistory';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationIconsByCorporationId
	* @description	Get the icon urls for a corporation  ---  Alternate route: `/v1/corporations/{corporation_id}/icons/`  Alternate route: `/legacy/corporations/{corporation_id}/icons/`  Alternate route: `/dev/corporations/{corporation_id}/icons/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - An EVE corporation ID
	* @return		struct
	*/
	public struct function getCorporationIconsByCorporationId( required numeric corporationId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/icons';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationMembersByCorporationId
	* @description	Read the current list of members if the calling character is a member.  ---  Alternate route: `/v2/corporations/{corporation_id}/members/`  Alternate route: `/legacy/corporations/{corporation_id}/members/`  Alternate route: `/dev/corporations/{corporation_id}/members/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - A corporation ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-corporations.read_corporation_membership.v1
	* @return		struct
	*/
	public struct function getCorporationMembersByCorporationId( required numeric corporationId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/members';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationRolesByCorporationId
	* @description	Return the roles of all members if the character has the personnel manager role or any grantable role.  ---  Alternate route: `/v1/corporations/{corporation_id}/roles/`  Alternate route: `/legacy/corporations/{corporation_id}/roles/`  Alternate route: `/dev/corporations/{corporation_id}/roles/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - A corporation ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-corporations.read_corporation_membership.v1
	* @return		struct
	*/
	public struct function getCorporationRolesByCorporationId( required numeric corporationId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/roles';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getCorporationStructuresByCorporationId
	* @description	Get a list of corporation structures  ---  Alternate route: `/v1/corporations/{corporation_id}/structures/`  Alternate route: `/legacy/corporations/{corporation_id}/structures/`  Alternate route: `/dev/corporations/{corporation_id}/structures/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - A corporation ID
	* @param		language {String} - Language to use in the response
	* @param		page {Numeric} required - Which page to query, 250 structures per page
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-corporations.read_structures.v1
	* @return		struct
	*/
	public struct function getCorporationStructuresByCorporationId( required numeric corporationId, string language = '', required numeric page, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/structures';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}
		apiParams[ 'page' ] = arguments.page;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	putCorporationStructuresByCorporationIdAndStructureId
	* @description	Update the vulnerability window schedule of a corporation structure  ---  Alternate route: `/v1/corporations/{corporation_id}/structures/{structure_id}/`  Alternate route: `/legacy/corporations/{corporation_id}/structures/{structure_id}/`  Alternate route: `/dev/corporations/{corporation_id}/structures/{structure_id}/` 
	* @param		corporationId {Numeric} required - A corporation ID
	* @param		newSchedule {Any} required - New vulnerability window schedule for the structure
	* @param		structureId {Numeric} required - A structure ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-corporations.write_structures.v1
	* @return		struct
	*/
	public struct function putCorporationStructuresByCorporationIdAndStructureId( required numeric corporationId, required any newSchedule, required numeric structureId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/corporations/#arguments.corporationId#/structures/#arguments.structureId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.newSchedule;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getDogmaAttributes
	* @description	Get a list of dogma attribute ids  ---  Alternate route: `/v1/dogma/attributes/`  Alternate route: `/legacy/dogma/attributes/`  Alternate route: `/dev/dogma/attributes/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getDogmaAttributes() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/dogma/attributes';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getDogmaAttributesByAttributeId
	* @description	Get information on a dogma attribute  ---  Alternate route: `/v1/dogma/attributes/{attribute_id}/`  Alternate route: `/legacy/dogma/attributes/{attribute_id}/`  Alternate route: `/dev/dogma/attributes/{attribute_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		attributeId {Numeric} required - A dogma attribute ID
	* @return		struct
	*/
	public struct function getDogmaAttributesByAttributeId( required numeric attributeId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/dogma/attributes/#arguments.attributeId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getDogmaEffects
	* @description	Get a list of dogma effect ids  ---  Alternate route: `/v1/dogma/effects/`  Alternate route: `/legacy/dogma/effects/`  Alternate route: `/dev/dogma/effects/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getDogmaEffects() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/dogma/effects';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getDogmaEffectsByEffectId
	* @description	Get information on a dogma effect  ---  Alternate route: `/v1/dogma/effects/{effect_id}/`  Alternate route: `/legacy/dogma/effects/{effect_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		effectId {Numeric} required - A dogma effect ID
	* @return		struct
	*/
	public struct function getDogmaEffectsByEffectId( required numeric effectId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/dogma/effects/#arguments.effectId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getFleetByFleetId
	* @description	Return details about a fleet  ---  Alternate route: `/v1/fleets/{fleet_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/`  Alternate route: `/dev/fleets/{fleet_id}/`   ---  This route is cached for up to 5 seconds
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.read_fleet.v1
	* @return		struct
	*/
	public struct function getFleetByFleetId( required numeric fleetId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	putFleetByFleetId
	* @description	Update settings about a fleet  ---  Alternate route: `/v1/fleets/{fleet_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/`  Alternate route: `/dev/fleets/{fleet_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		newSettings {Any} required - What to update for this fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function putFleetByFleetId( required numeric fleetId, required any newSettings, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.newSettings;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getFleetMembersByFleetId
	* @description	Return information about fleet members  ---  Alternate route: `/v1/fleets/{fleet_id}/members/`  Alternate route: `/legacy/fleets/{fleet_id}/members/`  Alternate route: `/dev/fleets/{fleet_id}/members/`   ---  This route is cached for up to 5 seconds
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		language {String} - Language to use in the response
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.read_fleet.v1
	* @return		struct
	*/
	public struct function getFleetMembersByFleetId( required numeric fleetId, string language = '', string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/members';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	postFleetMembersByFleetId
	* @description	Invite a character into the fleet, if a character has a CSPA charge set, it is not possible to invite them to the fleet using ESI  ---  Alternate route: `/v1/fleets/{fleet_id}/members/`  Alternate route: `/legacy/fleets/{fleet_id}/members/`  Alternate route: `/dev/fleets/{fleet_id}/members/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		invitation {Any} required - Details of the invitation
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function postFleetMembersByFleetId( required numeric fleetId, required any invitation, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/members';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.invitation;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	deleteFleetMembersByFleetIdAndMemberId
	* @description	Kick a fleet member  ---  Alternate route: `/v1/fleets/{fleet_id}/members/{member_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/members/{member_id}/`  Alternate route: `/dev/fleets/{fleet_id}/members/{member_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		memberId {Numeric} required - The character ID of a member in this fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function deleteFleetMembersByFleetIdAndMemberId( required numeric fleetId, required numeric memberId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/members/#arguments.memberId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	putFleetMembersByFleetIdAndMemberId
	* @description	Move a fleet member around  ---  Alternate route: `/v1/fleets/{fleet_id}/members/{member_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/members/{member_id}/`  Alternate route: `/dev/fleets/{fleet_id}/members/{member_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		memberId {Numeric} required - The character ID of a member in this fleet
	* @param		movement {Any} required - Details of the invitation
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function putFleetMembersByFleetIdAndMemberId( required numeric fleetId, required numeric memberId, required any movement, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/members/#arguments.memberId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.movement;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	deleteFleetSquadsByFleetIdAndSquadId
	* @description	Delete a fleet squad, only empty squads can be deleted  ---  Alternate route: `/v1/fleets/{fleet_id}/squads/{squad_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/squads/{squad_id}/`  Alternate route: `/dev/fleets/{fleet_id}/squads/{squad_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		squadId {Numeric} required - The squad to delete
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function deleteFleetSquadsByFleetIdAndSquadId( required numeric fleetId, required numeric squadId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/squads/#arguments.squadId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	putFleetSquadsByFleetIdAndSquadId
	* @description	Rename a fleet squad  ---  Alternate route: `/v1/fleets/{fleet_id}/squads/{squad_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/squads/{squad_id}/`  Alternate route: `/dev/fleets/{fleet_id}/squads/{squad_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		naming {Any} required - New name of the squad
	* @param		squadId {Numeric} required - The squad to rename
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function putFleetSquadsByFleetIdAndSquadId( required numeric fleetId, required any naming, required numeric squadId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/squads/#arguments.squadId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.naming;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	getFleetWingsByFleetId
	* @description	Return information about wings in a fleet  ---  Alternate route: `/v1/fleets/{fleet_id}/wings/`  Alternate route: `/legacy/fleets/{fleet_id}/wings/`  Alternate route: `/dev/fleets/{fleet_id}/wings/`   ---  This route is cached for up to 5 seconds
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		language {String} - Language to use in the response
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.read_fleet.v1
	* @return		struct
	*/
	public struct function getFleetWingsByFleetId( required numeric fleetId, string language = '', string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/wings';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	postFleetWingsByFleetId
	* @description	Create a new wing in a fleet  ---  Alternate route: `/v1/fleets/{fleet_id}/wings/`  Alternate route: `/legacy/fleets/{fleet_id}/wings/`  Alternate route: `/dev/fleets/{fleet_id}/wings/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function postFleetWingsByFleetId( required numeric fleetId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/wings';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	deleteFleetWingsByFleetIdAndWingId
	* @description	Delete a fleet wing, only empty wings can be deleted. The wing may contain squads, but the squads must be empty  ---  Alternate route: `/v1/fleets/{fleet_id}/wings/{wing_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/wings/{wing_id}/`  Alternate route: `/dev/fleets/{fleet_id}/wings/{wing_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		wingId {Numeric} required - The wing to delete
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function deleteFleetWingsByFleetIdAndWingId( required numeric fleetId, string token = '', required numeric wingId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/wings/#arguments.wingId#';
		// set the http method for this request
		var apiMethod = 'DELETE';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	putFleetWingsByFleetIdAndWingId
	* @description	Rename a fleet wing  ---  Alternate route: `/v1/fleets/{fleet_id}/wings/{wing_id}/`  Alternate route: `/legacy/fleets/{fleet_id}/wings/{wing_id}/`  Alternate route: `/dev/fleets/{fleet_id}/wings/{wing_id}/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		naming {Any} required - New name of the wing
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		wingId {Numeric} required - The wing to rename
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function putFleetWingsByFleetIdAndWingId( required numeric fleetId, required any naming, string token = '', required numeric wingId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/wings/#arguments.wingId#';
		// set the http method for this request
		var apiMethod = 'PUT';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.naming;
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody, params = apiParams );

	}

	/**
	* @displayname	postFleetWingsSquadsByFleetIdAndWingId
	* @description	Create a new squad in a fleet  ---  Alternate route: `/v1/fleets/{fleet_id}/wings/{wing_id}/squads/`  Alternate route: `/legacy/fleets/{fleet_id}/wings/{wing_id}/squads/`  Alternate route: `/dev/fleets/{fleet_id}/wings/{wing_id}/squads/` 
	* @param		fleetId {Numeric} required - ID for a fleet
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		wingId {Numeric} required - The wing_id to create squad in
	* @scope		esi-fleets.write_fleet.v1
	* @return		struct
	*/
	public struct function postFleetWingsSquadsByFleetIdAndWingId( required numeric fleetId, string token = '', required numeric wingId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/fleets/#arguments.fleetId#/wings/#arguments.wingId#/squads';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getIncursions
	* @description	Return a list of current incursions  ---  Alternate route: `/v1/incursions/`  Alternate route: `/legacy/incursions/`  Alternate route: `/dev/incursions/`   ---  This route is cached for up to 300 seconds
	* @return		struct
	*/
	public struct function getIncursions() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/incursions';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getIndustryFacilities
	* @description	Return a list of industry facilities  ---  Alternate route: `/v1/industry/facilities/`  Alternate route: `/legacy/industry/facilities/`  Alternate route: `/dev/industry/facilities/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getIndustryFacilities() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/industry/facilities';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getIndustrySystems
	* @description	Return cost indices for solar systems  ---  Alternate route: `/v1/industry/systems/`  Alternate route: `/legacy/industry/systems/`  Alternate route: `/dev/industry/systems/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getIndustrySystems() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/industry/systems';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getInsurancePrices
	* @description	Return available insurance levels for all ship types  ---  Alternate route: `/v1/insurance/prices/`  Alternate route: `/legacy/insurance/prices/`  Alternate route: `/dev/insurance/prices/`   ---  This route is cached for up to 3600 seconds
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getInsurancePrices( string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/insurance/prices';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getKillmailByKillmailIdAndKillmailHash
	* @description	Return a single killmail from its ID and hash  ---  Alternate route: `/v1/killmails/{killmail_id}/{killmail_hash}/`  Alternate route: `/legacy/killmails/{killmail_id}/{killmail_hash}/`  Alternate route: `/dev/killmails/{killmail_id}/{killmail_hash}/`   ---  This route is cached for up to 3600 seconds
	* @param		killmailHash {String} required - The killmail hash for verification
	* @param		killmailId {Numeric} required - The killmail ID to be queried
	* @return		struct
	*/
	public struct function getKillmailByKillmailIdAndKillmailHash( required string killmailHash, required numeric killmailId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/killmails/#arguments.killmailId#/#arguments.killmailHash#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getLoyaltyStoresOffersByCorporationId
	* @description	Return a list of offers from a specific corporation's loyalty store  ---  Alternate route: `/v1/loyalty/stores/{corporation_id}/offers/`  Alternate route: `/legacy/loyalty/stores/{corporation_id}/offers/`  Alternate route: `/dev/loyalty/stores/{corporation_id}/offers/`   ---  This route is cached for up to 3600 seconds
	* @param		corporationId {Numeric} required - ID of a corporation
	* @return		struct
	*/
	public struct function getLoyaltyStoresOffersByCorporationId( required numeric corporationId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/loyalty/stores/#arguments.corporationId#/offers';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getMarketGroups
	* @description	Get a list of item groups  ---  Alternate route: `/v1/markets/groups/`  Alternate route: `/legacy/markets/groups/`  Alternate route: `/dev/markets/groups/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getMarketGroups() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/groups';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getMarketGroupsByMarketGroupId
	* @description	Get information on an item group  ---  Alternate route: `/v1/markets/groups/{market_group_id}/`  Alternate route: `/legacy/markets/groups/{market_group_id}/`  Alternate route: `/dev/markets/groups/{market_group_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		language {String} - Language to use in the response
	* @param		marketGroupId {Numeric} required - An Eve item group ID
	* @return		struct
	*/
	public struct function getMarketGroupsByMarketGroupId( string language = '', required numeric marketGroupId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/groups/#arguments.marketGroupId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getMarketPrices
	* @description	Return a list of prices  ---  Alternate route: `/v1/markets/prices/`  Alternate route: `/legacy/markets/prices/`  Alternate route: `/dev/markets/prices/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getMarketPrices() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/prices';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getMarketStructuresByStructureId
	* @description	Return all orders in a structure  ---  Alternate route: `/v1/markets/structures/{structure_id}/`  Alternate route: `/legacy/markets/structures/{structure_id}/`  Alternate route: `/dev/markets/structures/{structure_id}/`   ---  This route is cached for up to 300 seconds
	* @param		page {Numeric} required - Which page to query, starting at 1
	* @param		structureId {Numeric} required - Return orders in this structure
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-markets.structure_markets.v1
	* @return		struct
	*/
	public struct function getMarketStructuresByStructureId( required numeric page, required numeric structureId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/structures/#arguments.structureId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'page' ] = arguments.page;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getMarketHistoryByRegionId
	* @description	Return a list of historical market statistics for the specified type in a region  ---  Alternate route: `/v1/markets/{region_id}/history/`  Alternate route: `/legacy/markets/{region_id}/history/`  Alternate route: `/dev/markets/{region_id}/history/`   ---  This route is cached for up to 3600 seconds
	* @param		regionId {Numeric} required - Return statistics in this region
	* @param		typeId {Numeric} required - Return statistics for this type
	* @return		struct
	*/
	public struct function getMarketHistoryByRegionId( required numeric regionId, required numeric typeId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/#arguments.regionId#/history';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'type_id' ] = arguments.typeId;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getMarketOrdersByRegionId
	* @description	Return a list of orders in a region  ---  Alternate route: `/v1/markets/{region_id}/orders/`  Alternate route: `/legacy/markets/{region_id}/orders/`  Alternate route: `/dev/markets/{region_id}/orders/`   ---  This route is cached for up to 300 seconds
	* @param		orderType {String} required - Filter buy/sell orders, return all orders by default. If you query without type_id, we always return both buy and sell orders. 
	* @param		page {Numeric} required - Which page to query, only used for querying without type_id. Starting at 1 
	* @param		regionId {Numeric} required - Return orders in this region
	* @param		typeId {Numeric} required - Return orders only for this type
	* @return		struct
	*/
	public struct function getMarketOrdersByRegionId( required string orderType, required numeric page, required numeric regionId, required numeric typeId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/markets/#arguments.regionId#/orders';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'order_type' ] = arguments.orderType;
		apiParams[ 'page' ] = arguments.page;
		apiParams[ 'type_id' ] = arguments.typeId;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getOpportunityGroups
	* @description	Return a list of opportunities groups  ---  Alternate route: `/v1/opportunities/groups/`  Alternate route: `/legacy/opportunities/groups/`  Alternate route: `/dev/opportunities/groups/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getOpportunityGroups() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/opportunities/groups';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getOpportunityGroupsByGroupId
	* @description	Return information of an opportunities group  ---  Alternate route: `/v1/opportunities/groups/{group_id}/`  Alternate route: `/legacy/opportunities/groups/{group_id}/`  Alternate route: `/dev/opportunities/groups/{group_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		groupId {Numeric} required - ID of an opportunities group
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getOpportunityGroupsByGroupId( required numeric groupId, string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/opportunities/groups/#arguments.groupId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getOpportunityTasks
	* @description	Return a list of opportunities tasks  ---  Alternate route: `/v1/opportunities/tasks/`  Alternate route: `/legacy/opportunities/tasks/`  Alternate route: `/dev/opportunities/tasks/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getOpportunityTasks() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/opportunities/tasks';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getOpportunityTasksByTaskId
	* @description	Return information of an opportunities task  ---  Alternate route: `/v1/opportunities/tasks/{task_id}/`  Alternate route: `/legacy/opportunities/tasks/{task_id}/`  Alternate route: `/dev/opportunities/tasks/{task_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		taskId {Numeric} required - ID of an opportunities task
	* @return		struct
	*/
	public struct function getOpportunityTasksByTaskId( required numeric taskId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/opportunities/tasks/#arguments.taskId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getRouteByOriginAndDestination
	* @description	Get the systems between origin and destination  ---  Alternate route: `/legacy/route/{origin}/{destination}/`  Alternate route: `/dev/route/{origin}/{destination}/`  Alternate route: `/v1/route/{origin}/{destination}/`   ---  This route is cached for up to 86400 seconds
	* @param		avoid {String} - avoid solar system ID(s)
	* @param		connections {String} - connected solar system pairs
	* @param		destination {Numeric} required - destination solar system ID
	* @param		flag {String} - route security preference
	* @param		origin {Numeric} required - origin solar system ID
	* @return		struct
	*/
	public struct function getRouteByOriginAndDestination( string avoid = '', string connections = '', required numeric destination, string flag = '', required numeric origin ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/route/#arguments.origin#/#arguments.destination#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'avoid' ) and len( arguments.avoid ) ) {
			apiParams[ 'avoid' ] = arguments.avoid;
		}
		if( structKeyExists( arguments, 'connections' ) and len( arguments.connections ) ) {
			apiParams[ 'connections' ] = arguments.connections;
		}
		if( structKeyExists( arguments, 'flag' ) and len( arguments.flag ) ) {
			apiParams[ 'flag' ] = arguments.flag;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 86400 ) );

	}

	/**
	* @displayname	getSearch
	* @description	Search for entities that match a given sub-string.  ---  Alternate route: `/v1/search/`  Alternate route: `/legacy/search/`   ---  This route is cached for up to 3600 seconds
	* @param		categories {String} required - Type of entities to search for
	* @param		language {String} - Search locale
	* @param		search {String} required - The string to search on
	* @param		strict {Boolean} - Whether the search should be a strict match
	* @return		struct
	*/
	public struct function getSearch( required string categories, string language = '', required string search, boolean strict = false ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/search';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'categories' ] = arguments.categories;
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}
		if( structKeyExists( arguments, 'strict' ) and len( arguments.strict ) ) {
			apiParams[ 'strict' ] = arguments.strict;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getSovereigntyCampaigns
	* @description	Shows sovereignty data for campaigns.  ---  Alternate route: `/v1/sovereignty/campaigns/`  Alternate route: `/legacy/sovereignty/campaigns/`  Alternate route: `/dev/sovereignty/campaigns/`   ---  This route is cached for up to 5 seconds
	* @return		struct
	*/
	public struct function getSovereigntyCampaigns() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/sovereignty/campaigns';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 5 ) );

	}

	/**
	* @displayname	getSovereigntyMap
	* @description	Shows sovereignty information for solar systems  ---  Alternate route: `/v1/sovereignty/map/`  Alternate route: `/legacy/sovereignty/map/`  Alternate route: `/dev/sovereignty/map/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getSovereigntyMap() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/sovereignty/map';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getSovereigntyStructures
	* @description	Shows sovereignty data for structures.  ---  Alternate route: `/v1/sovereignty/structures/`  Alternate route: `/legacy/sovereignty/structures/`  Alternate route: `/dev/sovereignty/structures/`   ---  This route is cached for up to 120 seconds
	* @return		struct
	*/
	public struct function getSovereigntyStructures() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/sovereignty/structures';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 120 ) );

	}

	/**
	* @displayname	getStatus
	* @description	EVE Server status  ---  Alternate route: `/v1/status/`  Alternate route: `/legacy/status/`  Alternate route: `/dev/status/`   ---  This route is cached for up to 30 seconds
	* @return		struct
	*/
	public struct function getStatus() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/status';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 30 ) );

	}

	/**
	* @displayname	postUiAutopilotWaypoint
	* @description	Set a solar system as autopilot waypoint  ---  Alternate route: `/v2/ui/autopilot/waypoint/`  Alternate route: `/dev/ui/autopilot/waypoint/` 
	* @param		addToBeginning {Boolean} required - Whether this solar system should be added to the beginning of all waypoints
	* @param		clearOtherWaypoints {Boolean} required - Whether clean other waypoints beforing adding this one
	* @param		destinationId {Numeric} required - The destination to travel to, can be solar system, station or structure's id
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-ui.write_waypoint.v1
	* @return		struct
	*/
	public struct function postUiAutopilotWaypoint( required boolean addToBeginning, required boolean clearOtherWaypoints, required numeric destinationId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/ui/autopilot/waypoint';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'add_to_beginning' ] = arguments.addToBeginning;
		apiParams[ 'clear_other_waypoints' ] = arguments.clearOtherWaypoints;
		apiParams[ 'destination_id' ] = arguments.destinationId;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	postUiOpenwindowContract
	* @description	Open the contract window inside the client  ---  Alternate route: `/v1/ui/openwindow/contract/`  Alternate route: `/legacy/ui/openwindow/contract/`  Alternate route: `/dev/ui/openwindow/contract/` 
	* @param		contractId {Numeric} required - The contract to open
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-ui.open_window.v1
	* @return		struct
	*/
	public struct function postUiOpenwindowContract( required numeric contractId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/ui/openwindow/contract';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'contract_id' ] = arguments.contractId;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	postUiOpenwindowInformation
	* @description	Open the information window for a character, corporation or alliance inside the client  ---  Alternate route: `/v1/ui/openwindow/information/`  Alternate route: `/legacy/ui/openwindow/information/`  Alternate route: `/dev/ui/openwindow/information/` 
	* @param		targetId {Numeric} required - The target to open
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-ui.open_window.v1
	* @return		struct
	*/
	public struct function postUiOpenwindowInformation( required numeric targetId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/ui/openwindow/information';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'target_id' ] = arguments.targetId;
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	postUiOpenwindowMarketdetails
	* @description	Open the market details window for a specific typeID inside the client  ---  Alternate route: `/v1/ui/openwindow/marketdetails/`  Alternate route: `/legacy/ui/openwindow/marketdetails/`  Alternate route: `/dev/ui/openwindow/marketdetails/` 
	* @param		token {String} - Access token to use, if preferred over a header
	* @param		typeId {Numeric} required - The item type to open in market window
	* @scope		esi-ui.open_window.v1
	* @return		struct
	*/
	public struct function postUiOpenwindowMarketdetails( string token = '', required numeric typeId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/ui/openwindow/marketdetails';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}
		apiParams[ 'type_id' ] = arguments.typeId;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	postUiOpenwindowNewmail
	* @description	Open the New Mail window, according to settings from the request if applicable  ---  Alternate route: `/v1/ui/openwindow/newmail/`  Alternate route: `/legacy/ui/openwindow/newmail/`  Alternate route: `/dev/ui/openwindow/newmail/` 
	* @param		newMail {Any} required - The details of mail to create
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-ui.open_window.v1
	* @return		struct
	*/
	public struct function postUiOpenwindowNewmail( required any newMail, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/ui/openwindow/newmail';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseBloodlines
	* @description	Get a list of bloodlines  ---  Alternate route: `/v1/universe/bloodlines/`  Alternate route: `/legacy/universe/bloodlines/`  Alternate route: `/dev/universe/bloodlines/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseBloodlines( string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/bloodlines';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseCategories
	* @description	Get a list of item categories  ---  Alternate route: `/v1/universe/categories/`  Alternate route: `/legacy/universe/categories/`  Alternate route: `/dev/universe/categories/`   ---  This route expires daily at 11:05
	* @return		struct
	*/
	public struct function getUniverseCategories() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/categories';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseCategoriesByCategoryId
	* @description	Get information of an item category  ---  Alternate route: `/v1/universe/categories/{category_id}/`  Alternate route: `/legacy/universe/categories/{category_id}/`  Alternate route: `/dev/universe/categories/{category_id}/`   ---  This route expires daily at 11:05
	* @param		categoryId {Numeric} required - An Eve item category ID
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseCategoriesByCategoryId( required numeric categoryId, string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/categories/#arguments.categoryId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseConstellations
	* @description	Get a list of constellations  ---  Alternate route: `/v1/universe/constellations/`  Alternate route: `/legacy/universe/constellations/`  Alternate route: `/dev/universe/constellations/`   ---  This route expires daily at 11:05
	* @return		struct
	*/
	public struct function getUniverseConstellations() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/constellations';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseConstellationsByConstellationId
	* @description	Get information on a constellation  ---  Alternate route: `/v1/universe/constellations/{constellation_id}/`  Alternate route: `/legacy/universe/constellations/{constellation_id}/`  Alternate route: `/dev/universe/constellations/{constellation_id}/`   ---  This route expires daily at 11:05
	* @param		constellationId {Numeric} required - constellation_id integer
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseConstellationsByConstellationId( required numeric constellationId, string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/constellations/#arguments.constellationId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseFactions
	* @description	Get a list of factions  ---  Alternate route: `/v1/universe/factions/`  Alternate route: `/legacy/universe/factions/`  Alternate route: `/dev/universe/factions/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseFactions( string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/factions';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseGraphics
	* @description	Get a list of graphics  ---  Alternate route: `/v1/universe/graphics/`  Alternate route: `/legacy/universe/graphics/`  Alternate route: `/dev/universe/graphics/`   ---  This route expires daily at 11:05
	* @return		struct
	*/
	public struct function getUniverseGraphics() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/graphics';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseGraphicsByGraphicId
	* @description	Get information on a graphic  ---  Alternate route: `/v1/universe/graphics/{graphic_id}/`  Alternate route: `/legacy/universe/graphics/{graphic_id}/`  Alternate route: `/dev/universe/graphics/{graphic_id}/`   ---  This route expires daily at 11:05
	* @param		graphicId {Numeric} required - graphic_id integer
	* @return		struct
	*/
	public struct function getUniverseGraphicsByGraphicId( required numeric graphicId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/graphics/#arguments.graphicId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseGroups
	* @description	Get a list of item groups  ---  Alternate route: `/v1/universe/groups/`  Alternate route: `/legacy/universe/groups/`  Alternate route: `/dev/universe/groups/`   ---  This route expires daily at 11:05
	* @param		page {Numeric} required - Which page to query
	* @return		struct
	*/
	public struct function getUniverseGroups( required numeric page ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/groups';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'page' ] = arguments.page;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseGroupsByGroupId
	* @description	Get information on an item group  ---  Alternate route: `/v1/universe/groups/{group_id}/`  Alternate route: `/legacy/universe/groups/{group_id}/`  Alternate route: `/dev/universe/groups/{group_id}/`   ---  This route expires daily at 11:05
	* @param		groupId {Numeric} required - An Eve item group ID
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseGroupsByGroupId( required numeric groupId, string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/groups/#arguments.groupId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseMoonsByMoonId
	* @description	Get information on a moon  ---  Alternate route: `/v1/universe/moons/{moon_id}/`  Alternate route: `/legacy/universe/moons/{moon_id}/`  Alternate route: `/dev/universe/moons/{moon_id}/`   ---  This route expires daily at 11:05
	* @param		moonId {Numeric} required - moon_id integer
	* @return		struct
	*/
	public struct function getUniverseMoonsByMoonId( required numeric moonId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/moons/#arguments.moonId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	postUniverseNames
	* @description	Resolve a set of IDs to names and categories. Supported ID's for resolving are: Characters, Corporations, Alliances, Stations, Solar Systems, Constellations, Regions, Types.  ---  Alternate route: `/v2/universe/names/`  Alternate route: `/dev/universe/names/` 
	* @param		ids {Any} required - The ids to resolve
	* @return		struct
	*/
	public struct function postUniverseNames( required any ids ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/names';
		// set the http method for this request
		var apiMethod = 'POST';
		// set up a variable to hold the body parameter for this request
		var apiBody = arguments.ids;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, body = apiBody );

	}

	/**
	* @displayname	getUniversePlanetsByPlanetId
	* @description	Get information on a planet  ---  Alternate route: `/v1/universe/planets/{planet_id}/`  Alternate route: `/legacy/universe/planets/{planet_id}/`  Alternate route: `/dev/universe/planets/{planet_id}/`   ---  This route expires daily at 11:05
	* @param		planetId {Numeric} required - planet_id integer
	* @return		struct
	*/
	public struct function getUniversePlanetsByPlanetId( required numeric planetId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/planets/#arguments.planetId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseRaces
	* @description	Get a list of character races  ---  Alternate route: `/v1/universe/races/`  Alternate route: `/legacy/universe/races/`  Alternate route: `/dev/universe/races/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @return		struct
	*/
	public struct function getUniverseRaces( string language = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/races';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseRegions
	* @description	Get a list of regions  ---  Alternate route: `/v1/universe/regions/`  Alternate route: `/legacy/universe/regions/`  Alternate route: `/dev/universe/regions/`   ---  This route expires daily at 11:05
	* @return		struct
	*/
	public struct function getUniverseRegions() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/regions';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseRegionsByRegionId
	* @description	Get information on a region  ---  Alternate route: `/v1/universe/regions/{region_id}/`  Alternate route: `/legacy/universe/regions/{region_id}/`  Alternate route: `/dev/universe/regions/{region_id}/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @param		regionId {Numeric} required - region_id integer
	* @return		struct
	*/
	public struct function getUniverseRegionsByRegionId( string language = '', required numeric regionId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/regions/#arguments.regionId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseSchematicsBySchematicId
	* @description	Get information on a planetary factory schematic  ---  Alternate route: `/v1/universe/schematics/{schematic_id}/`  Alternate route: `/legacy/universe/schematics/{schematic_id}/`  Alternate route: `/dev/universe/schematics/{schematic_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		schematicId {Numeric} required - A PI schematic ID
	* @return		struct
	*/
	public struct function getUniverseSchematicsBySchematicId( required numeric schematicId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/schematics/#arguments.schematicId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getUniverseStargatesByStargateId
	* @description	Get information on a stargate  ---  Alternate route: `/v1/universe/stargates/{stargate_id}/`  Alternate route: `/legacy/universe/stargates/{stargate_id}/`  Alternate route: `/dev/universe/stargates/{stargate_id}/`   ---  This route expires daily at 11:05
	* @param		stargateId {Numeric} required - stargate_id integer
	* @return		struct
	*/
	public struct function getUniverseStargatesByStargateId( required numeric stargateId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/stargates/#arguments.stargateId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseStationsByStationId
	* @description	Get information on a station  ---  Alternate route: `/v2/universe/stations/{station_id}/`  Alternate route: `/dev/universe/stations/{station_id}/`   ---  This route is cached for up to 300 seconds
	* @param		stationId {Numeric} required - station_id integer
	* @return		struct
	*/
	public struct function getUniverseStationsByStationId( required numeric stationId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/stations/#arguments.stationId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 300 ) );

	}

	/**
	* @displayname	getUniverseStructures
	* @description	List all public structures  ---  Alternate route: `/v1/universe/structures/`  Alternate route: `/legacy/universe/structures/`  Alternate route: `/dev/universe/structures/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getUniverseStructures() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/structures';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getUniverseStructuresByStructureId
	* @description	Returns information on requested structure, if you are on the ACL. Otherwise, returns "Forbidden" for all inputs.  ---  Alternate route: `/v1/universe/structures/{structure_id}/`  Alternate route: `/legacy/universe/structures/{structure_id}/`  Alternate route: `/dev/universe/structures/{structure_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		structureId {Numeric} required - An Eve structure ID
	* @param		token {String} - Access token to use, if preferred over a header
	* @scope		esi-universe.read_structures.v1
	* @return		struct
	*/
	public struct function getUniverseStructuresByStructureId( required numeric structureId, string token = '' ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/structures/#arguments.structureId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'token' ) and len( arguments.token ) ) {
			apiParams[ 'token' ] = arguments.token;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getUniverseSystemJumps
	* @description	Get the number of jumps in solar systems within the last hour, excluding wormhole space. Only systems with jumps will be listed  ---  Alternate route: `/v1/universe/system_jumps/`  Alternate route: `/legacy/universe/system_jumps/`  Alternate route: `/dev/universe/system_jumps/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getUniverseSystemJumps() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/system_jumps';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getUniverseSystemKills
	* @description	Get the number of ship, pod and NPC kills per solar system within the last hour, excluding wormhole space. Only systems with kills will be listed  ---  Alternate route: `/v1/universe/system_kills/`  Alternate route: `/legacy/universe/system_kills/`  Alternate route: `/dev/universe/system_kills/`   ---  This route is cached for up to 3600 seconds
	* @return		struct
	*/
	public struct function getUniverseSystemKills() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/system_kills';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getUniverseSystems
	* @description	Get a list of solar systems  ---  Alternate route: `/v1/universe/systems/`  Alternate route: `/legacy/universe/systems/`  Alternate route: `/dev/universe/systems/`   ---  This route expires daily at 11:05
	* @return		struct
	*/
	public struct function getUniverseSystems() {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/systems';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod );

	}

	/**
	* @displayname	getUniverseSystemsBySystemId
	* @description	Get information on a solar system  ---  Alternate route: `/v2/universe/systems/{system_id}/`  Alternate route: `/dev/universe/systems/{system_id}/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @param		systemId {Numeric} required - system_id integer
	* @return		struct
	*/
	public struct function getUniverseSystemsBySystemId( string language = '', required numeric systemId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/systems/#arguments.systemId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseTypes
	* @description	Get a list of type ids  ---  Alternate route: `/v1/universe/types/`  Alternate route: `/legacy/universe/types/`  Alternate route: `/dev/universe/types/`   ---  This route expires daily at 11:05
	* @param		page {Numeric} required - Which page to query
	* @return		struct
	*/
	public struct function getUniverseTypes( required numeric page ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/types';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'page' ] = arguments.page;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getUniverseTypesByTypeId
	* @description	Get information on a type  ---  Alternate route: `/v2/universe/types/{type_id}/`   ---  This route expires daily at 11:05
	* @param		language {String} - Language to use in the response
	* @param		typeId {Numeric} required - An Eve item type ID
	* @return		struct
	*/
	public struct function getUniverseTypesByTypeId( string language = '', required numeric typeId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/universe/types/#arguments.typeId#';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		if( structKeyExists( arguments, 'language' ) and len( arguments.language ) ) {
			apiParams[ 'language' ] = arguments.language;
		}

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams );

	}

	/**
	* @displayname	getWars
	* @description	Return a list of wars  ---  Alternate route: `/v1/wars/`  Alternate route: `/legacy/wars/`  Alternate route: `/dev/wars/`   ---  This route is cached for up to 3600 seconds
	* @param		maxWarId {Numeric} required - Only return wars with ID smaller than this.
	* @return		struct
	*/
	public struct function getWars( required numeric maxWarId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/wars';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'max_war_id' ] = arguments.maxWarId;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getWarByWarId
	* @description	Return details about a war  ---  Alternate route: `/v1/wars/{war_id}/`  Alternate route: `/legacy/wars/{war_id}/`  Alternate route: `/dev/wars/{war_id}/`   ---  This route is cached for up to 3600 seconds
	* @param		warId {Numeric} required - ID for a war
	* @return		struct
	*/
	public struct function getWarByWarId( required numeric warId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/wars/#arguments.warId#';
		// set the http method for this request
		var apiMethod = 'GET';

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}

	/**
	* @displayname	getWarKillmailsByWarId
	* @description	Return a list of kills related to a war  ---  Alternate route: `/v1/wars/{war_id}/killmails/`  Alternate route: `/legacy/wars/{war_id}/killmails/`  Alternate route: `/dev/wars/{war_id}/killmails/`   ---  This route is cached for up to 3600 seconds
	* @param		page {Numeric} required - Which page to query, starting at 1
	* @param		warId {Numeric} required - A valid war ID
	* @return		struct
	*/
	public struct function getWarKillmailsByWarId( required numeric page, required numeric warId ) {
		
		// set the endpoint for this request
		var apiEndpoint = variables.endpoint & '/wars/#arguments.warId#/killmails';
		// set the http method for this request
		var apiMethod = 'GET';
		// set up a struct to hold additional query parameters for this request
		var apiParams = structNew();

		// add additional params for this request
		apiParams[ 'page' ] = arguments.page;

		// return the results of the API call
		return doApiCall( endpoint = apiEndpoint, method = apiMethod, params = apiParams, cacheTime = createTimeSpan( 0, 0, 0, 3600 ) );

	}


	/**
	* @displayname	doApiCall
	* @description	I return a cached version of this request, or make an http request and return the results
	* @param		endpoint {String} required - I am the endpoint for this request
	* @param		method {String} required - I am the HTTP method to use for this request
	* @param		body {Any} - I am the HTTP body for this request - either a struct to be converted to JSON or an actual JSON string
	* @param		params {Struct} - I am the additional HTTP parameters for this request
	* @param		cacheTime {Numeric} - I am the time this request should be cached for
	* @param		method {String} - I am the HTTP method to use for this request
	*/
	public struct function doApiCall( required string endpoint, required string method, any body = '', any params = '', any cacheTime = '' ) {
		var httpService = new http();
		var cacheHash = hash( arguments.endPoint & ( ( isStruct( arguments.params ) ) ? deserializeJSON( arguments.params ) : '' ) & ( ( len( arguments.body ) or isStruct( arguments.body ) ) ? ( ( isStruct( arguments.body ) ) ? seralizeJson( arguments.body ) : arguments.body ) : '' ), 'MD5', 'UTF-8', 420 );

		// get this result from the cache
		var apiResult = cacheGet( cacheHash );
		// set up a counter
		var x = 0;
		// set up for params
		var param = '';

		// check if the cached version exists
		if( isNull( apiResult ) ) {

			// it doesm't, set properties of the http request
			httpService.setMethod( arguments.method );
			httpService.setCharset( 'UTF-8' );

			// check if there are parameters
			if( isStruct( arguments.params ) ) {
				// there are, check if the method is 'get'
				if( findNoCase( 'get', arguments.method ) ) {
					// it is, add a '?' to the endpoint
					arguments.endpoint &= '?';

					// loop through the params 
					for( param in arguments.params ) {
						// increase the counter
						x++;
						// and add them to the endpoint
						arguments.endpoint &= param & '=' & arguments.params[ param ];
						// check if there are more params 
						if( x neq structCount( arguments.params ) ) {
							// there are, add an ampersand (&)
							arguments.endpoint &= '&';
						}
					}
				// otherwise
				} else {

					// not using 'get', supply form fields instead - loop through the params 
					for( param in arguments.params ) {
						// and add the form fields
						httpService.addParam( name = param, type = 'formfield', value = arguments.params[ param ] );
					}


				}
			}

			// check if the body argument is a struct or has length
			if( isStruct( arguments.body ) or len( arguments.body ) ) {
				// it does, check if it's a struct
				if( isStruct( arguments.body ) ) {
					// it is, convert the struct to json
					httpService.addParam( type = 'body', value = deserializeJSON( arguments.body ) );
				// otherwise
				} else {
					// not a struct, assume json passed in
					httpService.addParam( type = 'body', value = arguments.body );					
				}
			}

			// set the url to the endpoint
			httpService.setUrl( arguments.endpoint );
			// set the user agent
			httpService.setUserAgent( variables.userAgent );

			// make the http call
			apiResult = httpService.send().getPrefix();

			// check if the http call was successful
			if( apiResult.status_code eq 200 ) {
				// it was, serialize the results into a struct
				apiResult = deserializeJSON( apiResult.fileContent.toString() );

				// check if this request should be cached
				if( len( arguments.cacheTime ) ) {

					// it should, add it to the cache
					cachePut( cacheHash, apiResult, arguments.cacheTime );

				}
			}

		}

		// and return the result
		return apiResult;

	}

}