@lgriffin/esi.ts 1.0.0

package/src/clients/FleetClient.ts

@@ -0,0 +1,105 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetCharacterFleetInfoApi } from '../api/fleets/getCharacterFleetInfo';
+import { GetFleetInfoApi } from '../api/fleets/getFleetInfo';
+import { UpdateFleetApi } from '../api/fleets/updateFleet';
+import { GetFleetMembersApi } from '../api/fleets/getFleetMembers';
+import { PostFleetInvitationApi } from '../api/fleets/postFleetInvitation';
+import { DeleteFleetMemberApi } from '../api/fleets/deleteFleetMember';
+import { PutFleetMemberApi } from '../api/fleets/putFleetMember';
+import { DeleteFleetSquadApi } from '../api/fleets/deleteFleetSquad';
+import { PutFleetSquadApi } from '../api/fleets/putFleetSquad';
+import { GetFleetWingsApi } from '../api/fleets/getFleetWings';
+import { PostFleetWingApi } from '../api/fleets/postFleetWing';
+import { DeleteFleetWingApi } from '../api/fleets/deleteFleetWing';
+import { PutFleetWingApi } from '../api/fleets/putFleetWing';
+import { PostFleetSquadApi } from '../api/fleets/postFleetSquad';
+
+export class FleetClient {
+    private getCharacterFleetInfoApi: GetCharacterFleetInfoApi;
+    private getFleetInformationApi: GetFleetInfoApi;
+    private updateFleetApi: UpdateFleetApi;
+    private getFleetMembersApi: GetFleetMembersApi;
+    private postFleetInvitationApi: PostFleetInvitationApi;
+    private deleteFleetMemberApi: DeleteFleetMemberApi;
+    private putFleetMemberApi: PutFleetMemberApi;
+    private deleteFleetSquadApi: DeleteFleetSquadApi;
+    private putFleetSquadApi: PutFleetSquadApi;
+    private getFleetWingsApi: GetFleetWingsApi;
+    private postFleetWingApi: PostFleetWingApi;
+    private deleteFleetWingApi: DeleteFleetWingApi;
+    private putFleetWingApi: PutFleetWingApi;
+    private postFleetSquadApi: PostFleetSquadApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterFleetInfoApi = new GetCharacterFleetInfoApi(client);
+        this.getFleetInformationApi = new GetFleetInfoApi(client);
+        this.updateFleetApi = new UpdateFleetApi(client);
+        this.getFleetMembersApi = new GetFleetMembersApi(client);
+        this.postFleetInvitationApi = new PostFleetInvitationApi(client);
+        this.deleteFleetMemberApi = new DeleteFleetMemberApi(client);
+        this.putFleetMemberApi = new PutFleetMemberApi(client);
+        this.deleteFleetSquadApi = new DeleteFleetSquadApi(client);
+        this.putFleetSquadApi = new PutFleetSquadApi(client);
+        this.getFleetWingsApi = new GetFleetWingsApi(client);
+        this.postFleetWingApi = new PostFleetWingApi(client);
+        this.deleteFleetWingApi = new DeleteFleetWingApi(client);
+        this.putFleetWingApi = new PutFleetWingApi(client);
+        this.postFleetSquadApi = new PostFleetSquadApi(client);
+    }
+
+    async getCharacterFleetInfo(characterId: number): Promise<any> {
+        return await this.getCharacterFleetInfoApi.getCharacterFleetInfo(characterId);
+    }
+
+    async getFleetInformation(fleetId: number): Promise<any> {
+        return await this.getFleetInformationApi.getFleetInfo(fleetId);
+    }
+
+    async updateFleet(fleetId: number, body: object): Promise<any> {
+        return await this.updateFleetApi.updateFleet(fleetId, body);
+    }
+
+    async getFleetMembers(fleetId: number): Promise<any> {
+        return await this.getFleetMembersApi.getFleetMembers(fleetId);
+    }
+
+    async createFleetInvitation(fleetId: number, body: object): Promise<any> {
+        return await this.postFleetInvitationApi.createFleetInvitation(fleetId, body);
+    }
+
+    async kickFleetMember(fleetId: number, memberId: number): Promise<any> {
+        return await this.deleteFleetMemberApi.kickFleetMember(fleetId, memberId);
+    }
+
+    async moveFleetMember(fleetId: number, memberId: number, body: object): Promise<any> {
+        return await this.putFleetMemberApi.moveFleetMember(fleetId, memberId, body);
+    }
+
+    async deleteFleetSquad(fleetId: number, squadId: number): Promise<any> {
+        return await this.deleteFleetSquadApi.deleteFleetSquad(fleetId, squadId);
+    }
+
+    async renameFleetSquad(fleetId: number, squadId: number, name: string): Promise<any> {
+        return await this.putFleetSquadApi.renameFleetSquad(fleetId, squadId, { name });
+    }
+
+    async getFleetWings(fleetId: number): Promise<any> {
+        return await this.getFleetWingsApi.getFleetWings(fleetId);
+    }
+
+    async createFleetWing(fleetId: number, body: object): Promise<any> {
+        return await this.postFleetWingApi.createFleetWing(fleetId, body);
+    }
+    
+    async deleteFleetWing(fleetId: number, wingId: number): Promise<any> {
+        return await this.deleteFleetWingApi.deleteFleetWing(fleetId, wingId);
+    }
+
+    async renameFleetWing(fleetId: number, wingId: number, name: string): Promise<any> {
+        return await this.putFleetWingApi.renameFleetWing(fleetId, wingId, name);
+    }
+
+    async createFleetSquad(fleetId: number, wingId: number): Promise<any> {
+        return await this.postFleetSquadApi.createFleetSquad(fleetId, wingId);
+    }
+}

package/src/clients/IncursionsClient.ts

@@ -0,0 +1,14 @@
+import { ApiClient } from '../core/ApiClient';
+import { IncursionsApi } from '../api/incursions/getIncursions';
+
+export class IncursionsClient {
+    private incursionsApi: IncursionsApi;
+
+    constructor(client: ApiClient) {
+        this.incursionsApi = new IncursionsApi(client);
+    }
+
+    async getIncursions(): Promise<any> {
+        return await this.incursionsApi.getIncursions();
+    }
+}

package/src/clients/IndustryClient.ts

@@ -0,0 +1,63 @@
+import { GetCharacterIndustryJobsApi } from '../api/industry/getCharacterIndustryJobs';
+import { GetCharacterMiningLedgerApi } from '../api/industry/getCharacterMiningLedger';
+import { GetMoonExtractionTimersApi } from '../api/industry/getMoonExtractionTimers';
+import { GetCorporationMiningObserversApi } from '../api/industry/getCorporationMiningObservers';
+import { GetCorporationMiningObserverApi } from '../api/industry/getCorporationMiningObserver';
+import { GetCorporationIndustryJobsApi } from '../api/industry/getCorporationIndustryJobs';
+import { GetIndustryFacilitiesApi } from '../api/industry/getIndustryFacilities';
+import { GetIndustrySystemsApi } from '../api/industry/getIndustrySystems';
+import { ApiClient } from '../core/ApiClient';
+
+export class IndustryClient {
+    private getCharacterIndustryJobsApi: GetCharacterIndustryJobsApi;
+    private getCharacterMiningLedgerApi: GetCharacterMiningLedgerApi;
+    private getMoonExtractionTimersApi: GetMoonExtractionTimersApi;
+    private getCorporationMiningObserversApi: GetCorporationMiningObserversApi;
+    private getCorporationMiningObserverApi: GetCorporationMiningObserverApi;
+    private getCorporationIndustryJobsApi: GetCorporationIndustryJobsApi;
+    private getIndustryFacilitiesApi: GetIndustryFacilitiesApi;
+    private getIndustrySystemsApi: GetIndustrySystemsApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterIndustryJobsApi = new GetCharacterIndustryJobsApi(client);
+        this.getCharacterMiningLedgerApi = new GetCharacterMiningLedgerApi(client);
+        this.getMoonExtractionTimersApi = new GetMoonExtractionTimersApi(client);
+        this.getCorporationMiningObserversApi = new GetCorporationMiningObserversApi(client);
+        this.getCorporationMiningObserverApi = new GetCorporationMiningObserverApi(client);
+        this.getCorporationIndustryJobsApi = new GetCorporationIndustryJobsApi(client);
+        this.getIndustryFacilitiesApi = new GetIndustryFacilitiesApi(client);
+        this.getIndustrySystemsApi = new GetIndustrySystemsApi(client);
+    }
+
+    async getCharacterIndustryJobs(characterId: number): Promise<any> {
+        return await this.getCharacterIndustryJobsApi.getCharacterIndustryJobs(characterId);
+    }
+
+    async getCharacterMiningLedger(characterId: number): Promise<any> {
+        return await this.getCharacterMiningLedgerApi.getCharacterMiningLedger(characterId);
+    }
+
+    async getMoonExtractionTimers(corporationId: number): Promise<any> {
+        return await this.getMoonExtractionTimersApi.getMoonExtractionTimers(corporationId);
+    }
+
+    async getCorporationMiningObservers(corporationId: number): Promise<any> {
+        return await this.getCorporationMiningObserversApi.getCorporationMiningObservers(corporationId);
+    }
+
+    async getCorporationMiningObserver(corporationId: number, observerId: number): Promise<any> {
+        return await this.getCorporationMiningObserverApi.getCorporationMiningObserver(corporationId, observerId);
+    }
+
+    async getCorporationIndustryJobs(corporationId: number): Promise<any> {
+        return await this.getCorporationIndustryJobsApi.getCorporationIndustryJobs(corporationId);
+    }
+
+    async getIndustryFacilities(): Promise<any> {
+        return await this.getIndustryFacilitiesApi.getIndustryFacilities();
+    }
+
+    async getIndustrySystems(): Promise<any> {
+        return await this.getIndustrySystemsApi.getIndustrySystems();
+    }
+}

package/src/clients/InsuranceClient.ts

@@ -0,0 +1,14 @@
+import { ApiClient } from '../core/ApiClient';
+import { InsuranceApi } from '../api/insurance/getInsurancePrices';
+
+export class InsuranceClient {
+    private insuranceApi: InsuranceApi;
+
+    constructor(client: ApiClient) {
+        this.insuranceApi = new InsuranceApi(client);
+    }
+
+    async getInsurancePrices(): Promise<any> {
+        return await this.insuranceApi.getInsurancePrices();
+    }
+}

package/src/clients/KillmailsClient.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetCharacterRecentKillmailsApi } from '../api/killmails/getCharacterRecentKillmails';
+import { GetCorporationRecentKillmailsApi } from '../api/killmails/getCorporationRecentKillmails';
+import { GetKillmailApi } from '../api/killmails/getKillmail';
+
+export class KillmailsClient {
+    private getCharacterRecentKillmailsApi: GetCharacterRecentKillmailsApi;
+    private getCorporationRecentKillmailsApi: GetCorporationRecentKillmailsApi;
+    private getKillmailApi: GetKillmailApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterRecentKillmailsApi = new GetCharacterRecentKillmailsApi(client);
+        this.getCorporationRecentKillmailsApi = new GetCorporationRecentKillmailsApi(client);
+        this.getKillmailApi = new GetKillmailApi(client);
+    }
+
+    async getCharacterRecentKillmails(characterId: number): Promise<any> {
+        return await this.getCharacterRecentKillmailsApi.getCharacterRecentKillmails(characterId);
+    }
+
+    async getCorporationRecentKillmails(corporationId: number): Promise<any> {
+        return await this.getCorporationRecentKillmailsApi.getCorporationRecentKillmails(corporationId);
+    }
+
+    async getKillmail(killmailId: number, killmailHash: string): Promise<any> {
+        return await this.getKillmailApi.getKillmail(killmailId, killmailHash);
+    }
+}

package/src/clients/LocationClient.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetCharacterLocationApi } from '../api/location/getCharacterLocation';
+import { GetCharacterOnlineApi } from '../api/location/getCharacterOnline';
+import { GetCharacterShipApi } from '../api/location/getCharacterShip';
+
+export class LocationClient {
+    private getCharacterLocationApi: GetCharacterLocationApi;
+    private getCharacterOnlineApi: GetCharacterOnlineApi;
+    private getCharacterShipApi: GetCharacterShipApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterLocationApi = new GetCharacterLocationApi(client);
+        this.getCharacterOnlineApi = new GetCharacterOnlineApi(client);
+        this.getCharacterShipApi = new GetCharacterShipApi(client);
+    }
+
+    async getCharacterLocation(characterId: number): Promise<any> {
+        return await this.getCharacterLocationApi.getCharacterLocation(characterId);
+    }
+
+    async getCharacterOnline(characterId: number): Promise<any> {
+        return await this.getCharacterOnlineApi.getCharacterOnline(characterId);
+    }
+
+    async getCharacterShip(characterId: number): Promise<any> {
+        return await this.getCharacterShipApi.getCharacterShip(characterId);
+    }
+}

package/src/clients/LoyaltyClient.ts

@@ -0,0 +1,21 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetLoyaltyPointsApi } from '../api/loyalty/getLoyaltyPoints';
+import { GetLoyaltyStoreOffersApi } from '../api/loyalty/getLoyaltyStoreOffers';
+
+export class LoyaltyClient {
+    private getLoyaltyPointsApi: GetLoyaltyPointsApi;
+    private getLoyaltyStoreOffersApi: GetLoyaltyStoreOffersApi;
+
+    constructor(client: ApiClient) {
+        this.getLoyaltyPointsApi = new GetLoyaltyPointsApi(client);
+        this.getLoyaltyStoreOffersApi = new GetLoyaltyStoreOffersApi(client);
+    }
+
+    async getLoyaltyPoints(characterId: number): Promise<any> {
+        return await this.getLoyaltyPointsApi.getLoyaltyPoints(characterId);
+    }
+
+    async getLoyaltyStoreOffers(corporationId: number): Promise<any> {
+        return await this.getLoyaltyStoreOffersApi.getLoyaltyStoreOffers(corporationId);
+    }
+}

package/src/clients/MailClient.ts

@@ -0,0 +1,70 @@
+import { GetCharacterMailHeadersApi } from '../api/mail/getCharacterMailHeaders';
+import { PostCharacterMailApi } from '../api/mail/postCharacterMail';
+import { DeleteCharacterMailApi } from '../api/mail/deleteCharacterMail';
+import { GetCharacterMailApi } from '../api/mail/getCharacterMail';
+import { PutCharacterMailApi } from '../api/mail/putCharacterMail';
+import { GetCharacterMailLabelsApi } from '../api/mail/getCharacterMailLabels';
+import { PostCharacterMailLabelsApi } from '../api/mail/postCharacterMailLabels';
+import { DeleteCharacterMailLabelApi } from '../api/mail/deleteCharacterMailLabel';
+import { GetCharacterMailingListsApi } from '../api/mail/getCharacterMailingLists';
+import { ApiClient } from '../core/ApiClient';
+
+export class MailClient {
+    private getCharacterMailHeadersApi: GetCharacterMailHeadersApi;
+    private postCharacterMailApi: PostCharacterMailApi;
+    private deleteCharacterMailApi: DeleteCharacterMailApi;
+    private getCharacterMailApi: GetCharacterMailApi;
+    private putCharacterMailApi: PutCharacterMailApi;
+    private getCharacterMailLabelsApi: GetCharacterMailLabelsApi;
+    private postCharacterMailLabelsApi: PostCharacterMailLabelsApi;
+    private deleteCharacterMailLabelApi: DeleteCharacterMailLabelApi;
+    private getCharacterMailingListsApi: GetCharacterMailingListsApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterMailHeadersApi = new GetCharacterMailHeadersApi(client);
+        this.postCharacterMailApi = new PostCharacterMailApi(client);
+        this.deleteCharacterMailApi = new DeleteCharacterMailApi(client);
+        this.getCharacterMailApi = new GetCharacterMailApi(client);
+        this.putCharacterMailApi = new PutCharacterMailApi(client);
+        this.getCharacterMailLabelsApi = new GetCharacterMailLabelsApi(client);
+        this.postCharacterMailLabelsApi = new PostCharacterMailLabelsApi(client);
+        this.deleteCharacterMailLabelApi = new DeleteCharacterMailLabelApi(client);
+        this.getCharacterMailingListsApi = new GetCharacterMailingListsApi(client);
+    }
+
+    async getMailHeaders(characterId: number): Promise<any> {
+        return await this.getCharacterMailHeadersApi.getCharacterMailHeaders(characterId);
+    }
+
+    async sendMail(characterId: number, body: object): Promise<any> {
+        return await this.postCharacterMailApi.sendMail(characterId, body);
+    }
+
+    async deleteMail(characterId: number, mailId: number): Promise<any> {
+        return await this.deleteCharacterMailApi.deleteMail(characterId, mailId);
+    }
+
+    async getMail(characterId: number, mailId: number): Promise<any> {
+        return await this.getCharacterMailApi.getMail(characterId, mailId);
+    }
+
+    async updateMailMetadata(characterId: number, mailId: number, body: object): Promise<any> {
+        return await this.putCharacterMailApi.updateMailMetadata(characterId, mailId, body);
+    }
+
+    async getMailLabels(characterId: number): Promise<any> {
+        return await this.getCharacterMailLabelsApi.getMailLabels(characterId);
+    }
+
+    async createMailLabel(characterId: number, body: object): Promise<any> {
+        return await this.postCharacterMailLabelsApi.createMailLabel(characterId, body);
+    }
+
+    async deleteMailLabel(characterId: number, labelId: number): Promise<any> {
+        return await this.deleteCharacterMailLabelApi.deleteMailLabel(characterId, labelId);
+    }
+
+    async getMailingLists(characterId: number): Promise<any> {
+        return await this.getCharacterMailingListsApi.getMailingLists(characterId);
+    }
+}

package/src/clients/MarketClient.ts

@@ -0,0 +1,84 @@
+import { getCharacterOrders } from '../api/market/getCharacterOrders';
+import { getCharacterOrderHistory } from '../api/market/getCharacterOrderHistory';
+import { getCorporationOrders } from '../api/market/getCorporationOrders';
+import { getCorporationOrderHistory } from '../api/market/getCorporationOrderHistory';
+import { getMarketHistory } from '../api/market/getMarketHistory';
+import { getMarketOrders } from '../api/market/getMarketOrders';
+import { getMarketTypes } from '../api/market/getMarketTypes';
+import { getMarketGroups } from '../api/market/getMarketGroups';
+import { getMarketGroupInformation } from '../api/market/getMarketGroupInformation';
+import { getMarketPrices } from '../api/market/getMarketPrices';
+import { getMarketOrdersInStructure } from '../api/market/getMarketOrdersInStructure';
+import { ApiClient } from '../core/ApiClient';
+
+export class MarketClient {
+    private getCharacterOrdersApi: getCharacterOrders;
+    private getCharacterOrderHistoryApi: getCharacterOrderHistory;
+    private getCorporationOrdersApi: getCorporationOrders;
+    private getCorporationOrderHistoryApi: getCorporationOrderHistory;
+    private getMarketHistoryApi: getMarketHistory;
+    private getMarketOrdersApi: getMarketOrders;
+    private getMarketTypesApi: getMarketTypes;
+    private getMarketGroupsApi: getMarketGroups;
+    private getMarketGroupInformationApi: getMarketGroupInformation;
+    private getMarketPricesApi: getMarketPrices;
+    private getMarketOrdersInStructureApi: getMarketOrdersInStructure;
+
+    constructor(client: ApiClient) {
+        this.getCharacterOrdersApi = new getCharacterOrders(client);
+        this.getCharacterOrderHistoryApi = new getCharacterOrderHistory(client);
+        this.getCorporationOrdersApi = new getCorporationOrders(client);
+        this.getCorporationOrderHistoryApi = new getCorporationOrderHistory(client);
+        this.getMarketHistoryApi = new getMarketHistory(client);
+        this.getMarketOrdersApi = new getMarketOrders(client);
+        this.getMarketTypesApi = new getMarketTypes(client);
+        this.getMarketGroupsApi = new getMarketGroups(client);
+        this.getMarketGroupInformationApi = new getMarketGroupInformation(client);
+        this.getMarketPricesApi = new getMarketPrices(client);
+        this.getMarketOrdersInStructureApi = new getMarketOrdersInStructure(client);
+    }
+
+    async getCharacterOrders(characterId: number): Promise<any> {
+        return await this.getCharacterOrdersApi.getCharacterOrders(characterId);
+    }
+
+    async getCharacterOrderHistory(characterId: number): Promise<any> {
+        return await this.getCharacterOrderHistoryApi.getCharacterOrderHistory(characterId);
+    }
+
+    async getCorporationOrders(corporationId: number): Promise<any> {
+        return await this.getCorporationOrdersApi.getCorporationOrders(corporationId);
+    }
+
+    async getCorporationOrderHistory(corporationId: number): Promise<any> {
+        return await this.getCorporationOrderHistoryApi.getCorporationOrderHistory(corporationId);
+    }
+
+    async getMarketHistory(regionId: number, typeId: number): Promise<any> {
+        return await this.getMarketHistoryApi.getMarketHistory(regionId, typeId);
+    }
+
+    async getMarketOrders(regionId: number): Promise<any> {
+        return await this.getMarketOrdersApi.getMarketOrders(regionId);
+    }
+
+    async getMarketTypes(regionId: number): Promise<any> {
+        return await this.getMarketTypesApi.getMarketTypes(regionId);
+    }
+
+    async getMarketGroups(): Promise<any> {
+        return await this.getMarketGroupsApi.getMarketGroups();
+    }
+
+    async getMarketGroupInformation(marketGroupId: number): Promise<any> {
+        return await this.getMarketGroupInformationApi.getMarketGroupInformation(marketGroupId);
+    }
+
+    async getMarketPrices(): Promise<any> {
+        return await this.getMarketPricesApi.getMarketPrices();
+    }
+
+    async getMarketOrdersInStructure(structureId: number): Promise<any> {
+        return await this.getMarketOrdersInStructureApi.getMarketOrdersInStructure(structureId);
+    }
+}

package/src/clients/OpportunitiesClient.ts

@@ -0,0 +1,42 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetCharacterOpportunitiesApi } from '../api/opportunities/getCharacterOpportunities';
+import { GetOpportunitiesGroupsApi } from '../api/opportunities/getOpportunitiesGroups';
+import { GetOpportunitiesGroupByIdApi } from '../api/opportunities/getOpportunitiesGroupById';
+import { GetOpportunitiesTasksApi } from '../api/opportunities/getOpportunitiesTasks';
+import { GetOpportunitiesTaskByIdApi } from '../api/opportunities/getOpportunitiesTaskById';
+
+export class OpportunitiesClient {
+    private getCharacterOpportunitiesApi: GetCharacterOpportunitiesApi;
+    private getOpportunitiesGroupsApi: GetOpportunitiesGroupsApi;
+    private getOpportunitiesGroupByIdApi: GetOpportunitiesGroupByIdApi;
+    private getOpportunitiesTasksApi: GetOpportunitiesTasksApi;
+    private getOpportunitiesTaskByIdApi: GetOpportunitiesTaskByIdApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterOpportunitiesApi = new GetCharacterOpportunitiesApi(client);
+        this.getOpportunitiesGroupsApi = new GetOpportunitiesGroupsApi(client);
+        this.getOpportunitiesGroupByIdApi = new GetOpportunitiesGroupByIdApi(client);
+        this.getOpportunitiesTasksApi = new GetOpportunitiesTasksApi(client);
+        this.getOpportunitiesTaskByIdApi = new GetOpportunitiesTaskByIdApi(client);
+    }
+
+    async getCharacterOpportunities(characterId: number): Promise<any> {
+        return await this.getCharacterOpportunitiesApi.getCharacterOpportunities(characterId);
+    }
+
+    async getOpportunitiesGroups(): Promise<any> {
+        return await this.getOpportunitiesGroupsApi.getOpportunitiesGroups();
+    }
+
+    async getOpportunitiesGroupById(groupId: number): Promise<any> {
+        return await this.getOpportunitiesGroupByIdApi.getOpportunitiesGroupById(groupId);
+    }
+
+    async getOpportunitiesTasks(): Promise<any> {
+        return await this.getOpportunitiesTasksApi.getOpportunitiesTasks();
+    }
+
+    async getOpportunitiesTaskById(taskId: number): Promise<any> {
+        return await this.getOpportunitiesTaskByIdApi.getOpportunitiesTaskById(taskId);
+    }
+}

package/src/clients/PiClient.ts

@@ -0,0 +1,35 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetColoniesApi } from '../api/pi/getColonies';
+import { GetColonyLayoutApi } from '../api/pi/getColonyLayout';
+import { GetCorporationCustomsOfficesApi } from '../api/pi/getCorporationCustomsOffices';
+import { GetSchematicInformationApi } from '../api/pi/getSchematicInformation';
+
+export class PIClient {
+    private getColoniesApi: GetColoniesApi;
+    private getColonyLayoutApi: GetColonyLayoutApi;
+    private getCorporationCustomsOfficesApi: GetCorporationCustomsOfficesApi;
+    private getSchematicInformationApi: GetSchematicInformationApi;
+
+    constructor(client: ApiClient) {
+        this.getColoniesApi = new GetColoniesApi(client);
+        this.getColonyLayoutApi = new GetColonyLayoutApi(client);
+        this.getCorporationCustomsOfficesApi = new GetCorporationCustomsOfficesApi(client);
+        this.getSchematicInformationApi = new GetSchematicInformationApi(client);
+    }
+
+    async getColonies(characterId: number): Promise<any> {
+        return await this.getColoniesApi.getColonies(characterId);
+    }
+
+    async getColonyLayout(characterId: number, planetId: number): Promise<any> {
+        return await this.getColonyLayoutApi.getColonyLayout(characterId, planetId);
+    }
+
+    async getCorporationCustomsOffices(corporationId: number): Promise<any> {
+        return await this.getCorporationCustomsOfficesApi.getCorporationCustomsOffices(corporationId);
+    }
+
+    async getSchematicInformation(schematicId: number): Promise<any> {
+        return await this.getSchematicInformationApi.getSchematicInformation(schematicId);
+    }
+}

package/src/clients/RouteClient.ts

@@ -0,0 +1,14 @@
+import { ApiClient } from '../core/ApiClient';
+import { RouteApi } from '../api/route/getRoute';
+
+export class RouteClient {
+    private routeApi: RouteApi;
+
+    constructor(client: ApiClient) {
+        this.routeApi = new RouteApi(client);
+    }
+
+    async getRoute(origin: number, destination: number): Promise<any> {
+        return await this.routeApi.getRoute(origin, destination);
+    }
+}

package/src/clients/SearchClient.ts

@@ -0,0 +1,14 @@
+import { ApiClient } from '../core/ApiClient';
+import { CharacterSearchApi } from '../api/search/getCharacterSearch';
+
+export class SearchClient {
+    private characterSearchApi: CharacterSearchApi;
+
+    constructor(client: ApiClient) {
+        this.characterSearchApi = new CharacterSearchApi(client);
+    }
+
+    async characterSearch(characterId: number, searchString: string): Promise<object> {
+        return this.characterSearchApi.searchCharacter(characterId, searchString);
+    }
+}

package/src/clients/SkillsClient.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from '../core/ApiClient';
+import { GetCharacterAttributesApi } from '../api/skills/getCharacterAttributes';
+import { GetCharacterSkillQueueApi } from '../api/skills/getCharacterSkillQueue';
+import { GetCharacterSkillsApi } from '../api/skills/getCharacterSkills';
+
+export class CharacterSkillsClient {
+    private getCharacterAttributesApi: GetCharacterAttributesApi;
+    private getCharacterSkillQueueApi: GetCharacterSkillQueueApi;
+    private getCharacterSkillsApi: GetCharacterSkillsApi;
+
+    constructor(client: ApiClient) {
+        this.getCharacterAttributesApi = new GetCharacterAttributesApi(client);
+        this.getCharacterSkillQueueApi = new GetCharacterSkillQueueApi(client);
+        this.getCharacterSkillsApi = new GetCharacterSkillsApi(client);
+    }
+
+    async getCharacterAttributes(characterId: number): Promise<any> {
+        return await this.getCharacterAttributesApi.getCharacterAttributes(characterId);
+    }
+
+    async getCharacterSkillQueue(characterId: number): Promise<any> {
+        return await this.getCharacterSkillQueueApi.getCharacterSkillQueue(characterId);
+    }
+
+    async getCharacterSkills(characterId: number): Promise<any> {
+        return await this.getCharacterSkillsApi.getCharacterSkills(characterId);
+    }
+}

package/src/clients/SovereigntyClient.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from '../core/ApiClient';
+import { SovereigntyCampaignsApi } from '../api/sovereignty/getSovereigntyCampaigns';
+import { SovereigntyMapApi } from '../api/sovereignty/getSovereigntyMap';
+import { SovereigntyStructuresApi } from '../api/sovereignty/getSovereigntyStructures';
+
+export class SovereigntyClient {
+    private sovereigntyCampaignsApi: SovereigntyCampaignsApi;
+    private sovereigntyMapApi: SovereigntyMapApi;
+    private sovereigntyStructuresApi: SovereigntyStructuresApi;
+
+    constructor(client: ApiClient) {
+        this.sovereigntyCampaignsApi = new SovereigntyCampaignsApi(client);
+        this.sovereigntyMapApi = new SovereigntyMapApi(client);
+        this.sovereigntyStructuresApi = new SovereigntyStructuresApi(client);
+    }
+
+    async getSovereigntyCampaigns(): Promise<any> {
+        return await this.sovereigntyCampaignsApi.getSovereigntyCampaigns();
+    }
+
+    async getSovereigntyMap(): Promise<any> {
+        return await this.sovereigntyMapApi.getSovereigntyMap();
+    }
+
+    async getSovereigntyStructures(): Promise<any> {
+        return await this.sovereigntyStructuresApi.getSovereigntyStructures();
+    }
+}

package/src/clients/StatusClient.ts

@@ -0,0 +1,24 @@
+import { GetStatusApi } from '../api/status/getStatus';
+import { ApiClient } from '../core/ApiClient';
+
+export class StatusClient {
+    private getStatusApi: GetStatusApi;
+
+    constructor(client: ApiClient) {
+        this.getStatusApi = new GetStatusApi(client);
+    }
+
+    async getStatus(): Promise<any> {
+        return await this.getStatusApi.getStatus();
+    }
+}
+
+
+
+/* This is what we had in case we want to go more granular later again
+return {
+            players: response.players,
+            start_time: response.start_time,
+            server_version: response.server_version,
+        };
+*/