@lgriffin/esi.ts 9.7.0 → 10.2.0

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

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 export declare const freelanceJobsEndpoints: {
     readonly getFreelanceJobs: {
         readonly path: "freelance-jobs";
@@ -8,79 +7,86 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
-        readonly responseSchema: z.ZodObject<{
-            cursor: z.ZodOptional<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 responseSchema: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodObject<{
+                before: import("zod").ZodOptional<import("zod").ZodString>;
+                after: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            freelance_jobs: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                state: import("zod").ZodString;
+                last_modified: import("zod").ZodString;
+                progress: import("zod").ZodObject<{
+                    current: import("zod").ZodNumber;
+                    desired: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>;
+                reward: import("zod").ZodOptional<import("zod").ZodObject<{
+                    initial: import("zod").ZodNumber;
+                    remaining: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/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.ZodOptional<z.ZodNumber>;
-                submission_multiplier: z.ZodOptional<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 responseSchema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            state: import("zod").ZodString;
+            last_modified: import("zod").ZodString;
+            progress: import("zod").ZodObject<{
+                current: import("zod").ZodNumber;
+                desired: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>;
+            reward: import("zod").ZodOptional<import("zod").ZodObject<{
+                initial: import("zod").ZodNumber;
+                remaining: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>>;
+            details: import("zod").ZodObject<{
+                description: import("zod").ZodString;
+                career: import("zod").ZodString;
+                created: import("zod").ZodString;
+                expires: import("zod").ZodOptional<import("zod").ZodString>;
+                finished: import("zod").ZodOptional<import("zod").ZodString>;
+                creator: import("zod").ZodObject<{
+                    character: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$loose>;
+                    corporation: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$loose>;
+                }, import("zod/v4/core").$loose>;
+            }, import("zod/v4/core").$loose>;
+            configuration: import("zod").ZodObject<{
+                version: import("zod").ZodNumber;
+                parameters: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                method: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>;
+            contribution: import("zod").ZodOptional<import("zod").ZodObject<{
+                max_committed_participants: import("zod").ZodNumber;
+                contribution_per_participant_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                reward_per_contribution: import("zod").ZodOptional<import("zod").ZodNumber>;
+                submission_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                submission_multiplier: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$loose>>;
+            access_and_visibility: import("zod").ZodObject<{
+                acl_protected: import("zod").ZodBoolean;
+                broadcast_locations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodNumber;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>>>;
+                restrictions: import("zod").ZodOptional<import("zod").ZodObject<{
+                    minimum_age: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    maximum_age: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getCharacterFreelanceJobs: {
         readonly path: "characters/{characterId}/freelance-jobs";
@@ -91,39 +97,37 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
-        readonly responseSchema: z.ZodObject<{
-            cursor: z.ZodOptional<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 responseSchema: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodObject<{
+                before: import("zod").ZodOptional<import("zod").ZodString>;
+                after: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            freelance_jobs: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                state: import("zod").ZodString;
+                last_modified: import("zod").ZodString;
+                progress: import("zod").ZodObject<{
+                    current: import("zod").ZodNumber;
+                    desired: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>;
+                reward: import("zod").ZodOptional<import("zod").ZodObject<{
+                    initial: import("zod").ZodNumber;
+                    remaining: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/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 responseSchema: import("zod").ZodObject<{
+            state: import("zod").ZodType<(string & {}) | "Unspecified" | "Committed" | "Kicked" | "Resigned", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "Unspecified" | "Committed" | "Kicked" | "Resigned", unknown>>;
+            contributed: import("zod").ZodNumber;
+            last_modified: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
     };
     readonly getCorporationFreelanceJobs: {
         readonly path: "corporations/{corporationId}/freelance-jobs";
@@ -134,39 +138,44 @@ export declare const freelanceJobsEndpoints: {
             readonly before: "before";
             readonly after: "after";
         };
-        readonly responseSchema: z.ZodObject<{
-            cursor: z.ZodOptional<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 responseSchema: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodObject<{
+                before: import("zod").ZodOptional<import("zod").ZodString>;
+                after: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            freelance_jobs: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                state: import("zod").ZodString;
+                last_modified: import("zod").ZodString;
+                progress: import("zod").ZodObject<{
+                    current: import("zod").ZodNumber;
+                    desired: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>;
+                reward: import("zod").ZodOptional<import("zod").ZodObject<{
+                    initial: import("zod").ZodNumber;
+                    remaining: import("zod").ZodNumber;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/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>>;
+        readonly responseSchema: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodObject<{
+                before: import("zod").ZodOptional<import("zod").ZodString>;
+                after: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            participants: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodNumber;
+                name: import("zod").ZodString;
+                state: import("zod").ZodType<(string & {}) | "Unspecified" | "Committed" | "Kicked" | "Resigned", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "Unspecified" | "Committed" | "Kicked" | "Resigned", unknown>>;
+                contributed: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/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":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CH,CAAC"}
+{"version":3,"file":"freelanceJobsEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/freelanceJobsEndpoints.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CH,CAAC"}

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

@@ -0,0 +1,19 @@
+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.ZodType<(string & {}) | "withdrawing" | "mobilizing" | "established", unknown, z.core.$ZodTypeInternals<(string & {}) | "withdrawing" | "mobilizing" | "established", unknown>>;
+            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/industryEndpoints.d.mts

@@ -0,0 +1,138 @@
+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.ZodType<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown>>;
+            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<{
+            status: z.ZodType<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown>>;
+            runs: z.ZodNumber;
+            start_date: z.ZodString;
+            facility_id: z.ZodNumber;
+            duration: z.ZodNumber;
+            job_id: z.ZodNumber;
+            installer_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;
+            cost: z.ZodOptional<z.ZodNumber>;
+            licensed_runs: z.ZodOptional<z.ZodNumber>;
+            probability: z.ZodOptional<z.ZodNumber>;
+            product_type_id: z.ZodOptional<z.ZodNumber>;
+            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>;
+            location_id: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getMoonExtractionTimers: {
+        readonly path: "corporation/{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: "corporation/{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: "corporation/{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

@@ -48,28 +48,28 @@ export declare const industryEndpoints: {
         readonly requiresAuth: true;
         readonly pathParams: readonly ["corporationId"];
         readonly responseSchema: z.ZodArray<z.ZodObject<{
+            status: z.ZodType<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown>>;
+            runs: z.ZodNumber;
+            start_date: z.ZodString;
+            facility_id: z.ZodNumber;
+            duration: z.ZodNumber;
             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.ZodType<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "active" | "delivered" | "paused" | "ready" | "reverted", unknown>>;
-            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>;
+            location_id: z.ZodNumber;
         }, z.core.$loose>>;
     };
     readonly getMoonExtractionTimers: {

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":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDE,CAAC"}
+{"version":3,"file":"industryEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/industryEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDE,CAAC"}

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

@@ -0,0 +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/killmailEndpoints.d.mts

@@ -0,0 +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/locationEndpoints.d.mts

@@ -0,0 +1,37 @@
+export declare const locationEndpoints: {
+    readonly getCharacterLocation: {
+        readonly path: "characters/{characterId}/location";
+        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