@lgriffin/esi.ts 9.7.0 → 10.2.0

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const loyaltyEndpoints: {
+    readonly getLoyaltyPoints: {
+        readonly path: "characters/{characterId}/loyalty/points";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            corporation_id: z.ZodNumber;
+            loyalty_points: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getLoyaltyStoreOffers: {
+        readonly path: "loyalty/stores/{corporationId}/offers";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            offer_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            quantity: z.ZodNumber;
+            lp_cost: z.ZodNumber;
+            isk_cost: z.ZodNumber;
+            ak_cost: z.ZodOptional<z.ZodNumber>;
+            required_items: z.ZodArray<z.ZodObject<{
+                type_id: z.ZodNumber;
+                quantity: z.ZodNumber;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    };
+};
+//# sourceMappingURL=loyaltyEndpoints.d.ts.map

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

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export declare const mailEndpoints: {
+    readonly getCharacterMailHeaders: {
+        readonly path: "characters/{characterId}/mail/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            mail_id: z.ZodOptional<z.ZodNumber>;
+            subject: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            is_read: z.ZodOptional<z.ZodBoolean>;
+            recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                recipient_id: z.ZodNumber;
+                recipient_type: z.ZodType<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown, z.core.$ZodTypeInternals<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+    };
+    readonly sendMail: {
+        readonly path: "characters/{characterId}/mail/";
+        readonly method: "POST";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly hasBody: true;
+        readonly requestSchema: z.ZodObject<{
+            recipients: z.ZodArray<z.ZodObject<{
+                recipient_id: z.ZodNumber;
+                recipient_type: z.ZodEnum<{
+                    character: "character";
+                    corporation: "corporation";
+                    alliance: "alliance";
+                    mailing_list: "mailing_list";
+                }>;
+            }, z.core.$loose>>;
+            subject: z.ZodString;
+            body: z.ZodString;
+        }, z.core.$loose>;
+    };
+    readonly getMail: {
+        readonly path: "characters/{characterId}/mail/{mailId}/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "mailId"];
+        readonly responseSchema: z.ZodObject<{
+            subject: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            read: z.ZodOptional<z.ZodBoolean>;
+            body: z.ZodOptional<z.ZodString>;
+            recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                recipient_id: z.ZodNumber;
+                recipient_type: z.ZodType<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown, z.core.$ZodTypeInternals<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>;
+    };
+    readonly deleteMail: {
+        readonly path: "characters/{characterId}/mail/{mailId}/";
+        readonly method: "DELETE";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "mailId"];
+    };
+    readonly updateMailMetadata: {
+        readonly path: "characters/{characterId}/mail/{mailId}/";
+        readonly method: "PUT";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "mailId"];
+        readonly hasBody: true;
+    };
+    readonly getMailLabels: {
+        readonly path: "characters/{characterId}/mail/labels/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodObject<{
+            labels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label_id: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                unread_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>>;
+            total_unread_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+    };
+    readonly createMailLabel: {
+        readonly path: "characters/{characterId}/mail/labels/";
+        readonly method: "POST";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly hasBody: true;
+    };
+    readonly deleteMailLabel: {
+        readonly path: "characters/{characterId}/mail/labels/{labelId}/";
+        readonly method: "DELETE";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "labelId"];
+    };
+    readonly getMailingLists: {
+        readonly path: "characters/{characterId}/mail/lists/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            mailing_list_id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$loose>>;
+    };
+};
+//# sourceMappingURL=mailEndpoints.d.ts.map

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

@@ -12,7 +12,6 @@ export declare const mailEndpoints: {
             timestamp: z.ZodOptional<z.ZodString>;
             labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             is_read: z.ZodOptional<z.ZodBoolean>;
-            body: z.ZodOptional<z.ZodString>;
             recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 recipient_id: z.ZodNumber;
                 recipient_type: z.ZodType<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown, z.core.$ZodTypeInternals<(string & {}) | "character" | "corporation" | "alliance" | "mailing_list", unknown>>;
@@ -45,12 +44,11 @@ export declare const mailEndpoints: {
         readonly requiresAuth: true;
         readonly pathParams: readonly ["characterId", "mailId"];
         readonly responseSchema: z.ZodObject<{
-            mail_id: z.ZodOptional<z.ZodNumber>;
             subject: z.ZodOptional<z.ZodString>;
             from: z.ZodOptional<z.ZodNumber>;
             timestamp: z.ZodOptional<z.ZodString>;
             labels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-            is_read: z.ZodOptional<z.ZodBoolean>;
+            read: z.ZodOptional<z.ZodBoolean>;
             body: z.ZodOptional<z.ZodString>;
             recipients: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 recipient_id: z.ZodNumber;
@@ -78,8 +76,8 @@ export declare const mailEndpoints: {
         readonly pathParams: readonly ["characterId"];
         readonly responseSchema: z.ZodObject<{
             labels: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                label_id: z.ZodNumber;
-                name: z.ZodString;
+                label_id: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodOptional<z.ZodString>;
                 color: z.ZodOptional<z.ZodString>;
                 unread_count: z.ZodOptional<z.ZodNumber>;
             }, z.core.$loose>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"mailEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mailEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EM,CAAC"}
+{"version":3,"file":"mailEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/mailEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EM,CAAC"}

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

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+export declare const marketEndpoints: {
+    readonly getCharacterOrders: {
+        readonly path: "characters/{characterId}/orders/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodOptional<z.ZodBoolean>;
+            is_corporation: z.ZodBoolean;
+            region_id: z.ZodNumber;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            escrow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getCharacterOrderHistory: {
+        readonly path: "characters/{characterId}/orders/history/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodOptional<z.ZodBoolean>;
+            is_corporation: z.ZodBoolean;
+            region_id: z.ZodNumber;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodType<(string & {}) | "cancelled" | "expired", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "expired", unknown>>;
+            escrow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationOrders: {
+        readonly path: "corporations/{corporationId}/orders/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodOptional<z.ZodBoolean>;
+            issued_by: z.ZodNumber;
+            region_id: z.ZodNumber;
+            wallet_division: z.ZodNumber;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            escrow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationOrderHistory: {
+        readonly path: "corporations/{corporationId}/orders/history/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodOptional<z.ZodNumber>;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodOptional<z.ZodBoolean>;
+            issued_by: z.ZodOptional<z.ZodNumber>;
+            region_id: z.ZodNumber;
+            wallet_division: z.ZodNumber;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+            state: z.ZodType<(string & {}) | "cancelled" | "expired", unknown, z.core.$ZodTypeInternals<(string & {}) | "cancelled" | "expired", unknown>>;
+            escrow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getMarketGroups: {
+        readonly path: "markets/groups/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+    readonly getMarketGroupInformation: {
+        readonly path: "markets/groups/{marketGroupId}/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["marketGroupId"];
+        readonly responseSchema: z.ZodObject<{
+            market_group_id: z.ZodNumber;
+            name: z.ZodString;
+            description: z.ZodString;
+            types: z.ZodArray<z.ZodNumber>;
+            parent_group_id: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+    };
+    readonly getMarketPrices: {
+        readonly path: "markets/prices/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            type_id: z.ZodNumber;
+            average_price: z.ZodOptional<z.ZodNumber>;
+            adjusted_price: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getMarketOrdersInStructure: {
+        readonly path: "markets/structures/{structureId}/";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["structureId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+        }, z.core.$loose>>;
+    };
+    readonly getMarketHistory: {
+        readonly path: "markets/{regionId}/history/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["regionId"];
+        readonly queryParams: {
+            readonly typeId: "type_id";
+        };
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            date: z.ZodString;
+            order_count: z.ZodNumber;
+            volume: z.ZodNumber;
+            highest: z.ZodNumber;
+            average: z.ZodNumber;
+            lowest: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getMarketOrders: {
+        readonly path: "markets/{regionId}/orders/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["regionId"];
+        readonly queryParams: {
+            readonly orderType: "order_type";
+        };
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            order_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            volume_total: z.ZodNumber;
+            volume_remain: z.ZodNumber;
+            min_volume: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy_order: z.ZodBoolean;
+            system_id: z.ZodNumber;
+            duration: z.ZodNumber;
+            issued: z.ZodString;
+            range: z.ZodString;
+        }, z.core.$loose>>;
+    };
+    readonly getMarketTypes: {
+        readonly path: "markets/{regionId}/types/";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["regionId"];
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+};
+//# sourceMappingURL=marketEndpoints.d.ts.map

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+export declare const mercenaryEndpoints: {
+    readonly getMercenaryDens: {
+        readonly path: "characters/{characterId}/structures/mercenary-dens";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            den_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            constellation_id: z.ZodNumber;
+            region_id: z.ZodNumber;
+            development_level: z.ZodOptional<z.ZodNumber>;
+            anarchy_level: z.ZodOptional<z.ZodNumber>;
+            active_operations: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+    readonly getMercenaryTacticalOperations: {
+        readonly path: "characters/{characterId}/mercenary-tactical-operations";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            operation_id: z.ZodNumber;
+            den_id: z.ZodNumber;
+            system_id: z.ZodNumber;
+            site_type: z.ZodString;
+            status: z.ZodType<(string & {}) | "expired" | "active" | "spawning" | "completed", unknown, z.core.$ZodTypeInternals<(string & {}) | "expired" | "active" | "spawning" | "completed", unknown>>;
+            started_at: z.ZodOptional<z.ZodString>;
+            expires_at: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    };
+    readonly getMercenaryDenDetail: {
+        readonly path: "characters/{characterId}/structures/mercenary-dens/{mercenaryDenId}";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "mercenaryDenId"];
+        readonly responseSchema: z.ZodObject<{
+            id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            state: z.ZodType<(string & {}) | "Unspecified" | "Running" | "Paused" | "Disabled", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unspecified" | "Running" | "Paused" | "Disabled", unknown>>;
+            skyhook: z.ZodObject<{
+                id: z.ZodNumber;
+                planet_id: z.ZodNumber;
+                corporation_id: z.ZodNumber;
+            }, z.core.$loose>;
+            infomorphs: z.ZodObject<{
+                amount: z.ZodNumber;
+            }, z.core.$loose>;
+            evolution: z.ZodObject<{
+                development: z.ZodObject<{
+                    level: z.ZodOptional<z.ZodNumber>;
+                    progress: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>;
+                anarchy: z.ZodObject<{
+                    level: z.ZodOptional<z.ZodNumber>;
+                    progress: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            reinforcement_timer: z.ZodOptional<z.ZodObject<{
+                end: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    };
+    readonly getMercenaryTacticalOperationDetail: {
+        readonly path: "characters/{characterId}/mercenary-tactical-operations/{operationId}";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "operationId"];
+        readonly responseSchema: z.ZodObject<{
+            id: z.ZodString;
+            mercenary_den_id: z.ZodNumber;
+            state: z.ZodType<(string & {}) | "Unspecified" | "Completed" | "Expired" | "Available" | "Started" | "Removed", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unspecified" | "Completed" | "Expired" | "Available" | "Started" | "Removed", unknown>>;
+            dungeon_type_id: z.ZodNumber;
+            expires: z.ZodString;
+        }, z.core.$loose>;
+    };
+};
+//# sourceMappingURL=mercenaryEndpoints.d.ts.map

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

@@ -70,7 +70,7 @@ export declare const mercenaryEndpoints: {
         readonly responseSchema: z.ZodObject<{
             id: z.ZodString;
             mercenary_den_id: z.ZodNumber;
-            state: z.ZodType<(string & {}) | "Unspecified" | "Available" | "Started" | "Completed" | "Expired" | "Removed", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unspecified" | "Available" | "Started" | "Completed" | "Expired" | "Removed", unknown>>;
+            state: z.ZodType<(string & {}) | "Unspecified" | "Completed" | "Expired" | "Available" | "Started" | "Removed", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unspecified" | "Completed" | "Expired" | "Available" | "Started" | "Removed", unknown>>;
             dungeon_type_id: z.ZodNumber;
             expires: z.ZodString;
         }, z.core.$loose>;

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const metaEndpoints: {
+    readonly getOpenApiJson: {
+        readonly path: "meta/openapi.json";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly getChangelog: {
+        readonly path: "meta/changelog";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            method: z.ZodString;
+            path: z.ZodString;
+            compatibility_date: z.ZodString;
+            is_breaking: z.ZodBoolean;
+            description: z.ZodString;
+        }, z.core.$loose>>>;
+    };
+    readonly getCompatibilityDates: {
+        readonly path: "meta/compatibility-dates";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodObject<{
+            compatibility_dates: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly getName: {
+        readonly path: "meta/name";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$loose>;
+    };
+    readonly getStatus: {
+        readonly path: "meta/status";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodObject<{
+            routes: z.ZodArray<z.ZodObject<{
+                method: z.ZodType<(string & {}) | "GET" | "POST" | "PUT" | "DELETE", unknown, z.core.$ZodTypeInternals<(string & {}) | "GET" | "POST" | "PUT" | "DELETE", unknown>>;
+                path: z.ZodString;
+                status: z.ZodType<(string & {}) | "Unknown" | "OK" | "Degraded" | "Down" | "Recovering", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unknown" | "OK" | "Degraded" | "Down" | "Recovering", unknown>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    };
+};
+//# sourceMappingURL=metaEndpoints.d.ts.map

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

@@ -39,7 +39,11 @@ export declare const metaEndpoints: {
         readonly method: "GET";
         readonly requiresAuth: false;
         readonly responseSchema: z.ZodObject<{
-            status: z.ZodString;
+            routes: z.ZodArray<z.ZodObject<{
+                method: z.ZodType<(string & {}) | "GET" | "POST" | "PUT" | "DELETE", unknown, z.core.$ZodTypeInternals<(string & {}) | "GET" | "POST" | "PUT" | "DELETE", unknown>>;
+                path: z.ZodString;
+                status: z.ZodType<(string & {}) | "Unknown" | "OK" | "Degraded" | "Down" | "Recovering", unknown, z.core.$ZodTypeInternals<(string & {}) | "Unknown" | "OK" | "Degraded" | "Down" | "Recovering", unknown>>;
+            }, z.core.$loose>>;
         }, z.core.$loose>;
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"metaEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/metaEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BM,CAAC"}
+{"version":3,"file":"metaEndpoints.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/metaEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BM,CAAC"}

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

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export declare const militaryCampaignEndpoints: {
+    readonly getMilitaryCampaigns: {
+        readonly path: "military-campaigns";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            campaign_id: z.ZodString;
+            state: z.ZodString;
+            progress: z.ZodNumber;
+            start_time: z.ZodString;
+            finish_time: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    };
+    readonly getMilitaryCampaign: {
+        readonly path: "military-campaigns/{campaignId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["campaignId"];
+        readonly responseSchema: z.ZodObject<{
+            campaign_id: z.ZodString;
+            state: z.ZodString;
+            progress: z.ZodNumber;
+            start_time: z.ZodString;
+            finish_time: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly getMilitaryCampaignObjectives: {
+        readonly path: "military-campaigns/{campaignId}/objectives";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["campaignId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            objective_id: z.ZodString;
+            campaign_id: z.ZodString;
+            state: z.ZodString;
+            progress: z.ZodNumber;
+            participants: z.ZodObject<{
+                total: z.ZodNumber;
+                committed: z.ZodNumber;
+                contributors: z.ZodNumber;
+            }, z.core.$loose>;
+        }, z.core.$loose>>;
+    };
+    readonly getMilitaryCampaignObjective: {
+        readonly path: "military-campaigns/{campaignId}/objectives/{objectiveId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["campaignId", "objectiveId"];
+        readonly responseSchema: z.ZodObject<{
+            objective_id: z.ZodString;
+            campaign_id: z.ZodString;
+            state: z.ZodString;
+            progress: z.ZodNumber;
+            participants: z.ZodObject<{
+                total: z.ZodNumber;
+                committed: z.ZodNumber;
+                contributors: z.ZodNumber;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
+    };
+    readonly getCharacterMilitaryCampaignObjectives: {
+        readonly path: "characters/{characterId}/military-campaigns/objectives";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            objective_id: z.ZodString;
+            campaign_id: z.ZodString;
+            committed: z.ZodBoolean;
+            contribution: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getCharacterMilitaryCampaignObjective: {
+        readonly path: "characters/{characterId}/military-campaigns/objectives/{objectiveId}";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId", "objectiveId"];
+        readonly responseSchema: z.ZodObject<{
+            objective_id: z.ZodString;
+            campaign_id: z.ZodString;
+            committed: z.ZodBoolean;
+            contribution: z.ZodNumber;
+        }, z.core.$loose>;
+    };
+};
+//# sourceMappingURL=militaryCampaignEndpoints.d.ts.map