@lgriffin/esi.ts 5.1.0 → 6.0.0

package/dist/core/endpoints/incursionEndpoints.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.incursionEndpoints = void 0;
+const zod_1 = require("zod");
+const incursions_1 = require("../../schemas/incursions");
 exports.incursionEndpoints = {
     getIncursions: {
         path: 'incursions',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(incursions_1.IncursionSchema),
     },
 };

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

@@ -1,49 +1,152 @@
+import { z } from 'zod';
 export declare const industryEndpoints: {
     readonly getCharacterIndustryJobs: {
         readonly path: "characters/{characterId}/industry/jobs";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            job_id: z.ZodNumber;
+            installer_id: z.ZodNumber;
+            facility_id: z.ZodNumber;
+            station_id: z.ZodNumber;
+            activity_id: z.ZodNumber;
+            blueprint_id: z.ZodNumber;
+            blueprint_type_id: z.ZodNumber;
+            blueprint_location_id: z.ZodNumber;
+            output_location_id: z.ZodNumber;
+            runs: z.ZodNumber;
+            cost: z.ZodOptional<z.ZodNumber>;
+            licensed_runs: z.ZodOptional<z.ZodNumber>;
+            probability: z.ZodOptional<z.ZodNumber>;
+            product_type_id: z.ZodOptional<z.ZodNumber>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                active: "active";
+                delivered: "delivered";
+                paused: "paused";
+                ready: "ready";
+                reverted: "reverted";
+            }>;
+            duration: z.ZodNumber;
+            start_date: z.ZodString;
+            end_date: z.ZodString;
+            pause_date: z.ZodOptional<z.ZodString>;
+            completed_date: z.ZodOptional<z.ZodString>;
+            completed_character_id: z.ZodOptional<z.ZodNumber>;
+            successful_runs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCharacterMiningLedger: {
         readonly path: "characters/{characterId}/mining";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            date: z.ZodString;
+            solar_system_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getCorporationIndustryJobs: {
         readonly path: "corporations/{corporationId}/industry/jobs";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            job_id: z.ZodNumber;
+            installer_id: z.ZodNumber;
+            facility_id: z.ZodNumber;
+            station_id: z.ZodNumber;
+            activity_id: z.ZodNumber;
+            blueprint_id: z.ZodNumber;
+            blueprint_type_id: z.ZodNumber;
+            blueprint_location_id: z.ZodNumber;
+            output_location_id: z.ZodNumber;
+            runs: z.ZodNumber;
+            cost: z.ZodOptional<z.ZodNumber>;
+            licensed_runs: z.ZodOptional<z.ZodNumber>;
+            probability: z.ZodOptional<z.ZodNumber>;
+            product_type_id: z.ZodOptional<z.ZodNumber>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                active: "active";
+                delivered: "delivered";
+                paused: "paused";
+                ready: "ready";
+                reverted: "reverted";
+            }>;
+            duration: z.ZodNumber;
+            start_date: z.ZodString;
+            end_date: z.ZodString;
+            pause_date: z.ZodOptional<z.ZodString>;
+            completed_date: z.ZodOptional<z.ZodString>;
+            completed_character_id: z.ZodOptional<z.ZodNumber>;
+            successful_runs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getMoonExtractionTimers: {
         readonly path: "corporations/{corporationId}/mining/extractions";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            structure_id: z.ZodNumber;
+            moon_id: z.ZodNumber;
+            extraction_start_time: z.ZodString;
+            chunk_arrival_time: z.ZodString;
+            natural_decay_time: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMiningObservers: {
         readonly path: "corporations/{corporationId}/mining/observers";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            observer_id: z.ZodNumber;
+            observer_type: z.ZodString;
+            last_updated: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMiningObserver: {
         readonly path: "corporations/{corporationId}/mining/observers/{observerId}";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId", "observerId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            recorded_corporation_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            last_updated: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getIndustryFacilities: {
         readonly path: "industry/facilities";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            facility_id: z.ZodNumber;
+            owner_id: z.ZodNumber;
+            region_id: z.ZodNumber;
+            solar_system_id: z.ZodNumber;
+            tax: z.ZodOptional<z.ZodNumber>;
+            type_id: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getIndustrySystems: {
         readonly path: "industry/systems";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            solar_system_id: z.ZodNumber;
+            cost_indices: z.ZodArray<z.ZodObject<{
+                activity: z.ZodString;
+                cost_index: z.ZodNumber;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=industryEndpoints.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"industryEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/industryEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CE,CAAC"}
+{"version":3,"file":"industryEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/industryEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDE,CAAC"}

package/dist/core/endpoints/industryEndpoints.js

@@ -1,51 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.industryEndpoints = void 0;
+const zod_1 = require("zod");
+const industry_1 = require("../../schemas/industry");
 exports.industryEndpoints = {
     getCharacterIndustryJobs: {
         path: 'characters/{characterId}/industry/jobs',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(industry_1.IndustryJobSchema),
     },
     getCharacterMiningLedger: {
         path: 'characters/{characterId}/mining',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(industry_1.MiningLedgerEntrySchema),
     },
     getCorporationIndustryJobs: {
         path: 'corporations/{corporationId}/industry/jobs',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(industry_1.IndustryJobSchema),
     },
     getMoonExtractionTimers: {
         path: 'corporations/{corporationId}/mining/extractions',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(industry_1.MoonExtractionTimerSchema),
     },
     getCorporationMiningObservers: {
         path: 'corporations/{corporationId}/mining/observers',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(industry_1.MiningObserverSchema),
     },
     getCorporationMiningObserver: {
         path: 'corporations/{corporationId}/mining/observers/{observerId}',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId', 'observerId'],
+        responseSchema: zod_1.z.array(industry_1.MiningObserverEntrySchema),
     },
     getIndustryFacilities: {
         path: 'industry/facilities',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(industry_1.IndustryFacilitySchema),
     },
     getIndustrySystems: {
         path: 'industry/systems',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(industry_1.IndustrySystemSchema),
     },
 };

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

@@ -1,8 +1,17 @@
+import { z } from 'zod';
 export declare const insuranceEndpoints: {
     readonly getInsurancePrices: {
         readonly path: "insurance/prices";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            type_id: z.ZodNumber;
+            levels: z.ZodArray<z.ZodObject<{
+                cost: z.ZodNumber;
+                payout: z.ZodNumber;
+                name: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=insuranceEndpoints.d.ts.map

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

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

package/dist/core/endpoints/insuranceEndpoints.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insuranceEndpoints = void 0;
+const zod_1 = require("zod");
+const insurance_1 = require("../../schemas/insurance");
 exports.insuranceEndpoints = {
     getInsurancePrices: {
         path: 'insurance/prices',
         method: 'GET',
         requiresAuth: false,
+        responseSchema: zod_1.z.array(insurance_1.InsurancePriceSchema),
     },
 };

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

@@ -1,21 +1,62 @@
+import { z } from 'zod';
 export declare const killmailEndpoints: {
     readonly getCharacterRecentKillmails: {
         readonly path: "characters/{characterId}/killmails/recent";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            killmail_id: z.ZodNumber;
+            killmail_hash: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationRecentKillmails: {
         readonly path: "corporations/{corporationId}/killmails/recent";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            killmail_id: z.ZodNumber;
+            killmail_hash: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getKillmail: {
         readonly path: "killmails/{killmailId}/{killmailHash}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["killmailId", "killmailHash"];
+        readonly responseSchema: z.ZodObject<{
+            killmail_id: z.ZodNumber;
+            killmail_time: z.ZodString;
+            solar_system_id: z.ZodNumber;
+            moon_id: z.ZodOptional<z.ZodNumber>;
+            war_id: z.ZodOptional<z.ZodNumber>;
+            victim: z.ZodObject<{
+                character_id: z.ZodOptional<z.ZodNumber>;
+                corporation_id: z.ZodOptional<z.ZodNumber>;
+                alliance_id: z.ZodOptional<z.ZodNumber>;
+                faction_id: z.ZodOptional<z.ZodNumber>;
+                ship_type_id: z.ZodNumber;
+                damage_taken: z.ZodNumber;
+                position: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    z: z.ZodNumber;
+                }, z.core.$loose>>;
+                items: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            }, z.core.$loose>;
+            attackers: z.ZodArray<z.ZodObject<{
+                character_id: z.ZodOptional<z.ZodNumber>;
+                corporation_id: z.ZodOptional<z.ZodNumber>;
+                alliance_id: z.ZodOptional<z.ZodNumber>;
+                faction_id: z.ZodOptional<z.ZodNumber>;
+                ship_type_id: z.ZodOptional<z.ZodNumber>;
+                weapon_type_id: z.ZodOptional<z.ZodNumber>;
+                damage_done: z.ZodNumber;
+                final_blow: z.ZodBoolean;
+                security_status: z.ZodNumber;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
     };
 };
 //# sourceMappingURL=killmailEndpoints.d.ts.map

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

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

package/dist/core/endpoints/killmailEndpoints.js

@@ -1,23 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.killmailEndpoints = void 0;
+const zod_1 = require("zod");
+const killmails_1 = require("../../schemas/killmails");
 exports.killmailEndpoints = {
     getCharacterRecentKillmails: {
         path: 'characters/{characterId}/killmails/recent',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(killmails_1.KillmailSummarySchema),
     },
     getCorporationRecentKillmails: {
         path: 'corporations/{corporationId}/killmails/recent',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(killmails_1.KillmailSummarySchema),
     },
     getKillmail: {
         path: 'killmails/{killmailId}/{killmailHash}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['killmailId', 'killmailHash'],
+        responseSchema: killmails_1.KillmailSchema,
     },
 };

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

@@ -4,18 +4,34 @@ export declare const locationEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            solar_system_id: import("zod").ZodNumber;
+            station_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+            structure_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getCharacterOnline: {
         readonly path: "characters/{characterId}/online";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            online: import("zod").ZodBoolean;
+            last_login: import("zod").ZodOptional<import("zod").ZodString>;
+            last_logout: import("zod").ZodOptional<import("zod").ZodString>;
+            logins: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getCharacterShip: {
         readonly path: "characters/{characterId}/ship";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            ship_item_id: import("zod").ZodNumber;
+            ship_name: import("zod").ZodString;
+            ship_type_id: import("zod").ZodNumber;
+        }, import("zod/v4/core").$loose>;
     };
 };
 //# sourceMappingURL=locationEndpoints.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"locationEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/locationEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CAmBE,CAAC"}
+{"version":3,"file":"locationEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/locationEndpoints.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBE,CAAC"}

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}/',