@lgriffin/esi.ts 5.1.0 → 6.0.0

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"}

package/dist/core/endpoints/skillEndpoints.js

@@ -1,18 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.skillEndpoints = void 0;
+const zod_1 = require("zod");
+const skills_1 = require("../../schemas/skills");
+const character_1 = require("../../schemas/character");
 exports.skillEndpoints = {
     getCharacterAttributes: {
         path: 'characters/{characterId}/attributes',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: character_1.CharacterAttributesSchema,
     },
     getCharacterSkillQueue: {
         path: 'characters/{characterId}/skillqueue',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(skills_1.SkillQueueSchema),
     },
     getCharacterSkills: {
         path: 'characters/{characterId}/skills',

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

@@ -1,18 +1,45 @@
+import { z } from 'zod';
 export declare const skyhookEndpoints: {
     readonly getSovereigntyHubs: {
         readonly path: "sovereignty/hubs";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            structure_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            corporation_id: z.ZodNumber;
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            online: z.ZodBoolean;
+            remaining_reagents: z.ZodOptional<z.ZodNumber>;
+            installed_upgrades: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$loose>>;
     };
     readonly getOrbitalSkyhooks: {
         readonly path: "sovereignty/skyhooks";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            structure_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            corporation_id: z.ZodNumber;
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            online: z.ZodBoolean;
+            reagent_silo_capacity: z.ZodOptional<z.ZodNumber>;
+            reagent_silo_level: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getRaidableSkyhooks: {
         readonly path: "sovereignty/skyhooks/raidable";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            structure_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            corporation_id: z.ZodNumber;
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            raidable_at: z.ZodOptional<z.ZodString>;
+            is_raidable: z.ZodBoolean;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=skyhookEndpoints.d.ts.map

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

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

package/dist/core/endpoints/skyhookEndpoints.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.skyhookEndpoints = void 0;
+const zod_1 = require("zod");
+const skyhooks_1 = require("../../schemas/skyhooks");
 exports.skyhookEndpoints = {
     getSovereigntyHubs: {
         path: 'sovereignty/hubs',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(skyhooks_1.SovereigntyHubSchema),
     },
     getOrbitalSkyhooks: {
         path: 'sovereignty/skyhooks',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(skyhooks_1.OrbitalSkyhookSchema),
     },
     getRaidableSkyhooks: {
         path: 'sovereignty/skyhooks/raidable',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(skyhooks_1.RaidableSkyhookSchema),
     },
 };

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

@@ -1,13 +1,50 @@
+import { z } from 'zod';
 export declare const sovereigntyEndpoints: {
     readonly getSovereigntyCampaigns: {
         readonly path: "sovereignty/campaigns";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            campaign_id: z.ZodNumber;
+            structure_id: z.ZodNumber;
+            solar_system_id: z.ZodNumber;
+            constellation_id: z.ZodNumber;
+            event_type: z.ZodEnum<{
+                tcu_defense: "tcu_defense";
+                ihub_defense: "ihub_defense";
+                station_defense: "station_defense";
+                station_freeport: "station_freeport";
+            }>;
+            start_time: z.ZodString;
+            defender_id: z.ZodOptional<z.ZodNumber>;
+            defender_score: z.ZodOptional<z.ZodNumber>;
+            attackers_score: z.ZodOptional<z.ZodNumber>;
+            participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                alliance_id: z.ZodNumber;
+                score: z.ZodNumber;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
     };
     readonly getSovereigntySystems: {
         readonly path: "sovereignty/systems";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            system_id: z.ZodNumber;
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            corporation_id: z.ZodOptional<z.ZodNumber>;
+            faction_id: z.ZodOptional<z.ZodNumber>;
+            military_index: z.ZodOptional<z.ZodNumber>;
+            industry_index: z.ZodOptional<z.ZodNumber>;
+            strategic_index: z.ZodOptional<z.ZodNumber>;
+            structures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                structure_id: z.ZodNumber;
+                structure_type_id: z.ZodNumber;
+                vulnerability_occupancy_level: z.ZodOptional<z.ZodNumber>;
+                vulnerable_start_time: z.ZodOptional<z.ZodString>;
+                vulnerable_end_time: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=sovereigntyEndpoints.d.ts.map

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

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

package/dist/core/endpoints/sovereigntyEndpoints.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sovereigntyEndpoints = void 0;
+const zod_1 = require("zod");
+const sovereignty_1 = require("../../schemas/sovereignty");
 exports.sovereigntyEndpoints = {
     getSovereigntyCampaigns: {
         path: 'sovereignty/campaigns',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(sovereignty_1.SovereigntyCampaignSchema),
     },
     getSovereigntySystems: {
         path: 'sovereignty/systems',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(sovereignty_1.SovereigntySystemSchema),
     },
 };