@lgriffin/esi.ts 5.1.0 → 6.0.0

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

@@ -1,15 +1,39 @@
+import { z } from 'zod';
 export declare const corporationEndpoints: {
     readonly getCorporationInfo: {
         readonly path: "corporations/{corporationId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodObject<{
+            corporation_id: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            ceo_id: z.ZodNumber;
+            creator_id: z.ZodNumber;
+            date_founded: z.ZodOptional<z.ZodString>;
+            faction_id: z.ZodOptional<z.ZodNumber>;
+            home_station_id: z.ZodOptional<z.ZodNumber>;
+            member_count: z.ZodNumber;
+            shares: z.ZodOptional<z.ZodNumber>;
+            tax_rate: z.ZodNumber;
+            war_eligible: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
     };
     readonly getCorporationAllianceHistory: {
         readonly path: "corporations/{corporationId}/alliancehistory";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            alliance_id: z.ZodOptional<z.ZodNumber>;
+            is_deleted: z.ZodOptional<z.ZodBoolean>;
+            record_id: z.ZodNumber;
+            start_date: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationBlueprints: {
         readonly path: "corporations/{corporationId}/blueprints";
@@ -22,18 +46,50 @@ export declare const corporationEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            logged_at: z.ZodString;
+            container_id: z.ZodNumber;
+            container_type_id: z.ZodNumber;
+            character_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            location_flag: z.ZodString;
+            action: z.ZodString;
+            password_type: z.ZodOptional<z.ZodEnum<{
+                config: "config";
+                general: "general";
+            }>>;
+            type_id: z.ZodOptional<z.ZodNumber>;
+            quantity: z.ZodOptional<z.ZodNumber>;
+            old_config_bitmask: z.ZodOptional<z.ZodNumber>;
+            new_config_bitmask: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationDivisions: {
         readonly path: "corporations/{corporationId}/divisions";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodObject<{
+            hangar: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                division: z.ZodNumber;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            wallet: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                division: z.ZodNumber;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>;
     };
     readonly getCorporationFacilities: {
         readonly path: "corporations/{corporationId}/facilities";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            facility_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getCorporationIcon: {
         readonly path: "corporations/{corporationId}/icons";
@@ -46,12 +102,32 @@ export declare const corporationEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            medal_id: z.ZodNumber;
+            title: z.ZodString;
+            description: z.ZodString;
+            creator_id: z.ZodNumber;
+            date: z.ZodString;
+        }, z.core.$loose>>;
     };
     readonly getCorporationIssuedMedals: {
         readonly path: "corporations/{corporationId}/medals/issued";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            medal_id: z.ZodNumber;
+            title: z.ZodString;
+            description: z.ZodString;
+            character_id: z.ZodNumber;
+            issued_at: z.ZodString;
+            issuer_id: z.ZodNumber;
+            reason: z.ZodString;
+            status: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMembers: {
         readonly path: "corporations/{corporationId}/members";
@@ -70,30 +146,71 @@ export declare const corporationEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            titles: z.ZodArray<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMemberTracking: {
         readonly path: "corporations/{corporationId}/membertracking";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            start_date: z.ZodString;
+            base_id: z.ZodOptional<z.ZodNumber>;
+            location_id: z.ZodOptional<z.ZodNumber>;
+            logoff_date: z.ZodOptional<z.ZodString>;
+            logon_date: z.ZodOptional<z.ZodString>;
+            online: z.ZodOptional<z.ZodBoolean>;
+            ship_type_id: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMemberRoles: {
         readonly path: "corporations/{corporationId}/roles";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_hq: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_hq: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_base: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_base: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_other: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_other: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationMemberRolesHistory: {
         readonly path: "corporations/{corporationId}/roles/history";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            character_id: z.ZodNumber;
+            changed_at: z.ZodString;
+            issuer_id: z.ZodNumber;
+            role_type: z.ZodString;
+            before: z.ZodArray<z.ZodString>;
+            after: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationShareholders: {
         readonly path: "corporations/{corporationId}/shareholders";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            shareholder_id: z.ZodNumber;
+            shareholder_type: z.ZodEnum<{
+                character: "character";
+                corporation: "corporation";
+            }>;
+            share_count: z.ZodNumber;
+        }, z.core.$loose>>;
     };
     readonly getCorporationStandings: {
         readonly path: "corporations/{corporationId}/standings";
@@ -106,24 +223,99 @@ export declare const corporationEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            starbase_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            state: z.ZodEnum<{
+                offline: "offline";
+                online: "online";
+                onlining: "onlining";
+                reinforced: "reinforced";
+                unanchoring: "unanchoring";
+            }>;
+            moon_id: z.ZodOptional<z.ZodNumber>;
+            onlined_since: z.ZodOptional<z.ZodString>;
+            reinforced_until: z.ZodOptional<z.ZodString>;
+            unanchor_at: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationStarbaseDetail: {
         readonly path: "corporations/{corporationId}/starbases/{starbaseId}";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId", "starbaseId"];
+        readonly responseSchema: z.ZodObject<{
+            state: z.ZodEnum<{
+                offline: "offline";
+                online: "online";
+                onlining: "onlining";
+                reinforced: "reinforced";
+                unanchoring: "unanchoring";
+            }>;
+            fuels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type_id: z.ZodNumber;
+                quantity: z.ZodNumber;
+            }, z.core.$loose>>>;
+            allow_alliance_members: z.ZodOptional<z.ZodBoolean>;
+            allow_corporation_members: z.ZodOptional<z.ZodBoolean>;
+            anchor: z.ZodOptional<z.ZodString>;
+            attack_if_at_war: z.ZodOptional<z.ZodBoolean>;
+            attack_if_other_security_status_dropping: z.ZodOptional<z.ZodBoolean>;
+            attack_security_status_threshold: z.ZodOptional<z.ZodNumber>;
+            fuel_bay_take: z.ZodOptional<z.ZodString>;
+            fuel_bay_view: z.ZodOptional<z.ZodString>;
+            offline: z.ZodOptional<z.ZodString>;
+            online: z.ZodOptional<z.ZodString>;
+            unanchor: z.ZodOptional<z.ZodString>;
+            use_alliance_standings: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
     };
     readonly getCorporationStructures: {
         readonly path: "corporations/{corporationId}/structures";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            structure_id: z.ZodNumber;
+            corporation_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            profile_id: z.ZodNumber;
+            services: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                state: z.ZodEnum<{
+                    offline: "offline";
+                    online: "online";
+                    cleanup: "cleanup";
+                }>;
+            }, z.core.$loose>>>;
+            fuel_expires: z.ZodOptional<z.ZodString>;
+            state: z.ZodString;
+            state_timer_start: z.ZodOptional<z.ZodString>;
+            state_timer_end: z.ZodOptional<z.ZodString>;
+            unanchors_at: z.ZodOptional<z.ZodString>;
+            reinforce_hour: z.ZodOptional<z.ZodNumber>;
+            next_reinforce_apply: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
     };
     readonly getCorporationTitles: {
         readonly path: "corporations/{corporationId}/titles";
         readonly method: "GET";
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            title_id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_hq: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_hq: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_base: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_base: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            roles_at_other: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grantable_roles_at_other: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
     };
     readonly getNpcCorporations: {
         readonly path: "corporations/npccorps";

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

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

package/dist/core/endpoints/corporationEndpoints.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.corporationEndpoints = void 0;
+const zod_1 = require("zod");
+const corporation_1 = require("../../schemas/corporation");
 exports.corporationEndpoints = {
     getCorporationInfo: {
         path: 'corporations/{corporationId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['corporationId'],
+        responseSchema: corporation_1.CorporationInfoSchema,
     },
     getCorporationAllianceHistory: {
         path: 'corporations/{corporationId}/alliancehistory',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationAllianceHistorySchema),
     },
     getCorporationBlueprints: {
         path: 'corporations/{corporationId}/blueprints',
@@ -25,18 +29,21 @@ exports.corporationEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.ContainerLogSchema),
     },
     getCorporationDivisions: {
         path: 'corporations/{corporationId}/divisions',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: corporation_1.CorporationDivisionsSchema,
     },
     getCorporationFacilities: {
         path: 'corporations/{corporationId}/facilities',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationFacilitySchema),
     },
     getCorporationIcon: {
         path: 'corporations/{corporationId}/icons',
@@ -49,12 +56,14 @@ exports.corporationEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationMedalSchema),
     },
     getCorporationIssuedMedals: {
         path: 'corporations/{corporationId}/medals/issued',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationIssuedMedalSchema),
     },
     getCorporationMembers: {
         path: 'corporations/{corporationId}/members',
@@ -73,30 +82,35 @@ exports.corporationEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationMemberTitleSchema),
     },
     getCorporationMemberTracking: {
         path: 'corporations/{corporationId}/membertracking',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationMemberTrackingSchema),
     },
     getCorporationMemberRoles: {
         path: 'corporations/{corporationId}/roles',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationMemberRoleSchema),
     },
     getCorporationMemberRolesHistory: {
         path: 'corporations/{corporationId}/roles/history',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationRoleHistorySchema),
     },
     getCorporationShareholders: {
         path: 'corporations/{corporationId}/shareholders',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationShareholderSchema),
     },
     getCorporationStandings: {
         path: 'corporations/{corporationId}/standings',
@@ -109,24 +123,28 @@ exports.corporationEndpoints = {
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationStarbaseSchema),
     },
     getCorporationStarbaseDetail: {
         path: 'corporations/{corporationId}/starbases/{starbaseId}',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId', 'starbaseId'],
+        responseSchema: corporation_1.CorporationStarbaseDetailSchema,
     },
     getCorporationStructures: {
         path: 'corporations/{corporationId}/structures',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationStructureSchema),
     },
     getCorporationTitles: {
         path: 'corporations/{corporationId}/titles',
         method: 'GET',
         requiresAuth: true,
         pathParams: ['corporationId'],
+        responseSchema: zod_1.z.array(corporation_1.CorporationTitleSchema),
     },
     getNpcCorporations: {
         path: 'corporations/npccorps',

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

@@ -1 +1 @@
-{"version":3,"file":"createClient.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/createClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAmB,MAAM,2BAA2B,CAAC;AAKzE,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,KAAK,aAAa,CAAC,CAAC,SAAS,WAAW,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAC3B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAC/D,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GACvC,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAmBF,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAChD,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,CAAC,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,CAAC,CAAC,CA8HlB;AAGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,KAAK,GAAG,OAAO,EAClE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EAChE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,KAAK,EAAE,EAC1C,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,GACA,OAAO,CAAC,KAAK,EAAE,CAAC,CA0BlB"}
+{"version":3,"file":"createClient.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/createClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAmB,MAAM,2BAA2B,CAAC;AAMzE,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,KAAK,aAAa,CAAC,CAAC,SAAS,WAAW,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAC3B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAC/D,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GACvC,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AA8BF,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAChD,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,CAAC,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,CAAC,CAAC,CAqGlB;AAGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,KAAK,GAAG,OAAO,EAClE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EAChE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,KAAK,EAAE,EAC1C,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,GACA,OAAO,CAAC,KAAK,EAAE,CAAC,CA0BlB"}

package/dist/core/endpoints/createClient.js

@@ -3,15 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createClient = createClient;
 exports.fetchAllCursorPages = fetchAllCursorPages;
 const ApiRequestHandler_1 = require("../ApiRequestHandler");
-const validation_1 = require("../util/validation");
+const buildEndpointPath_1 = require("./buildEndpointPath");
 const headersUtil_1 = require("../util/headersUtil");
 const loggerUtil_1 = require("../logger/loggerUtil");
+const error_1 = require("../util/error");
 function buildMeta(response) {
     const meta = {
         headers: response.headers,
         fromCache: response.fromCache ?? false,
         stale: response.stale ?? false,
     };
+    if (response.cacheHitType)
+        meta.cacheHitType = response.cacheHitType;
+    if (response.responseTimeMs !== undefined)
+        meta.responseTimeMs = response.responseTimeMs;
     const w = (0, headersUtil_1.parseWarning)(response.headers['warning']);
     if (w)
         meta.warning = w;
@@ -21,6 +26,14 @@ function buildMeta(response) {
         meta.date = response.headers['date'];
     if (response.headers['content-language'])
         meta.contentLanguage = response.headers['content-language'];
+    if (response.headers['x-ratelimit-remaining']) {
+        meta.rateLimit = {
+            remaining: parseInt(response.headers['x-ratelimit-remaining'], 10),
+            limit: parseInt(response.headers['x-ratelimit-limit'] ?? '0', 10),
+            used: parseInt(response.headers['x-ratelimit-used'] ?? '0', 10),
+            group: response.headers['x-ratelimit-group'] ?? null,
+        };
+    }
     return meta;
 }
 /* eslint-disable sonarjs/cognitive-complexity */
@@ -40,44 +53,9 @@ function createClient(apiClient, endpoints, options) {
                     parts.push(`Sunset date: ${def.deprecated.sunsetDate}.`);
                 (0, loggerUtil_1.logWarn)(parts.join(' '));
             }
-            let argIndex = 0;
-            let path = def.path;
-            if (def.pathParams) {
-                for (const param of def.pathParams) {
-                    const raw = args[argIndex++];
-                    const validated = (0, validation_1.validatePathParam)(param, raw);
-                    path = path.replace(`{${param}}`, encodeURIComponent(validated));
-                }
-            }
-            if (def.queryParams) {
-                const queryParts = [];
-                for (const [paramName, queryKey] of Object.entries(def.queryParams)) {
-                    const value = args[argIndex++];
-                    if (value !== undefined) {
-                        const validated = (0, validation_1.validateQueryParam)(paramName, value);
-                        queryParts.push(`${queryKey}=${encodeURIComponent(validated)}`);
-                    }
-                }
-                if (queryParts.length > 0) {
-                    path += (path.includes('?') ? '&' : '?') + queryParts.join('&');
-                }
-            }
-            let body = undefined;
-            if (def.bodyBuilder) {
-                /* eslint-disable @typescript-eslint/no-unsafe-argument */
-                body = def.bodyBuilder(...args.slice(argIndex));
-                /* eslint-enable @typescript-eslint/no-unsafe-argument */
-            }
-            else if (def.hasBody) {
-                // eslint-disable-next-line security/detect-object-injection
-                body = args[argIndex];
-            }
-            const datasource = apiClient.getDatasource();
-            if (datasource) {
-                path +=
-                    (path.includes('?') ? '&' : '?') +
-                        `datasource=${encodeURIComponent(datasource)}`;
-            }
+            const built = (0, buildEndpointPath_1.buildEndpointPath)(def, args, apiClient.getDatasource());
+            let path = built.path;
+            const body = built.body;
             if (def.cursorPagination) {
                 const lastArg = args[args.length - 1];
                 const isCursorArg = lastArg != null &&
@@ -96,7 +74,7 @@ function createClient(apiClient, endpoints, options) {
                         path += (path.includes('?') ? '&' : '?') + parts.join('&');
                     }
                 }
-                const response = await (0, ApiRequestHandler_1.handleRequest)(apiClient, path, def.method, body, def.requiresAuth);
+                const response = await (0, ApiRequestHandler_1.handleRequest)(apiClient, path, def.method, body, def.requiresAuth, true, def.path);
                 const responseBody = response.body;
                 let data;
                 if (Array.isArray(responseBody)) {
@@ -117,11 +95,19 @@ function createClient(apiClient, endpoints, options) {
                 }
                 return cursorResult;
             }
-            const response = await (0, ApiRequestHandler_1.handleRequest)(apiClient, path, def.method, body, def.requiresAuth);
+            const response = await (0, ApiRequestHandler_1.handleRequest)(apiClient, path, def.method, body, def.requiresAuth, true, def.path);
+            let responseBody = response.body;
+            if (def.responseSchema && apiClient.getValidateResponse()) {
+                const result = def.responseSchema.safeParse(responseBody);
+                if (!result.success) {
+                    throw new error_1.EsiValidationError(`${apiClient.getLink()}/${path}`, result.error);
+                }
+                responseBody = result.data;
+            }
             if (returnMetadata) {
-                return { data: response.body, meta: buildMeta(response) };
+                return { data: responseBody, meta: buildMeta(response) };
             }
-            return response.body;
+            return responseBody;
         };
     }
     return client;

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

@@ -9,6 +9,18 @@ export declare const dogmaEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["attributeId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            attribute_id: import("zod").ZodNumber;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            icon_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+            default_value: import("zod").ZodOptional<import("zod").ZodNumber>;
+            published: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            display_name: import("zod").ZodOptional<import("zod").ZodString>;
+            unit_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+            stackable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            high_is_good: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getEffects: {
         readonly path: "dogma/effects";
@@ -20,12 +32,38 @@ export declare const dogmaEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["effectId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            effect_id: import("zod").ZodNumber;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            icon_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+            display_name: import("zod").ZodOptional<import("zod").ZodString>;
+            published: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            effect_category: import("zod").ZodOptional<import("zod").ZodNumber>;
+            is_assistance: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            is_offensive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            is_warp_safe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            disallow_auto_repeat: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getDynamicItemInfo: {
         readonly path: "dogma/dynamic/items/{typeId}/{itemId}";
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly pathParams: readonly ["typeId", "itemId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            created_by: import("zod").ZodNumber;
+            dogma_attributes: import("zod").ZodArray<import("zod").ZodObject<{
+                attribute_id: import("zod").ZodNumber;
+                value: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>>;
+            dogma_effects: import("zod").ZodArray<import("zod").ZodObject<{
+                effect_id: import("zod").ZodNumber;
+                is_default: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$loose>>;
+            mutator_type_id: import("zod").ZodNumber;
+            source_type_id: import("zod").ZodNumber;
+        }, import("zod/v4/core").$loose>;
     };
 };
 //# sourceMappingURL=dogmaEndpoints.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dogmaEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/dogmaEndpoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BK,CAAC"}
+{"version":3,"file":"dogmaEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/dogmaEndpoints.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCK,CAAC"}

package/dist/core/endpoints/dogmaEndpoints.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dogmaEndpoints = void 0;
+const dogma_1 = require("../../schemas/dogma");
 exports.dogmaEndpoints = {
     getAttributes: {
         path: 'dogma/attributes',
@@ -12,6 +13,7 @@ exports.dogmaEndpoints = {
         method: 'GET',
         requiresAuth: false,
         pathParams: ['attributeId'],
+        responseSchema: dogma_1.DogmaAttributeSchema,
     },
     getEffects: {
         path: 'dogma/effects',
@@ -23,11 +25,13 @@ exports.dogmaEndpoints = {
         method: 'GET',
         requiresAuth: false,
         pathParams: ['effectId'],
+        responseSchema: dogma_1.DogmaEffectSchema,
     },
     getDynamicItemInfo: {
         path: 'dogma/dynamic/items/{typeId}/{itemId}',
         method: 'GET',
         requiresAuth: false,
         pathParams: ['typeId', 'itemId'],
+        responseSchema: dogma_1.DogmaDynamicItemSchema,
     },
 };

package/dist/core/endpoints/esi-cache-ttls.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const esiCacheTtls: Record<string, number>;
+//# sourceMappingURL=esi-cache-ttls.generated.d.ts.map

package/dist/core/endpoints/esi-cache-ttls.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esi-cache-ttls.generated.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/esi-cache-ttls.generated.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwH/C,CAAC"}