@lgriffin/esi.ts 5.2.0 → 6.0.0

package/dist/core/endpoints/characterEndpoints.js

@@ -1,42 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.characterEndpoints = void 0;
+const zod_1 = require("zod");
+const character_1 = require("../../schemas/character");
 exports.characterEndpoints = {
     getCharacterPublicInfo: {
         path: 'characters/{characterId}/',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['characterId'],
+        responseSchema: character_1.CharacterInfoSchema,
     },
     getAgentsResearch: {
         path: 'characters/{characterId}/agents_research/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.AgentResearchSchema),
     },
     getBlueprints: {
         path: 'characters/{characterId}/blueprints/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.BlueprintSchema),
     },
     getRoles: {
         path: 'characters/{characterId}/roles',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: character_1.CharacterRoleSchema,
     },
     getStandings: {
         path: 'characters/{characterId}/standings',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.StandingSchema),
     },
     getTitles: {
         path: 'characters/{characterId}/titles',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.CharacterTitleSchema),
     },
     getContactNotifications: {
         path: 'characters/{characterId}/notifications/contacts/',
@@ -49,30 +57,35 @@ exports.characterEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.CorporationHistorySchema),
     },
     getJumpFatigue: {
         path: 'characters/{characterId}/fatigue/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: character_1.JumpFatigueSchema,
     },
     getMedals: {
         path: 'characters/{characterId}/medals/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.MedalSchema),
     },
     getNotifications: {
         path: 'characters/{characterId}/notifications/',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(character_1.NotificationSchema),
     },
     getPortrait: {
         path: 'characters/{characterId}/portrait/',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['characterId'],
+        responseSchema: character_1.CharacterPortraitSchema,
     },
     postCharacterAffiliation: {
         path: 'characters/affiliation',

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

@@ -4,6 +4,27 @@ export declare const cloneEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            home_location: import("zod").ZodOptional<import("zod").ZodObject<{
+                location_id: import("zod").ZodNumber;
+                location_type: import("zod").ZodEnum<{
+                    station: "station";
+                    structure: "structure";
+                }>;
+            }, import("zod/v4/core").$loose>>;
+            jump_clones: import("zod").ZodArray<import("zod").ZodObject<{
+                jump_clone_id: import("zod").ZodNumber;
+                location_id: import("zod").ZodNumber;
+                location_type: import("zod").ZodEnum<{
+                    station: "station";
+                    structure: "structure";
+                }>;
+                implants: import("zod").ZodArray<import("zod").ZodNumber>;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            last_clone_jump_date: import("zod").ZodOptional<import("zod").ZodString>;
+            last_station_change_date: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getImplants: {
         readonly path: "characters/{characterId}/implants";

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

@@ -1 +1 @@
-{"version":3,"file":"cloneEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/cloneEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAaK,CAAC"}
+{"version":3,"file":"cloneEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/cloneEndpoints.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcK,CAAC"}

package/dist/core/endpoints/cloneEndpoints.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cloneEndpoints = void 0;
+const clones_1 = require("../../schemas/clones");
 exports.cloneEndpoints = {
     getClones: {
         path: 'characters/{characterId}/clones',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: clones_1.CloneInfoSchema,
     },
     getImplants: {
         path: 'characters/{characterId}/implants',

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

@@ -1,39 +1,88 @@
+import { z } from 'zod';
 export declare const contactEndpoints: {
     readonly getAllianceContacts: {
         readonly path: "alliances/{allianceId}/contacts";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["allianceId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contact_id: z.ZodNumber;
+            contact_type: z.ZodEnum<{
+                character: "character";
+                corporation: "corporation";
+                alliance: "alliance";
+                faction: "faction";
+            }>;
+            standing: z.ZodNumber;
+            label_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_watched: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
     };
     readonly getAllianceContactLabels: {
         readonly path: "alliances/{allianceId}/contacts/labels";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["allianceId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            label_id: z.ZodNumber;
+            label_name: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCharacterContacts: {
         readonly path: "characters/{characterId}/contacts";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contact_id: z.ZodNumber;
+            contact_type: z.ZodEnum<{
+                character: "character";
+                corporation: "corporation";
+                alliance: "alliance";
+                faction: "faction";
+            }>;
+            standing: z.ZodNumber;
+            label_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_watched: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
     };
     readonly getCharacterContactLabels: {
         readonly path: "characters/{characterId}/contacts/labels";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            label_id: z.ZodNumber;
+            label_name: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationContacts: {
         readonly path: "corporations/{corporationId}/contacts";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contact_id: z.ZodNumber;
+            contact_type: z.ZodEnum<{
+                character: "character";
+                corporation: "corporation";
+                alliance: "alliance";
+                faction: "faction";
+            }>;
+            standing: z.ZodNumber;
+            label_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_watched: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationContactLabels: {
         readonly path: "corporations/{corporationId}/contacts/labels";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            label_id: z.ZodNumber;
+            label_name: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly addContacts: {
         readonly path: "characters/{characterId}/contacts";

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

@@ -1 +1 @@
-{"version":3,"file":"contactEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/contactEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAwDC,MAAM,EAAE;;CAEN,CAAC"}
+{"version":3,"file":"contactEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/contactEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CA8DC,MAAM,EAAE;;CAEN,CAAC"}

package/dist/core/endpoints/contactEndpoints.js

@@ -1,42 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contactEndpoints = void 0;
+const zod_1 = require("zod");
+const contacts_1 = require("../../schemas/contacts");
 exports.contactEndpoints = {
     getAllianceContacts: {
         path: 'alliances/{allianceId}/contacts',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['allianceId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactSchema),
     },
     getAllianceContactLabels: {
         path: 'alliances/{allianceId}/contacts/labels',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['allianceId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactLabelSchema),
     },
     getCharacterContacts: {
         path: 'characters/{characterId}/contacts',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactSchema),
     },
     getCharacterContactLabels: {
         path: 'characters/{characterId}/contacts/labels',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactLabelSchema),
     },
     getCorporationContacts: {
         path: 'corporations/{corporationId}/contacts',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactSchema),
     },
     getCorporationContactLabels: {
         path: 'corporations/{corporationId}/contacts/labels',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(contacts_1.ContactLabelSchema),
     },
     addContacts: {
         path: 'characters/{characterId}/contacts',

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

@@ -1,57 +1,241 @@
+import { z } from 'zod';
 export declare const contractEndpoints: {
     readonly getCharacterContracts: {
         readonly path: "characters/{characterId}/contracts";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contract_id: z.ZodNumber;
+            issuer_id: z.ZodNumber;
+            issuer_corporation_id: z.ZodNumber;
+            assignee_id: z.ZodOptional<z.ZodNumber>;
+            acceptor_id: z.ZodOptional<z.ZodNumber>;
+            start_location_id: z.ZodOptional<z.ZodNumber>;
+            end_location_id: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodEnum<{
+                unknown: "unknown";
+                item_exchange: "item_exchange";
+                auction: "auction";
+                courier: "courier";
+                loan: "loan";
+            }>;
+            status: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                outstanding: "outstanding";
+                in_progress: "in_progress";
+                finished_issuer: "finished_issuer";
+                finished_contractor: "finished_contractor";
+                finished: "finished";
+                rejected: "rejected";
+                failed: "failed";
+                deleted: "deleted";
+                reversed: "reversed";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            for_corporation: z.ZodOptional<z.ZodBoolean>;
+            availability: z.ZodOptional<z.ZodEnum<{
+                corporation: "corporation";
+                alliance: "alliance";
+                public: "public";
+                personal: "personal";
+            }>>;
+            date_issued: z.ZodString;
+            date_expired: z.ZodString;
+            date_accepted: z.ZodOptional<z.ZodString>;
+            date_completed: z.ZodOptional<z.ZodString>;
+            days_to_complete: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodOptional<z.ZodNumber>;
+            reward: z.ZodOptional<z.ZodNumber>;
+            collateral: z.ZodOptional<z.ZodNumber>;
+            buyout: z.ZodOptional<z.ZodNumber>;
+            volume: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCharacterContractBids: {
         readonly path: "characters/{characterId}/contracts/{contractId}/bids";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            bid_id: z.ZodNumber;
+            bidder_id: z.ZodNumber;
+            date_bid: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getCharacterContractItems: {
         readonly path: "characters/{characterId}/contracts/{contractId}/items";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            record_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            raw_quantity: z.ZodOptional<z.ZodNumber>;
+            is_singleton: z.ZodBoolean;
+            is_blueprint_copy: z.ZodOptional<z.ZodBoolean>;
+            is_included: z.ZodBoolean;
+        }, z.core.$loose>>;
     };
     readonly getCorporationContracts: {
         readonly path: "corporations/{corporationId}/contracts";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contract_id: z.ZodNumber;
+            issuer_id: z.ZodNumber;
+            issuer_corporation_id: z.ZodNumber;
+            assignee_id: z.ZodOptional<z.ZodNumber>;
+            acceptor_id: z.ZodOptional<z.ZodNumber>;
+            start_location_id: z.ZodOptional<z.ZodNumber>;
+            end_location_id: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodEnum<{
+                unknown: "unknown";
+                item_exchange: "item_exchange";
+                auction: "auction";
+                courier: "courier";
+                loan: "loan";
+            }>;
+            status: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                outstanding: "outstanding";
+                in_progress: "in_progress";
+                finished_issuer: "finished_issuer";
+                finished_contractor: "finished_contractor";
+                finished: "finished";
+                rejected: "rejected";
+                failed: "failed";
+                deleted: "deleted";
+                reversed: "reversed";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            for_corporation: z.ZodOptional<z.ZodBoolean>;
+            availability: z.ZodOptional<z.ZodEnum<{
+                corporation: "corporation";
+                alliance: "alliance";
+                public: "public";
+                personal: "personal";
+            }>>;
+            date_issued: z.ZodString;
+            date_expired: z.ZodString;
+            date_accepted: z.ZodOptional<z.ZodString>;
+            date_completed: z.ZodOptional<z.ZodString>;
+            days_to_complete: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodOptional<z.ZodNumber>;
+            reward: z.ZodOptional<z.ZodNumber>;
+            collateral: z.ZodOptional<z.ZodNumber>;
+            buyout: z.ZodOptional<z.ZodNumber>;
+            volume: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationContractBids: {
         readonly path: "corporations/{corporationId}/contracts/{contractId}/bids";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId", "contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            bid_id: z.ZodNumber;
+            bidder_id: z.ZodNumber;
+            date_bid: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getCorporationContractItems: {
         readonly path: "corporations/{corporationId}/contracts/{contractId}/items";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId", "contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            record_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            raw_quantity: z.ZodOptional<z.ZodNumber>;
+            is_singleton: z.ZodBoolean;
+            is_blueprint_copy: z.ZodOptional<z.ZodBoolean>;
+            is_included: z.ZodBoolean;
+        }, z.core.$loose>>;
     };
     readonly getPublicContracts: {
         readonly path: "contracts/public/{regionId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["regionId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            contract_id: z.ZodNumber;
+            issuer_id: z.ZodNumber;
+            issuer_corporation_id: z.ZodNumber;
+            assignee_id: z.ZodOptional<z.ZodNumber>;
+            acceptor_id: z.ZodOptional<z.ZodNumber>;
+            start_location_id: z.ZodOptional<z.ZodNumber>;
+            end_location_id: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodEnum<{
+                unknown: "unknown";
+                item_exchange: "item_exchange";
+                auction: "auction";
+                courier: "courier";
+                loan: "loan";
+            }>;
+            status: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                outstanding: "outstanding";
+                in_progress: "in_progress";
+                finished_issuer: "finished_issuer";
+                finished_contractor: "finished_contractor";
+                finished: "finished";
+                rejected: "rejected";
+                failed: "failed";
+                deleted: "deleted";
+                reversed: "reversed";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            for_corporation: z.ZodOptional<z.ZodBoolean>;
+            availability: z.ZodOptional<z.ZodEnum<{
+                corporation: "corporation";
+                alliance: "alliance";
+                public: "public";
+                personal: "personal";
+            }>>;
+            date_issued: z.ZodString;
+            date_expired: z.ZodString;
+            date_accepted: z.ZodOptional<z.ZodString>;
+            date_completed: z.ZodOptional<z.ZodString>;
+            days_to_complete: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodOptional<z.ZodNumber>;
+            reward: z.ZodOptional<z.ZodNumber>;
+            collateral: z.ZodOptional<z.ZodNumber>;
+            buyout: z.ZodOptional<z.ZodNumber>;
+            volume: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getPublicContractBids: {
         readonly path: "contracts/public/bids/{contractId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            bid_id: z.ZodNumber;
+            bidder_id: z.ZodNumber;
+            date_bid: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getPublicContractItems: {
         readonly path: "contracts/public/items/{contractId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["contractId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            record_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            raw_quantity: z.ZodOptional<z.ZodNumber>;
+            is_singleton: z.ZodBoolean;
+            is_blueprint_copy: z.ZodOptional<z.ZodBoolean>;
+            is_included: z.ZodBoolean;
+        }, z.core.$loose>>;
     };
 };
 //# sourceMappingURL=contractEndpoints.d.ts.map

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

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

package/dist/core/endpoints/contractEndpoints.js

@@ -1,59 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contractEndpoints = void 0;
+const zod_1 = require("zod");
+const contracts_1 = require("../../schemas/contracts");
 exports.contractEndpoints = {
     getCharacterContracts: {
         path: 'characters/{characterId}/contracts',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractSchema),
     },
     getCharacterContractBids: {
         path: 'characters/{characterId}/contracts/{contractId}/bids',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId', 'contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractBidSchema),
     },
     getCharacterContractItems: {
         path: 'characters/{characterId}/contracts/{contractId}/items',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['characterId', 'contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractItemSchema),
     },
     getCorporationContracts: {
         path: 'corporations/{corporationId}/contracts',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractSchema),
     },
     getCorporationContractBids: {
         path: 'corporations/{corporationId}/contracts/{contractId}/bids',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId', 'contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractBidSchema),
     },
     getCorporationContractItems: {
         path: 'corporations/{corporationId}/contracts/{contractId}/items',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId', 'contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractItemSchema),
     },
     getPublicContracts: {
         path: 'contracts/public/{regionId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['regionId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractSchema),
     },
     getPublicContractBids: {
         path: 'contracts/public/bids/{contractId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractBidSchema),
     },
     getPublicContractItems: {
         path: 'contracts/public/items/{contractId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['contractId'],
+        responseSchema: zod_1.z.array(contracts_1.ContractItemSchema),
     },
 };