@lgriffin/esi.ts 5.2.0 → 6.0.0

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare const freelanceJobsEndpoints: {
     readonly getFreelanceJobs: {
         readonly path: "freelance-jobs";
@@ -7,12 +8,79 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
+        readonly responseSchema: z.ZodObject<{
+            cursor: z.ZodObject<{
+                before: z.ZodNullable<z.ZodString>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            freelance_jobs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                state: z.ZodString;
+                last_modified: z.ZodString;
+                progress: z.ZodObject<{
+                    current: z.ZodNumber;
+                    desired: z.ZodNumber;
+                }, z.core.$loose>;
+                reward: z.ZodOptional<z.ZodObject<{
+                    initial: z.ZodNumber;
+                    remaining: z.ZodNumber;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
     };
     readonly getFreelanceJobById: {
         readonly path: "freelance-jobs/{jobId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["jobId"];
+        readonly responseSchema: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            state: z.ZodString;
+            last_modified: z.ZodString;
+            progress: z.ZodObject<{
+                current: z.ZodNumber;
+                desired: z.ZodNumber;
+            }, z.core.$loose>;
+            reward: z.ZodOptional<z.ZodObject<{
+                initial: z.ZodNumber;
+                remaining: z.ZodNumber;
+            }, z.core.$loose>>;
+            details: z.ZodObject<{
+                description: z.ZodString;
+                career: z.ZodString;
+                created: z.ZodString;
+                expires: z.ZodString;
+                creator: z.ZodObject<{
+                    character: z.ZodObject<{
+                        id: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$loose>;
+                    corporation: z.ZodObject<{
+                        id: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$loose>;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            configuration: z.ZodObject<{
+                version: z.ZodNumber;
+                parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                method: z.ZodString;
+            }, z.core.$loose>;
+            contribution: z.ZodObject<{
+                max_committed_participants: z.ZodNumber;
+                reward_per_contribution: z.ZodNumber;
+                submission_multiplier: z.ZodNumber;
+            }, z.core.$loose>;
+            access_and_visibility: z.ZodObject<{
+                acl_protected: z.ZodBoolean;
+                broadcast_locations: z.ZodArray<z.ZodObject<{
+                    id: z.ZodNumber;
+                    name: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
     };
     readonly getCharacterFreelanceJobs: {
         readonly path: "characters/{characterId}/freelance-jobs";
@@ -23,12 +91,39 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
+        readonly responseSchema: z.ZodObject<{
+            cursor: z.ZodObject<{
+                before: z.ZodNullable<z.ZodString>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            freelance_jobs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                state: z.ZodString;
+                last_modified: z.ZodString;
+                progress: z.ZodObject<{
+                    current: z.ZodNumber;
+                    desired: z.ZodNumber;
+                }, z.core.$loose>;
+                reward: z.ZodOptional<z.ZodObject<{
+                    initial: z.ZodNumber;
+                    remaining: z.ZodNumber;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
     };
     readonly getCharacterFreelanceJobParticipation: {
         readonly path: "characters/{characterId}/freelance-jobs/{jobId}/participation";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "jobId"];
+        readonly responseSchema: z.ZodObject<{
+            job_id: z.ZodString;
+            character_id: z.ZodNumber;
+            status: z.ZodString;
+            contributions: z.ZodNumber;
+            last_contribution: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
     };
     readonly getCorporationFreelanceJobs: {
         readonly path: "corporations/{corporationId}/freelance-jobs";
@@ -39,12 +134,39 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
+        readonly responseSchema: z.ZodObject<{
+            cursor: z.ZodObject<{
+                before: z.ZodNullable<z.ZodString>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            freelance_jobs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                state: z.ZodString;
+                last_modified: z.ZodString;
+                progress: z.ZodObject<{
+                    current: z.ZodNumber;
+                    desired: z.ZodNumber;
+                }, z.core.$loose>;
+                reward: z.ZodOptional<z.ZodObject<{
+                    initial: z.ZodNumber;
+                    remaining: z.ZodNumber;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
     };
     readonly getCorporationFreelanceJobParticipants: {
         readonly path: "corporations/{corporationId}/freelance-jobs/{jobId}/participants";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId", "jobId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            corporation_id: z.ZodNumber;
+            status: z.ZodString;
+            contributions: z.ZodNumber;
+            last_contribution: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=freelanceJobsEndpoints.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"freelanceJobsEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/freelanceJobsEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCH,CAAC"}
+{"version":3,"file":"freelanceJobsEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/freelanceJobsEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CH,CAAC"}

package/dist/core/endpoints/freelanceJobsEndpoints.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.freelanceJobsEndpoints = void 0;
+const zod_1 = require("zod");
+const freelance_jobs_1 = require("../../schemas/freelance-jobs");
 exports.freelanceJobsEndpoints = {
     getFreelanceJobs: {
         path: 'freelance-jobs',
         method: 'GET',
         requiresAuth: false,
         queryParams: { before: 'before', after: 'after' },
+        responseSchema: freelance_jobs_1.FreelanceJobsListingSchema,
     },
     getFreelanceJobById: {
         path: 'freelance-jobs/{jobId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['jobId'],
+        responseSchema: freelance_jobs_1.FreelanceJobDetailSchema,
     },
     getCharacterFreelanceJobs: {
         path: 'characters/{characterId}/freelance-jobs',
@@ -20,12 +24,14 @@ exports.freelanceJobsEndpoints = {
         requiresAuth: true,
         pathParams: ['characterId'],
         queryParams: { before: 'before', after: 'after' },
+        responseSchema: freelance_jobs_1.CharacterFreelanceJobsListingSchema,
     },
     getCharacterFreelanceJobParticipation: {
         path: 'characters/{characterId}/freelance-jobs/{jobId}/participation',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId', 'jobId'],
+        responseSchema: freelance_jobs_1.FreelanceJobParticipationSchema,
     },
     getCorporationFreelanceJobs: {
         path: 'corporations/{corporationId}/freelance-jobs',
@@ -33,11 +39,13 @@ exports.freelanceJobsEndpoints = {
         requiresAuth: true,
         pathParams: ['corporationId'],
         queryParams: { before: 'before', after: 'after' },
+        responseSchema: freelance_jobs_1.CorporationFreelanceJobsListingSchema,
     },
     getCorporationFreelanceJobParticipants: {
         path: 'corporations/{corporationId}/freelance-jobs/{jobId}/participants',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId', 'jobId'],
+        responseSchema: zod_1.z.array(freelance_jobs_1.FreelanceJobParticipantSchema),
     },
 };

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

@@ -1,8 +1,23 @@
+import { z } from 'zod';
 export declare const incursionEndpoints: {
     readonly getIncursions: {
         readonly path: "incursions";
         readonly method: "GET";
         readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            state: z.ZodEnum<{
+                withdrawing: "withdrawing";
+                mobilizing: "mobilizing";
+                established: "established";
+            }>;
+            staging_solar_system_id: z.ZodNumber;
+            constellation_id: z.ZodNumber;
+            infested_solar_systems: z.ZodArray<z.ZodNumber>;
+            has_boss: z.ZodBoolean;
+            faction_id: z.ZodNumber;
+            influence: z.ZodNumber;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=incursionEndpoints.d.ts.map

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

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

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