@lgriffin/esi.ts 5.2.0 → 6.0.0

package/dist/core/endpoints/locationEndpoints.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.locationEndpoints = void 0;
+const location_1 = require("../../schemas/location");
 exports.locationEndpoints = {
     getCharacterLocation: {
         path: 'characters/{characterId}/location',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: location_1.CharacterLocationSchema,
     },
     getCharacterOnline: {
         path: 'characters/{characterId}/online',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: location_1.CharacterOnlineSchema,
     },
     getCharacterShip: {
         path: 'characters/{characterId}/ship',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: location_1.CharacterShipSchema,
     },
 };

package/dist/core/endpoints/loyaltyEndpoints.d.ts

@@ -1,15 +1,32 @@
+import { z } from 'zod';
 export declare const loyaltyEndpoints: {
     readonly getLoyaltyPoints: {
         readonly path: "characters/{characterId}/loyalty/points";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            corporation_id: z.ZodNumber;
+            loyalty_points: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getLoyaltyStoreOffers: {
         readonly path: "loyalty/stores/{corporationId}/offers";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            offer_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            lp_cost: z.ZodNumber;
+            isk_cost: z.ZodNumber;
+            ak_cost: z.ZodOptional<z.ZodNumber>;
+            required_items: z.ZodArray<z.ZodObject<{
+                type_id: z.ZodNumber;
+                quantity: z.ZodNumber;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=loyaltyEndpoints.d.ts.map

package/dist/core/endpoints/loyaltyEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loyaltyEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/loyaltyEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAaG,CAAC"}
+{"version":3,"file":"loyaltyEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/loyaltyEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeG,CAAC"}

package/dist/core/endpoints/loyaltyEndpoints.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loyaltyEndpoints = void 0;
+const zod_1 = require("zod");
+const loyalty_1 = require("../../schemas/loyalty");
 exports.loyaltyEndpoints = {
     getLoyaltyPoints: {
         path: 'characters/{characterId}/loyalty/points',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(loyalty_1.LoyaltyPointsSchema),
     },
     getLoyaltyStoreOffers: {
         path: 'loyalty/stores/{corporationId}/offers',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(loyalty_1.LoyaltyStoreOfferSchema),
     },
 };

package/dist/core/endpoints/mailEndpoints.d.ts

@@ -1,9 +1,27 @@
+import { z } from 'zod';
 export declare const mailEndpoints: {
     readonly getCharacterMailHeaders: {
         readonly path: "characters/{characterId}/mail/";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            mail_id: z.ZodOptional<z.ZodNumber>;
+            subject: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_read: z.ZodOptional<z.ZodBoolean>;
+            recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                recipient_id: z.ZodNumber;
+                recipient_type: z.ZodEnum<{
+                    character: "character";
+                    corporation: "corporation";
+                    alliance: "alliance";
+                    mailing_list: "mailing_list";
+                }>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
     };
     readonly sendMail: {
         readonly path: "characters/{characterId}/mail/";
@@ -17,6 +35,23 @@ export declare const mailEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "mailId"];
+        readonly responseSchema: z.ZodObject<{
+            mail_id: z.ZodOptional<z.ZodNumber>;
+            subject: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_read: z.ZodOptional<z.ZodBoolean>;
+            recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                recipient_id: z.ZodNumber;
+                recipient_type: z.ZodEnum<{
+                    character: "character";
+                    corporation: "corporation";
+                    alliance: "alliance";
+                    mailing_list: "mailing_list";
+                }>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>;
     };
     readonly deleteMail: {
         readonly path: "characters/{characterId}/mail/{mailId}/";

package/dist/core/endpoints/mailEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mailEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mailEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DM,CAAC"}
+{"version":3,"file":"mailEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mailEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DM,CAAC"}

package/dist/core/endpoints/mailEndpoints.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mailEndpoints = void 0;
+const zod_1 = require("zod");
+const mail_1 = require("../../schemas/mail");
 exports.mailEndpoints = {
     getCharacterMailHeaders: {
         path: 'characters/{characterId}/mail/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(mail_1.MailMessageSchema),
     },
     sendMail: {
         path: 'characters/{characterId}/mail/',
@@ -20,6 +23,7 @@ exports.mailEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId', 'mailId'],
+        responseSchema: mail_1.MailMessageSchema,
     },
     deleteMail: {
         path: 'characters/{characterId}/mail/{mailId}/',

package/dist/core/endpoints/marketEndpoints.d.ts

@@ -1,27 +1,104 @@
+import { z } from 'zod';
 export declare const marketEndpoints: {
     readonly getCharacterOrders: {
         readonly path: "characters/{characterId}/orders/";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getCharacterOrderHistory: {
         readonly path: "characters/{characterId}/orders/history/";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationOrders: {
         readonly path: "corporations/{corporationId}/orders/";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationOrderHistory: {
         readonly path: "corporations/{corporationId}/orders/history/";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getMarketGroups: {
         readonly path: "markets/groups/";
@@ -44,6 +121,25 @@ export declare const marketEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["structureId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getMarketHistory: {
         readonly path: "markets/{regionId}/history/";
@@ -53,6 +149,14 @@ export declare const marketEndpoints: {
         readonly queryParams: {
             readonly typeId: "type_id";
         };
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            date: z.ZodString;
+            order_count: z.ZodNumber;
+            volume: z.ZodNumber;
+            highest: z.ZodNumber;
+            average: z.ZodNumber;
+            lowest: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getMarketOrders: {
         readonly path: "markets/{regionId}/orders/";
@@ -62,6 +166,25 @@ export declare const marketEndpoints: {
         readonly queryParams: {
             readonly orderType: "order_type";
         };
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                closed: "closed";
+                open: "open";
+                expired: "expired";
+                cancelled: "cancelled";
+            }>>;
+        }, z.core.$loose>>;
     };
     readonly getMarketTypes: {
         readonly path: "markets/{regionId}/types/";

package/dist/core/endpoints/marketEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marketEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/marketEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEI,CAAC"}
+{"version":3,"file":"marketEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/marketEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EI,CAAC"}

package/dist/core/endpoints/marketEndpoints.js

@@ -1,30 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.marketEndpoints = void 0;
+const zod_1 = require("zod");
+const market_1 = require("../../schemas/market");
 exports.marketEndpoints = {
     getCharacterOrders: {
         path: 'characters/{characterId}/orders/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getCharacterOrderHistory: {
         path: 'characters/{characterId}/orders/history/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getCorporationOrders: {
         path: 'corporations/{corporationId}/orders/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getCorporationOrderHistory: {
         path: 'corporations/{corporationId}/orders/history/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getMarketGroups: {
         path: 'markets/groups/',
@@ -47,6 +53,7 @@ exports.marketEndpoints = {
         method: 'GET',
         requiresAuth: false,
         pathParams: ['structureId'],
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getMarketHistory: {
         path: 'markets/{regionId}/history/',
@@ -54,6 +61,7 @@ exports.marketEndpoints = {
         requiresAuth: false,
         pathParams: ['regionId'],
         queryParams: { typeId: 'type_id' },
+        responseSchema: zod_1.z.array(market_1.MarketHistorySchema),
     },
     getMarketOrders: {
         path: 'markets/{regionId}/orders/',
@@ -61,6 +69,7 @@ exports.marketEndpoints = {
         requiresAuth: false,
         pathParams: ['regionId'],
         queryParams: { orderType: 'order_type' },
+        responseSchema: zod_1.z.array(market_1.MarketOrderSchema),
     },
     getMarketTypes: {
         path: 'markets/{regionId}/types/',

package/dist/core/endpoints/mercenaryEndpoints.d.ts

@@ -1,13 +1,37 @@
+import { z } from 'zod';
 export declare const mercenaryEndpoints: {
     readonly getMercenaryDens: {
         readonly path: "mercenary/dens";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            den_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            constellation_id: z.ZodNumber;
+            region_id: z.ZodNumber;
+            development_level: z.ZodOptional<z.ZodNumber>;
+            anarchy_level: z.ZodOptional<z.ZodNumber>;
+            active_operations: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getMercenaryTacticalOperations: {
         readonly path: "mercenary/operations";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            operation_id: z.ZodNumber;
+            den_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            site_type: z.ZodString;
+            status: z.ZodEnum<{
+                expired: "expired";
+                active: "active";
+                spawning: "spawning";
+                completed: "completed";
+            }>;
+            started_at: z.ZodOptional<z.ZodString>;
+            expires_at: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=mercenaryEndpoints.d.ts.map

package/dist/core/endpoints/mercenaryEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mercenaryEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mercenaryEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;;;;;;;;;;CAWC,CAAC"}
+{"version":3,"file":"mercenaryEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mercenaryEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaC,CAAC"}

package/dist/core/endpoints/mercenaryEndpoints.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mercenaryEndpoints = void 0;
+const zod_1 = require("zod");
+const mercenary_1 = require("../../schemas/mercenary");
 exports.mercenaryEndpoints = {
     getMercenaryDens: {
         path: 'mercenary/dens',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(mercenary_1.MercenaryDenSchema),
     },
     getMercenaryTacticalOperations: {
         path: 'mercenary/operations',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(mercenary_1.MercenaryTacticalOperationSchema),
     },
 };

package/dist/core/endpoints/piEndpoints.d.ts

@@ -1,21 +1,97 @@
+import { z } from 'zod';
 export declare const piEndpoints: {
     readonly getColonies: {
         readonly path: "characters/{characterId}/planets";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            solar_system_id: z.ZodNumber;
+            planet_id: z.ZodNumber;
+            planet_type: z.ZodEnum<{
+                temperate: "temperate";
+                barren: "barren";
+                oceanic: "oceanic";
+                ice: "ice";
+                gas: "gas";
+                lava: "lava";
+                storm: "storm";
+                plasma: "plasma";
+            }>;
+            owner_id: z.ZodNumber;
+            last_update: z.ZodString;
+            upgrade_level: z.ZodNumber;
+            num_pins: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getColonyLayout: {
         readonly path: "characters/{characterId}/planets/{planetId}";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "planetId"];
+        readonly responseSchema: z.ZodObject<{
+            links: z.ZodArray<z.ZodObject<{
+                source_pin_id: z.ZodNumber;
+                destination_pin_id: z.ZodNumber;
+                link_level: z.ZodNumber;
+            }, z.core.$loose>>;
+            pins: z.ZodArray<z.ZodObject<{
+                pin_id: z.ZodNumber;
+                type_id: z.ZodNumber;
+                latitude: z.ZodNumber;
+                longitude: z.ZodNumber;
+                schematic_id: z.ZodOptional<z.ZodNumber>;
+                extractor_details: z.ZodOptional<z.ZodObject<{
+                    heads: z.ZodArray<z.ZodObject<{
+                        head_id: z.ZodNumber;
+                        latitude: z.ZodNumber;
+                        longitude: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    product_type_id: z.ZodOptional<z.ZodNumber>;
+                    cycle_time: z.ZodOptional<z.ZodNumber>;
+                    head_radius: z.ZodOptional<z.ZodNumber>;
+                    qty_per_cycle: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+                factory_details: z.ZodOptional<z.ZodObject<{
+                    schematic_id: z.ZodNumber;
+                }, z.core.$loose>>;
+                contents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    type_id: z.ZodNumber;
+                    amount: z.ZodNumber;
+                }, z.core.$loose>>>;
+                install_time: z.ZodOptional<z.ZodString>;
+                expiry_time: z.ZodOptional<z.ZodString>;
+                last_cycle_start: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+            routes: z.ZodArray<z.ZodObject<{
+                route_id: z.ZodNumber;
+                source_pin_id: z.ZodNumber;
+                destination_pin_id: z.ZodNumber;
+                content_type_id: z.ZodNumber;
+                quantity: z.ZodNumber;
+                waypoints: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
     };
     readonly getCorporationCustomsOffices: {
         readonly path: "corporations/{corporationId}/customs_offices";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            office_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            reinforce_exit_start: z.ZodNumber;
+            reinforce_exit_end: z.ZodNumber;
+            alliance_tax_rate: z.ZodOptional<z.ZodNumber>;
+            corporation_tax_rate: z.ZodOptional<z.ZodNumber>;
+            standing_level: z.ZodOptional<z.ZodString>;
+            terrible_standing_tax_rate: z.ZodOptional<z.ZodNumber>;
+            bad_standing_tax_rate: z.ZodOptional<z.ZodNumber>;
+            neutral_standing_tax_rate: z.ZodOptional<z.ZodNumber>;
+            good_standing_tax_rate: z.ZodOptional<z.ZodNumber>;
+            excellent_standing_tax_rate: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getSchematicInformation: {
         readonly path: "universe/schematics/{schematicId}";

package/dist/core/endpoints/piEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"piEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/piEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAyBQ,CAAC"}
+{"version":3,"file":"piEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/piEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BQ,CAAC"}

package/dist/core/endpoints/piEndpoints.js

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.piEndpoints = void 0;
+const zod_1 = require("zod");
+const pi_1 = require("../../schemas/pi");
 exports.piEndpoints = {
     getColonies: {
         path: 'characters/{characterId}/planets',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(pi_1.PlanetaryColonySchema),
     },
     getColonyLayout: {
         path: 'characters/{characterId}/planets/{planetId}',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId', 'planetId'],
+        responseSchema: pi_1.ColonyLayoutSchema,
     },
     getCorporationCustomsOffices: {
         path: 'corporations/{corporationId}/customs_offices',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(pi_1.CustomsOfficeSchema),
     },
     getSchematicInformation: {
         path: 'universe/schematics/{schematicId}',

package/dist/core/endpoints/skillEndpoints.d.ts

@@ -1,15 +1,36 @@
+import { z } from 'zod';
 export declare const skillEndpoints: {
     readonly getCharacterAttributes: {
         readonly path: "characters/{characterId}/attributes";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodObject<{
+            charisma: z.ZodNumber;
+            intelligence: z.ZodNumber;
+            memory: z.ZodNumber;
+            perception: z.ZodNumber;
+            willpower: z.ZodNumber;
+            bonus_remaps: z.ZodOptional<z.ZodNumber>;
+            last_remap_date: z.ZodOptional<z.ZodString>;
+            accrued_remap_cooldown_date: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
     };
     readonly getCharacterSkillQueue: {
         readonly path: "characters/{characterId}/skillqueue";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            skill_id: z.ZodNumber;
+            finished_level: z.ZodNumber;
+            queue_position: z.ZodNumber;
+            level_end_sp: z.ZodOptional<z.ZodNumber>;
+            level_start_sp: z.ZodOptional<z.ZodNumber>;
+            training_start_sp: z.ZodOptional<z.ZodNumber>;
+            start_date: z.ZodOptional<z.ZodString>;
+            finish_date: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
     };
     readonly getCharacterSkills: {
         readonly path: "characters/{characterId}/skills";

package/dist/core/endpoints/skillEndpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/skillEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;CAmBK,CAAC"}
+{"version":3,"file":"skillEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/skillEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBK,CAAC"}