@lgriffin/esi.ts 10.0.0 → 10.2.1

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

@@ -0,0 +1,324 @@
+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";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            item_id: z.ZodNumber;
+            type_id: z.ZodNumber;
+            location_id: z.ZodNumber;
+            location_flag: z.ZodString;
+            quantity: z.ZodNumber;
+            time_efficiency: z.ZodNumber;
+            material_efficiency: z.ZodNumber;
+            runs: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationAlscLogs: {
+        readonly path: "corporations/{corporationId}/containers/logs";
+        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.ZodType<(string & {}) | "config" | "general", unknown, z.core.$ZodTypeInternals<(string & {}) | "config" | "general", unknown>>>;
+            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.ZodOptional<z.ZodNumber>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            wallet: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                division: z.ZodOptional<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";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodObject<{
+            px64x64: z.ZodOptional<z.ZodString>;
+            px128x128: z.ZodOptional<z.ZodString>;
+            px256x256: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly getCorporationMedals: {
+        readonly path: "corporations/{corporationId}/medals";
+        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;
+            created_at: 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;
+            character_id: z.ZodNumber;
+            issued_at: z.ZodString;
+            issuer_id: z.ZodNumber;
+            reason: z.ZodString;
+            status: z.ZodType<(string & {}) | "private" | "public", unknown, z.core.$ZodTypeInternals<(string & {}) | "private" | "public", unknown>>;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationMembers: {
+        readonly path: "corporations/{corporationId}/members";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+    readonly getCorporationMemberLimit: {
+        readonly path: "corporations/{corporationId}/members/limit";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodNumber;
+    };
+    readonly getCorporationMembersTitles: {
+        readonly path: "corporations/{corporationId}/members/titles";
+        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.ZodOptional<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;
+            old_roles: z.ZodArray<z.ZodString>;
+            new_roles: 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.ZodType<(string & {}) | "character" | "corporation", unknown, z.core.$ZodTypeInternals<(string & {}) | "character" | "corporation", unknown>>;
+            share_count: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationStandings: {
+        readonly path: "corporations/{corporationId}/standings";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly responseSchema: z.ZodArray<z.ZodObject<{
+            from_id: z.ZodNumber;
+            from_type: z.ZodType<(string & {}) | "agent" | "npc_corp" | "faction", unknown, z.core.$ZodTypeInternals<(string & {}) | "agent" | "npc_corp" | "faction", unknown>>;
+            standing: z.ZodNumber;
+        }, z.core.$loose>>;
+    };
+    readonly getCorporationStarbases: {
+        readonly path: "corporations/{corporationId}/starbases";
+        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.ZodOptional<z.ZodType<(string & {}) | "offline" | "online" | "onlining" | "reinforced" | "unanchoring", unknown, z.core.$ZodTypeInternals<(string & {}) | "offline" | "online" | "onlining" | "reinforced" | "unanchoring", unknown>>>;
+            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<{
+            fuels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type_id: z.ZodNumber;
+                quantity: z.ZodNumber;
+            }, z.core.$loose>>>;
+            allow_alliance_members: z.ZodBoolean;
+            allow_corporation_members: z.ZodBoolean;
+            anchor: z.ZodString;
+            attack_if_at_war: z.ZodBoolean;
+            attack_if_other_security_status_dropping: z.ZodBoolean;
+            attack_security_status_threshold: z.ZodOptional<z.ZodNumber>;
+            attack_standing_threshold: z.ZodOptional<z.ZodNumber>;
+            fuel_bay_take: z.ZodString;
+            fuel_bay_view: z.ZodString;
+            offline: z.ZodString;
+            online: z.ZodString;
+            unanchor: z.ZodString;
+            use_alliance_standings: 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.ZodType<(string & {}) | "offline" | "online" | "cleanup", unknown, z.core.$ZodTypeInternals<(string & {}) | "offline" | "online" | "cleanup", unknown>>;
+            }, z.core.$loose>>>;
+            fuel_expires: z.ZodOptional<z.ZodString>;
+            name: 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_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.ZodOptional<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";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+};
+//# sourceMappingURL=corporationEndpoints.d.ts.map

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

@@ -0,0 +1,102 @@
+export declare const corporationProjectEndpoints: {
+    readonly getCorporationProjects: {
+        readonly path: "corporations/{corporationId}/projects";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId"];
+        readonly queryParams: {
+            readonly before: "before";
+            readonly after: "after";
+        };
+        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>>;
+            projects: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                state: import("zod").ZodType<(string & {}) | "Unspecified" | "Active" | "Closed" | "Completed" | "Expired" | "Deleted", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "Unspecified" | "Active" | "Closed" | "Completed" | "Expired" | "Deleted", unknown>>;
+                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 getCorporationProject: {
+        readonly path: "corporations/{corporationId}/projects/{projectId}";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId", "projectId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            state: import("zod").ZodType<(string & {}) | "Unspecified" | "Active" | "Closed" | "Completed" | "Expired" | "Deleted", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "Unspecified" | "Active" | "Closed" | "Completed" | "Expired" | "Deleted", unknown>>;
+            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>>;
+            creator: import("zod").ZodObject<{
+                id: import("zod").ZodNumber;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>;
+            details: import("zod").ZodObject<{
+                career: import("zod").ZodType<(string & {}) | "Unspecified" | "Explorer" | "Industrialist" | "Enforcer" | "Soldier of Fortune", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "Unspecified" | "Explorer" | "Industrialist" | "Enforcer" | "Soldier of Fortune", unknown>>;
+                created: import("zod").ZodString;
+                description: import("zod").ZodString;
+                expires: import("zod").ZodOptional<import("zod").ZodString>;
+                finished: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+            configuration: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            contribution: import("zod").ZodOptional<import("zod").ZodObject<{
+                participation_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>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly getCorporationProjectContribution: {
+        readonly path: "corporations/{corporationId}/projects/{projectId}/contribution/{characterId}";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId", "projectId", "characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            contributed: import("zod").ZodNumber;
+            last_modified: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly getCorporationProjectContributors: {
+        readonly path: "corporations/{corporationId}/projects/{projectId}/contributors";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["corporationId", "projectId"];
+        readonly queryParams: {
+            readonly before: "before";
+            readonly after: "after";
+        };
+        readonly responseSchema: import("zod").ZodObject<{
+            contributors: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodNumber;
+                name: import("zod").ZodString;
+                contributed: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>>;
+            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>>;
+        }, import("zod/v4/core").$loose>;
+    };
+};
+//# sourceMappingURL=corporationProjectEndpoints.d.ts.map

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

@@ -0,0 +1,52 @@
+export declare const cosmeticsEndpoints: {
+    readonly getCharacterSkinr: {
+        readonly path: "characters/{characterId}/cosmetics/skinr";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            licenses: import("zod").ZodArray<import("zod").ZodObject<{
+                skinr_id: import("zod").ZodString;
+                activated: import("zod").ZodBoolean;
+                unactivated: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly getCharacterSkinrComponents: {
+        readonly path: "characters/{characterId}/cosmetics/skinr/components";
+        readonly method: "GET";
+        readonly requiresAuth: true;
+        readonly pathParams: readonly ["characterId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            licenses: import("zod").ZodArray<import("zod").ZodObject<{
+                component_id: import("zod").ZodNumber;
+                type: import("zod").ZodType<(string & {}) | "pattern" | "nanocoating", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "pattern" | "nanocoating", unknown>>;
+                runs: import("zod").ZodObject<{
+                    remaining: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    unlimited: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$loose>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly getSkinr: {
+        readonly path: "cosmetics/skinr/{skinrId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["skinrId"];
+        readonly responseSchema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            creator_id: import("zod").ZodNumber;
+            ship_type_id: import("zod").ZodNumber;
+            line: import("zod").ZodOptional<import("zod").ZodString>;
+            tier: import("zod").ZodObject<{
+                level: import("zod").ZodNumber;
+            }, import("zod/v4/core").$loose>;
+            layout: import("zod").ZodObject<{
+                slots: import("zod").ZodArray<import("zod").ZodObject<{}, import("zod/v4/core").$loose>>;
+                pattern_blend_mode: import("zod").ZodType<(string & {}) | "normal" | "subtract" | "exclusion" | "nested" | "nested_inverted", unknown, import("zod/v4/core").$ZodTypeInternals<(string & {}) | "normal" | "subtract" | "exclusion" | "nested" | "nested_inverted", unknown>>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$loose>;
+    };
+};
+//# sourceMappingURL=cosmeticsEndpoints.d.ts.map

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

@@ -0,0 +1,69 @@
+import { ApiClient } from '../ApiClient.mjs';
+import { EndpointMap, EndpointArgs } from './EndpointDefinition.mjs';
+import { CursorTokens } from '../pagination/CursorPaginationHandler.mjs';
+import { EsiResponse, EsiResult } from '../../types/api-responses.mjs';
+import type { z } from 'zod';
+export interface CursorOptions {
+    before?: string;
+    after?: string;
+}
+export interface CursorResult<T = unknown> {
+    data: T[];
+    cursors: CursorTokens;
+}
+export interface CreateClientOptions {
+    returnMetadata?: boolean;
+    safeMode?: boolean;
+}
+/** Extract the element type from an array type, or return T unchanged. */
+export type UnwrapArray<T> = T extends readonly (infer E)[] ? E : T;
+/**
+ * Infer the result type from an endpoint definition's responseSchema.
+ *
+ * - When `cursorPagination: true`, wraps in `CursorResult<ElementType>`.
+ * - When `responseSchema` is present, uses `z.infer` to extract the type.
+ * - Falls back to `unknown` when no `responseSchema` is defined.
+ */
+export type InferEndpointResult<D> = D extends {
+    cursorPagination: true;
+} ? D extends {
+    responseSchema: infer S extends z.ZodType;
+} ? CursorResult<UnwrapArray<z.infer<S>>> : CursorResult : D extends {
+    responseSchema: infer S extends z.ZodType;
+} ? z.infer<S> : unknown;
+type ClientMethods<T extends EndpointMap> = {
+    [K in keyof T]: (...args: EndpointArgs<T[K]>) => Promise<InferEndpointResult<T[K]>>;
+};
+export type WithMetadata<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<EsiResponse<R>> : T[K];
+};
+export type WithSafeMode<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<EsiResult<R>> : T[K];
+};
+export declare function createClient<T extends EndpointMap>(apiClient: ApiClient, endpoints: T, options?: CreateClientOptions): ClientMethods<T>;
+/**
+ * Fetch all pages of a cursor-paginated endpoint.
+ *
+ * ESI returns cursor tokens in the response body. This helper follows
+ * `after` tokens until the dataset is exhausted (empty items array).
+ *
+ * Usage with body-based cursors (ESI's actual format):
+ *   const allJobs = await fetchAllCursorPages(
+ *       (before, after) => client.freelanceJobs.getFreelanceJobs(before, after),
+ *       (response) => response.freelance_jobs,
+ *       (response) => response.cursor,
+ *   );
+ *
+ * Usage with CursorResult shape:
+ *   const all = await fetchAllCursorPages(
+ *       (before, after) => fetcher({ before, after }),
+ *       (r) => r.data,
+ *       (r) => r.cursors,
+ *   );
+ */
+export declare function fetchAllCursorPages<TResponse, TItem = unknown>(fetcher: (before?: string, after?: string) => Promise<TResponse>, getItems: (response: TResponse) => TItem[], getCursor: (response: TResponse) => {
+    before?: string | null;
+    after?: string | null;
+}): Promise<TItem[]>;
+export {};
+//# sourceMappingURL=createClient.d.ts.map

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

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const dogmaEndpoints: {
+    readonly getAttributes: {
+        readonly path: "dogma/attributes";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+    readonly getAttributeById: {
+        readonly path: "dogma/attributes/{attributeId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["attributeId"];
+        readonly responseSchema: z.ZodObject<{
+            attribute_id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            icon_id: z.ZodOptional<z.ZodNumber>;
+            default_value: z.ZodOptional<z.ZodNumber>;
+            published: z.ZodOptional<z.ZodBoolean>;
+            display_name: z.ZodOptional<z.ZodString>;
+            unit_id: z.ZodOptional<z.ZodNumber>;
+            stackable: z.ZodOptional<z.ZodBoolean>;
+            high_is_good: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
+    };
+    readonly getEffects: {
+        readonly path: "dogma/effects";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly responseSchema: z.ZodArray<z.ZodNumber>;
+    };
+    readonly getEffectById: {
+        readonly path: "dogma/effects/{effectId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["effectId"];
+        readonly responseSchema: z.ZodObject<{
+            effect_id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            icon_id: z.ZodOptional<z.ZodNumber>;
+            display_name: z.ZodOptional<z.ZodString>;
+            published: z.ZodOptional<z.ZodBoolean>;
+            effect_category: z.ZodOptional<z.ZodNumber>;
+            is_assistance: z.ZodOptional<z.ZodBoolean>;
+            is_offensive: z.ZodOptional<z.ZodBoolean>;
+            is_warp_safe: z.ZodOptional<z.ZodBoolean>;
+            disallow_auto_repeat: z.ZodOptional<z.ZodBoolean>;
+            discharge_attribute_id: z.ZodOptional<z.ZodNumber>;
+            duration_attribute_id: z.ZodOptional<z.ZodNumber>;
+            electronic_chance: z.ZodOptional<z.ZodBoolean>;
+            falloff_attribute_id: z.ZodOptional<z.ZodNumber>;
+            modifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                domain: z.ZodOptional<z.ZodString>;
+                effect_id: z.ZodOptional<z.ZodNumber>;
+                func: z.ZodString;
+                modified_attribute_id: z.ZodOptional<z.ZodNumber>;
+                modifying_attribute_id: z.ZodOptional<z.ZodNumber>;
+                operator: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>>;
+            post_expression: z.ZodOptional<z.ZodNumber>;
+            pre_expression: z.ZodOptional<z.ZodNumber>;
+            range_attribute_id: z.ZodOptional<z.ZodNumber>;
+            range_chance: z.ZodOptional<z.ZodBoolean>;
+            tracking_speed_attribute_id: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+    };
+    readonly getDynamicItemInfo: {
+        readonly path: "dogma/dynamic/items/{typeId}/{itemId}";
+        readonly method: "GET";
+        readonly requiresAuth: false;
+        readonly pathParams: readonly ["typeId", "itemId"];
+        readonly responseSchema: z.ZodObject<{
+            created_by: z.ZodNumber;
+            dogma_attributes: z.ZodArray<z.ZodObject<{
+                attribute_id: z.ZodNumber;
+                value: z.ZodNumber;
+            }, z.core.$loose>>;
+            dogma_effects: z.ZodArray<z.ZodObject<{
+                effect_id: z.ZodNumber;
+                is_default: z.ZodBoolean;
+            }, z.core.$loose>>;
+            mutator_type_id: z.ZodNumber;
+            source_type_id: z.ZodNumber;
+        }, z.core.$loose>;
+    };
+};
+//# sourceMappingURL=dogmaEndpoints.d.ts.map

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

@@ -1 +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,CA+H/C,CAAC"}
+{"version":3,"file":"esi-cache-ttls.generated.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/esi-cache-ttls.generated.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAyI/C,CAAC"}

package/dist/core/endpoints/esi-rate-limit-groups.generated.d.mts

@@ -0,0 +1,7 @@
+export interface RateLimitGroupSpec {
+    group: string;
+    maxTokens: number;
+    windowSizeMs: number;
+}
+export declare const esiRateLimitGroups: Record<string, RateLimitGroupSpec>;
+//# sourceMappingURL=esi-rate-limit-groups.generated.d.ts.map

package/dist/core/endpoints/esi-rate-limit-groups.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"esi-rate-limit-groups.generated.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/esi-rate-limit-groups.generated.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAmJjE,CAAC"}
+{"version":3,"file":"esi-rate-limit-groups.generated.d.ts","sourceRoot":"","sources":["../../../src/core/endpoints/esi-rate-limit-groups.generated.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CA6JjE,CAAC"}