public Task<EveServiceResponse<ServerStatus>> ServerStatusAsync(ResponseMode responseMode = ResponseMode.Normal)
        {
            const string MethodPath = "{0}/ServerStatus.xml.aspx";
            const string CacheKeyFormat = "ServerStatus";

            string cacheKey = CacheKeyFormat.FormatInvariant();

            IDictionary<string, string> apiParams = new Dictionary<string, string>();

            return GetServiceResponseAsync(null, null, 0, MethodPath.FormatInvariant(RequestPrefix), apiParams, cacheKey,
                ApiConstants.SixtyMinuteCache, responseMode, ParseServerStatusResponse);
        }

        /// <summary>Calls the CalendarEventAttendees method on the Eve web service.</summary>
        /// <param name="keyId">API Key ID to query</param>
        /// <param name="vCode">The Verification Code for this ID</param>
        /// <param name="characterId">Character to query.</param>
        /// <param name="eventId">The eventID to query</param>
        /// <param name="responseMode"></param>
        /// <returns>A collection of attendees for the event.</returns>
        public Task<EveServiceResponse<IEnumerable<CalendarEventAttendee>>> CalendarEventAttendees(string keyId,
            string vCode, int characterId, int eventId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());
            Guard.Ensure(characterId > 0);

            const string MethodPath = "{0}/CalendarEventAttendees.xml.aspx";
            const string CacheKeyFormat = "Calendar_EventAttendees{0}_{1}_{2}";

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId, characterId, eventId);

            IDictionary<string, string> apiParams = new Dictionary<string, string>();
            apiParams[ApiConstants.EventId] = eventId.ToInvariantString();

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), apiParams,
                cacheKey, ApiConstants.SixtyMinuteCache, responseMode, ParseCalendarEventAttendeesResponse);
        }

        public Task<EveServiceResponse<CorporateData>> CorporationSheetAsync(string keyId, string vCode, int corpId = 0,
            ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());

            const string MethodPath = "{0}/CorporationSheet.xml.aspx";
            const string CacheKeyFormat = "CorporationSheet{0}";

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId,
                corpId > 0 ? "_{0}".FormatInvariant(corpId) : string.Empty);

            IDictionary<string, string> apiParams = new Dictionary<string, string>();
            if (corpId > 0)
            {
                apiParams["corporationID"] = corpId.ToInvariantString();
            }

            return GetServiceResponseAsync(keyId, vCode, 0, MethodPath.FormatInvariant(PathPrefix), apiParams, cacheKey,
                ApiConstants.SixtyMinuteCache, responseMode, ProcessCorporationSheetResponse);
        }

 /// <summary>The skill queue.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="responseMode">The response Mode.</param>
 /// <returns>The <see cref="Task" />.</returns>
 public EveServiceResponse<IEnumerable<QueuedSkill>> SkillQueue(string keyId, string vCode, int characterId,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(SkillQueueAsync, keyId, vCode, characterId, responseMode);
 }

 /// <summary>The npc standings.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="responseMode">The response mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<NpcStanding>> NPCStandings(string keyId, string vCode, int characterId,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(NPCStandingsAsync, keyId, vCode, characterId, responseMode);
 }

 /// <summary>
 ///     Gets the list of characters on the given account.
 /// </summary>
 /// <param name="keyId">API Key ID to query</param>
 /// <param name="vCode">The Verification Code for this ID</param>
 /// <param name="responseMode"></param>
 /// <returns>A Service Response object, containing the collection of Characters.</returns>
 public EveServiceResponse<IEnumerable<AccountCharacter>> Characters(string keyId, string vCode,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     Guard.Ensure(!keyId.IsNullOrWhiteSpace());
     Guard.Ensure(!vCode.IsNullOrWhiteSpace());
     return RunAsyncMethod(CharactersAsync, keyId, vCode, responseMode);
 }

 /// <summary>The notification texts.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="notificationIds">The notification ids.</param>
 /// <param name="responseMode">The response mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<NotificationText>> NotificationTexts(string keyId, string vCode,
     int characterId, IEnumerable<long> notificationIds, ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(NotificationTextsAsync, keyId, vCode, characterId, notificationIds, responseMode);
 }

 public EveServiceResponse<ServerStatus> ServerStatus(ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(ServerStatusAsync, responseMode);
 }

 public EveServiceResponse<IEnumerable<Entities.Blueprint>> Blueprints(string keyId, string vCode, int characterId,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(BlueprintsAsync, keyId, vCode, characterId, responseMode);
 }

 /// <summary>The contract items.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="contractId">The contract id.</param>
 /// <param name="responseMode">The response mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<ContractItem>> ContractItems(string keyId, string vCode, int characterId,
     long contractId, ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(ContractItemsAsync, keyId, vCode, characterId, contractId, responseMode);
 }

        /// <summary>The wallet transactions.</summary>
        /// <param name="keyId">The key id.</param>
        /// <param name="vCode">The v code.</param>
        /// <param name="characterId">The character id.</param>
        /// <param name="accountKey"></param>
        /// <param name="fromId">The from id.</param>
        /// <param name="rowCount">The row count.</param>
        /// <param name="responseMode">The response Mode.</param>
        /// <returns>The <see cref="Task" />.</returns>
        public Task<EveServiceResponse<IEnumerable<WalletTransaction>>> WalletTransactionsAsync(
            string keyId,
            string vCode,
            int characterId,
            int accountKey,
            long? fromId = null,
            int? rowCount = null,
            ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());
            Guard.Ensure(characterId > 0);
            Guard.Ensure(rowCount == null || rowCount.Value > 0);

            const string MethodPath = "{0}/WalletTransactions.xml.aspx";
            const string CacheKeyFormat = "WalletTransactions{0}_{1}{2}{3}{4}";

            const string FromId = "fromID";
            const string RowCount = "rowCount";
            const string AccountKey = "accountKey";


            IDictionary<string, string> apiParams = new Dictionary<string, string>();

            apiParams[AccountKey] = accountKey.ToInvariantString();

            if (fromId != null)
            {
                apiParams[FromId] = fromId.Value.ToInvariantString();
            }

            if (rowCount != null)
            {
                apiParams[RowCount] = rowCount.Value.ToInvariantString();
            }

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId, characterId, accountKey,
                fromId.HasValue ? fromId.Value.ToInvariantString() : string.Empty,
                rowCount.HasValue ? rowCount.Value.ToInvariantString() : string.Empty);

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), apiParams,
                cacheKey, ApiConstants.SixtyMinuteCache, responseMode, ProcessWalletTransctionResponse);
        }

        /// <summary>Retrieves the given character's asset list.</summary>
        /// <param name="keyId">API Key ID to query</param>
        /// <param name="vCode">The Verification Code for this ID</param>
        /// <param name="characterId">Character to query.</param>
        /// <param name="responseMode">The response Mode.</param>
        /// <returns>An enumerable collection of all items in the characters assets.</returns>
        public Task<EveServiceResponse<IEnumerable<AssetItem>>> AssetListAsync(string keyId, string vCode,
            int characterId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Against(keyId.IsNullOrWhiteSpace());
            Guard.Against(vCode.IsNullOrWhiteSpace());
            Guard.Against(characterId == 0);

            const string MethodPath = "{0}/AssetList.xml.aspx";
            const string CacheKeyFormat = "Character_AssetList_{0}_{1}";

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId, characterId);

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), null,
                cacheKey, ApiConstants.SixHourCache, responseMode, ParseAssetListResponse);
        }

 /// <summary>The contact list.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="responseMode">The response mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<Contact>> ContactList(string keyId, string vCode, int characterId,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(ContactListAsync, keyId, vCode, characterId, responseMode);
 }

        /// <summary>Gets the balance of a character.</summary>
        /// <param name="keyId">API Key ID to query</param>
        /// <param name="vCode">The Verification Code for this ID</param>
        /// <param name="characterId">Character to query.</param>
        /// <param name="responseMode">The response Mode.</param>
        /// <returns>Account balances.</returns>
        public Task<EveServiceResponse<IEnumerable<AccountBalance>>> AccountBalanceAsync(string keyId, string vCode,
            int characterId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Against(keyId.IsNullOrWhiteSpace());
            Guard.Against(vCode.IsNullOrWhiteSpace());
            Guard.Against(characterId == 0);

            const string methodPath = "{0}/AccountBalance.xml.aspx";
            const string cacheKeyFormat = "Character_AccountBalance_{0}_{1}";

            string cacheKey = cacheKeyFormat.FormatInvariant(keyId, characterId);

            return GetServiceResponseAsync(keyId, vCode, characterId, methodPath.FormatInvariant(PathPrefix), null,
                cacheKey, ApiConstants.SixtyMinuteCache, responseMode, ParseBalanceResponse);
        }

        public Task<EveServiceResponse<IEnumerable<Entities.Killmail.KillMail>>> KillMailsAsync(string keyId, string vCode,
            int characterId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());
            Guard.Ensure(characterId > 0);

            const string MethodPath = "{0}/KillMails.xml.aspx";
            const string CacheKeyFormat = "{0}KillMails{1}_{2}";

            string cacheKey = CacheKeyFormat.FormatInvariant(PathPrefix, keyId, characterId);

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), null,
                cacheKey, ApiConstants.FiveMinuteCache, responseMode, ProcessKillMailResponse);
        }

 /// <summary>The kill mails</summary>
 /// <param name="keyId">API Key ID to query</param>
 /// <param name="vCode">The Verification Code for this ID</param>
 /// <param name="characterId">Character to query.</param>
 /// <param name="responseMode">The response Mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<Entities.Killmail.KillMail>> KillMails(string keyId, string vCode, int characterId,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(KillMailsAsync, keyId, vCode, characterId, responseMode);
 }

        /// <summary>The standings.</summary>
        /// <param name="keyId">The key id.</param>
        /// <param name="vCode">The v code.</param>
        /// <param name="characterId">The character id.</param>
        /// <param name="responseMode">The response Mode.</param>
        /// <returns>The <see cref="Task" />.</returns>
        public Task<EveServiceResponse<IEnumerable<NpcStanding>>> NPCStandingsAsync(string keyId, string vCode,
            int characterId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());
            Guard.Ensure(characterId > 0);

            const string MethodPath = "{0}/Standings.xml.aspx";
            const string CacheKeyFormat = "CharacterNpcStandings{0}_{1}";

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId, characterId);

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), null,
                cacheKey, ApiConstants.SixtyMinuteCache, responseMode, ProcessStandingsResponse);
        }

        /// <summary>Retrieves the list of contracts</summary>
        /// <param name="keyId">API Key ID to query</param>
        /// <param name="vCode">The Verification Code for this ID</param>
        /// <param name="characterId">Character to query.</param>
        /// <param name="contractId">Contract ID to get items for.</param>
        /// <param name="responseMode">The response Mode.</param>
        /// <returns>The <see cref="Task" />.</returns>
        public Task<EveServiceResponse<IEnumerable<ContractItem>>> ContractItemsAsync(string keyId, string vCode,
            int characterId, long contractId, ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Against(keyId.IsNullOrWhiteSpace());
            Guard.Against(vCode.IsNullOrWhiteSpace());
            Guard.Against(characterId == 0);
            Guard.Against(contractId == 0);

            const string MethodPath = "{0}/ContractItems.xml.aspx";
            const string CacheKeyFormat = "CharacterContractItems{0}_{1}_{2}";

            string cacheKey = CacheKeyFormat.FormatInvariant(keyId, characterId, contractId);

            IDictionary<string, string> apiParams = new Dictionary<string, string>();

            const string ContractId = "contractID";
            apiParams[ContractId] = contractId.ToInvariantString();

            return GetServiceResponseAsync(keyId, vCode, characterId, MethodPath.FormatInvariant(PathPrefix), apiParams,
                cacheKey, ApiConstants.SixtyMinuteCache, responseMode, ParseContractItemResponse);
        }

 /// <summary>The wallet transactions.</summary>
 /// <param name="keyId">The key id.</param>
 /// <param name="vCode">The v code.</param>
 /// <param name="characterId">The character id.</param>
 /// <param name="accountKey">The account key.</param>
 /// <param name="fromId">The from id.</param>
 /// <param name="rowCount">The row count.</param>
 /// <param name="responseMode">The response mode.</param>
 /// <returns></returns>
 public EveServiceResponse<IEnumerable<WalletTransaction>> WalletTransactions(
     string keyId,
     string vCode,
     int characterId,
     int accountKey,
     long? fromId = null,
     int? rowCount = null,
     ResponseMode responseMode = ResponseMode.Normal)
 {
     return RunAsyncMethod(WalletTransactionsAsync, keyId, vCode, characterId, accountKey, fromId, rowCount,
         responseMode);
 }

        public EveServiceResponse<Account> AccountStatus(string keyId, string vCode,
            ResponseMode responseMode = ResponseMode.Normal)
        {
            Guard.Ensure(!keyId.IsNullOrWhiteSpace());
            Guard.Ensure(!vCode.IsNullOrWhiteSpace());

            return RunAsyncMethod(AccountStatusAsync, keyId, vCode, responseMode);
        }