@lgriffin/esi.ts - EVE Online ESI API Client - v12.3.0
    Preparing search index...

    Class UniverseClient

    The base of the custom domain clients: an endpoint map turned into methods, plus the stream*/fetchAll* page helpers and withMetadata/withSafeMode. Extend it for a custom domain client of your own.

    Hierarchy (View Summary)

    Index
    constructor
    api _client _endpoints
    streamEndpoint fetchAllEndpoint withMetadata withSafeMode getAncestries getAsteroidBeltInfo getBloodlines getConstellationById getConstellations getFactions getGraphicById getGraphics getItemCategories getItemCategoryById getItemGroupById getItemGroups getMoonById getPlanetById getRaces getRegionById getStarById getStargateById getStationById getStructureById getStructures getSystemById getSystemJumps getSystemKills getSystems getTypeById getTypes postBulkNamesToIds postNamesAndCategories getSchematicById getRegions
    api: ClientMethods<T>

    Protected_client

    _client: ApiClient

    Protected_endpoints

    _endpoints: {
        getAncestries: {
            path: "universe/ancestries";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<
                    {
                        id: ZodNumber;
                        name: ZodString;
                        bloodline_id: ZodNumber;
                        description: ZodString;
                        short_description: ZodOptional<ZodString>;
                        icon_id: ZodOptional<ZodNumber>;
                    },
                    $loose,
                >,
            >;
        };
        getAsteroidBeltInfo: {
            path: "universe/asteroid_belts/{asteroidBeltId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["asteroidBeltId"];
            responseSchema: ZodObject<
                {
                    name: ZodString;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                    system_id: ZodNumber;
                },
                $loose,
            >;
        };
        getBloodlines: {
            path: "universe/bloodlines";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<
                    {
                        bloodline_id: ZodNumber;
                        name: ZodString;
                        description: ZodString;
                        race_id: ZodNumber;
                        corporation_id: ZodNumber;
                        ship_type_id: ZodNullable<ZodNumber>;
                        charisma: ZodNumber;
                        intelligence: ZodNumber;
                        memory: ZodNumber;
                        perception: ZodNumber;
                        willpower: ZodNumber;
                    },
                    $loose,
                >,
            >;
        };
        getCategories: {
            path: "universe/categories";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getCategoryById: {
            path: "universe/categories/{categoryId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["categoryId"];
            responseSchema: ZodObject<
                {
                    category_id: ZodNumber;
                    name: ZodString;
                    groups: ZodArray<ZodNumber>;
                    published: ZodBoolean;
                },
                $loose,
            >;
        };
        getConstellations: {
            path: "universe/constellations";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getConstellationById: {
            path: "universe/constellations/{constellationId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["constellationId"];
            responseSchema: ZodObject<
                {
                    constellation_id: ZodNumber;
                    name: ZodString;
                    region_id: ZodNumber;
                    systems: ZodArray<ZodNumber>;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                },
                $loose,
            >;
        };
        getFactions: {
            path: "universe/factions";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<
                    {
                        faction_id: ZodNumber;
                        name: ZodString;
                        description: ZodString;
                        size_factor: ZodNumber;
                        station_count: ZodNumber;
                        station_system_count: ZodNumber;
                        is_unique: ZodBoolean;
                        solar_system_id: ZodOptional<ZodNumber>;
                        corporation_id: ZodOptional<ZodNumber>;
                        militia_corporation_id: ZodOptional<ZodNumber>;
                    },
                    $loose,
                >,
            >;
        };
        getGraphics: {
            path: "universe/graphics";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getGraphicById: {
            path: "universe/graphics/{graphicId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["graphicId"];
            responseSchema: ZodObject<
                {
                    graphic_id: ZodNumber;
                    collision_file: ZodOptional<ZodString>;
                    graphic_file: ZodOptional<ZodString>;
                    icon_folder: ZodOptional<ZodString>;
                    sof_dna: ZodOptional<ZodString>;
                    sof_fation_name: ZodOptional<ZodString>;
                    sof_hull_name: ZodOptional<ZodString>;
                    sof_race_name: ZodOptional<ZodString>;
                },
                $loose,
            >;
        };
        getItemGroups: {
            path: "universe/groups";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getItemGroupById: {
            path: "universe/groups/{groupId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["groupId"];
            responseSchema: ZodObject<
                {
                    group_id: ZodNumber;
                    name: ZodString;
                    category_id: ZodNumber;
                    types: ZodArray<ZodNumber>;
                    published: ZodBoolean;
                },
                $loose,
            >;
        };
        postBulkNamesToIds: {
            path: "universe/ids";
            method: "POST";
            requiresAuth: false;
            bodyBuilder: (names: string[]) => string[];
            responseSchema: ZodObject<
                {
                    agents: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    alliances: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    characters: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    constellations: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    corporations: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    factions: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    inventory_types: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    regions: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    systems: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                    stations: ZodOptional<
                        ZodArray<
                            ZodObject<
                                { id: ZodOptional<ZodNumber>; name: ZodOptional<ZodString> },
                                $loose,
                            >,
                        >,
                    >;
                },
                $loose,
            >;
            requestSchema: ZodArray<ZodString>;
        };
        getMoonById: {
            path: "universe/moons/{moonId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["moonId"];
            responseSchema: ZodObject<
                {
                    moon_id: ZodNumber;
                    name: ZodString;
                    system_id: ZodNumber;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                },
                $loose,
            >;
        };
        postNamesAndCategories: {
            path: "universe/names";
            method: "POST";
            requiresAuth: false;
            bodyBuilder: (ids: number[]) => number[];
            responseSchema: ZodArray<
                ZodObject<
                    {
                        id: ZodNumber;
                        name: ZodString;
                        category: ZodType<
                            | string & {}
                            | "faction"
                            | "character"
                            | "corporation"
                            | "alliance"
                            | "constellation"
                            | "inventory_type"
                            | "region"
                            | "solar_system"
                            | "station",
                            unknown,
                            $ZodTypeInternals<
                                | string & {}
                                | "faction"
                                | "character"
                                | "corporation"
                                | "alliance"
                                | "constellation"
                                | "inventory_type"
                                | "region"
                                | "solar_system"
                                | "station",
                                unknown,
                            >,
                        >;
                    },
                    $loose,
                >,
            >;
            requestSchema: ZodArray<ZodNumber>;
        };
        getPlanetById: {
            path: "universe/planets/{planetId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["planetId"];
            responseSchema: ZodObject<
                {
                    planet_id: ZodNumber;
                    name: ZodString;
                    system_id: ZodNumber;
                    type_id: ZodNumber;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                },
                $loose,
            >;
        };
        getRaces: {
            path: "universe/races";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<
                    {
                        race_id: ZodNumber;
                        name: ZodString;
                        description: ZodString;
                        alliance_id: ZodNumber;
                    },
                    $loose,
                >,
            >;
        };
        getRegions: {
            path: "universe/regions";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getRegionById: {
            path: "universe/regions/{regionId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["regionId"];
            responseSchema: ZodObject<
                {
                    region_id: ZodNumber;
                    name: ZodString;
                    description: ZodOptional<ZodString>;
                    constellations: ZodArray<ZodNumber>;
                },
                $loose,
            >;
        };
        getSchematicById: {
            path: "universe/schematics/{schematicId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["schematicId"];
            responseSchema: ZodObject<
                { schematic_name: ZodString; cycle_time: ZodNumber },
                $loose,
            >;
        };
        getStargateById: {
            path: "universe/stargates/{stargateId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["stargateId"];
            responseSchema: ZodObject<
                {
                    stargate_id: ZodNumber;
                    name: ZodString;
                    system_id: ZodNumber;
                    type_id: ZodNumber;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                    destination: ZodObject<
                        { system_id: ZodNumber; stargate_id: ZodNumber },
                        $loose,
                    >;
                },
                $loose,
            >;
        };
        getStarById: {
            path: "universe/stars/{starId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["starId"];
            responseSchema: ZodObject<
                {
                    star_id: ZodOptional<ZodNumber>;
                    solar_system_id: ZodNumber;
                    name: ZodString;
                    type_id: ZodNumber;
                    age: ZodNumber;
                    luminosity: ZodNumber;
                    radius: ZodNumber;
                    spectral_class: ZodString;
                    temperature: ZodNumber;
                },
                $loose,
            >;
        };
        getStationById: {
            path: "universe/stations/{stationId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["stationId"];
            responseSchema: ZodObject<
                {
                    station_id: ZodNumber;
                    name: ZodString;
                    owner: ZodOptional<ZodNumber>;
                    system_id: ZodNumber;
                    type_id: ZodNumber;
                    race_id: ZodOptional<ZodNumber>;
                    reprocessing_efficiency: ZodNumber;
                    reprocessing_stations_take: ZodNumber;
                    max_dockable_ship_volume: ZodNumber;
                    office_rental_cost: ZodNumber;
                    services: ZodArray<ZodString>;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                },
                $loose,
            >;
        };
        getStructures: {
            path: "universe/structures";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getStructureById: {
            path: "universe/structures/{structureId}";
            method: "GET";
            requiresAuth: true;
            pathParams: readonly ["structureId"];
            responseSchema: ZodObject<
                {
                    structure_id: ZodOptional<ZodNumber>;
                    name: ZodString;
                    owner_id: ZodNumber;
                    solar_system_id: ZodNumber;
                    type_id: ZodOptional<ZodNumber>;
                    position: ZodOptional<
                        ZodObject<{ x: ZodNumber; y: ZodNumber; z: ZodNumber }, $loose>,
                    >;
                },
                $loose,
            >;
        };
        getSystemJumps: {
            path: "universe/system_jumps";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<{ system_id: ZodNumber; ship_jumps: ZodNumber }, $loose>,
            >;
        };
        getSystemKills: {
            path: "universe/system_kills";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<
                ZodObject<
                    {
                        system_id: ZodNumber;
                        npc_kills: ZodNumber;
                        pod_kills: ZodNumber;
                        ship_kills: ZodNumber;
                    },
                    $loose,
                >,
            >;
        };
        getSystems: {
            path: "universe/systems";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getSystemById: {
            path: "universe/systems/{systemId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["systemId"];
            responseSchema: ZodObject<
                {
                    system_id: ZodNumber;
                    name: ZodString;
                    constellation_id: ZodNumber;
                    position: ZodObject<
                        { x: ZodNumber; y: ZodNumber; z: ZodNumber },
                        $loose,
                    >;
                    security_class: ZodOptional<ZodString>;
                    security_status: ZodNumber;
                    star_id: ZodOptional<ZodNumber>;
                    stargates: ZodOptional<ZodArray<ZodNumber>>;
                    stations: ZodOptional<ZodArray<ZodNumber>>;
                    planets: ZodOptional<
                        ZodArray<
                            ZodObject<
                                {
                                    asteroid_belts: ZodOptional<ZodArray<ZodNumber>>;
                                    moons: ZodOptional<ZodArray<ZodNumber>>;
                                    planet_id: ZodNumber;
                                },
                                $loose,
                            >,
                        >,
                    >;
                },
                $loose,
            >;
        };
        getTypes: {
            path: "universe/types";
            method: "GET";
            requiresAuth: false;
            responseSchema: ZodArray<ZodNumber>;
        };
        getTypeById: {
            path: "universe/types/{typeId}";
            method: "GET";
            requiresAuth: false;
            pathParams: readonly ["typeId"];
            responseSchema: ZodObject<
                {
                    type_id: ZodNumber;
                    name: ZodString;
                    description: ZodString;
                    published: ZodBoolean;
                    group_id: ZodNumber;
                    market_group_id: ZodOptional<ZodNumber>;
                    radius: ZodOptional<ZodNumber>;
                    volume: ZodOptional<ZodNumber>;
                    packaged_volume: ZodOptional<ZodNumber>;
                    capacity: ZodOptional<ZodNumber>;
                    portion_size: ZodOptional<ZodNumber>;
                    mass: ZodOptional<ZodNumber>;
                    icon_id: ZodOptional<ZodNumber>;
                    graphic_id: ZodOptional<ZodNumber>;
                    dogma_attributes: ZodOptional<
                        ZodArray<
                            ZodObject<{ attribute_id: ZodNumber; value: ZodNumber }, $loose>,
                        >,
                    >;
                    dogma_effects: ZodOptional<
                        ZodArray<
                            ZodObject<{ effect_id: ZodNumber; is_default: ZodBoolean }, $loose>,
                        >,
                    >;
                },
                $loose,
            >;
        };
    }

    • Type Parameters

      • R

      Parameters

      • endpointName:
            | "getSystems"
            | "getAncestries"
            | "getAsteroidBeltInfo"
            | "getBloodlines"
            | "getCategories"
            | "getCategoryById"
            | "getConstellations"
            | "getConstellationById"
            | "getFactions"
            | "getGraphics"
            | "getGraphicById"
            | "getItemGroups"
            | "getItemGroupById"
            | "postBulkNamesToIds"
            | "getMoonById"
            | "postNamesAndCategories"
            | "getPlanetById"
            | "getRaces"
            | "getRegions"
            | "getRegionById"
            | "getSchematicById"
            | "getStargateById"
            | "getStarById"
            | "getStationById"
            | "getStructures"
            | "getStructureById"
            | "getSystemJumps"
            | "getSystemKills"
            | "getSystemById"
            | "getTypes"
            | "getTypeById"
      • ...args: unknown[]

      Returns AsyncGenerator<PageResult<R>, void, undefined>

    • Type Parameters

      • R

      Parameters

      • endpointName:
            | "getSystems"
            | "getAncestries"
            | "getAsteroidBeltInfo"
            | "getBloodlines"
            | "getCategories"
            | "getCategoryById"
            | "getConstellations"
            | "getConstellationById"
            | "getFactions"
            | "getGraphics"
            | "getGraphicById"
            | "getItemGroups"
            | "getItemGroupById"
            | "postBulkNamesToIds"
            | "getMoonById"
            | "postNamesAndCategories"
            | "getPlanetById"
            | "getRaces"
            | "getRegions"
            | "getRegionById"
            | "getSchematicById"
            | "getStargateById"
            | "getStarById"
            | "getStationById"
            | "getStructures"
            | "getStructureById"
            | "getSystemJumps"
            | "getSystemKills"
            | "getSystemById"
            | "getTypes"
            | "getTypeById"
      • args: unknown[]
      • Optionalconcurrency: number

      Returns Promise<R[]>

    • Retrieves all available character ancestries for character creation.

      Returns Promise<
          {
              id: number;
              name: string;
              bloodline_id: number;
              description: string;
              short_description?: string;
              icon_id?: number;
              [key: string]: unknown;
          }[],
      >

      A list of character ancestries

    • Retrieves information about an asteroid belt, including its position in space.

      Parameters

      • asteroidBeltId: number

        The ID of the asteroid belt

      Returns Promise<
          {
              name: string;
              position: { x: number; y: number; z: number; [key: string]: unknown };
              system_id: number;
              [key: string]: unknown;
          },
      >

      Details about the asteroid belt

    • Retrieves all available character bloodlines for character creation.

      Returns Promise<
          {
              bloodline_id: number;
              name: string;
              description: string;
              race_id: number;
              corporation_id: number;
              ship_type_id: number
              | null;
              charisma: number;
              intelligence: number;
              memory: number;
              perception: number;
              willpower: number;
              [key: string]: unknown;
          }[],
      >

      A list of character bloodlines

    • Retrieves information about a constellation, including its systems and position.

      Parameters

      • constellationId: number

        The ID of the constellation

      Returns Promise<
          {
              constellation_id: number;
              name: string;
              region_id: number;
              systems: number[];
              position: { x: number; y: number; z: number; [key: string]: unknown };
              [key: string]: unknown;
          },
      >

      Detailed constellation information

    • Retrieves a list of all constellation IDs in the EVE universe.

      Returns Promise<number[]>

      A list of constellation IDs

    • Retrieves all NPC factions in the EVE universe.

      Returns Promise<
          {
              faction_id: number;
              name: string;
              description: string;
              size_factor: number;
              station_count: number;
              station_system_count: number;
              is_unique: boolean;
              solar_system_id?: number;
              corporation_id?: number;
              militia_corporation_id?: number;
              [key: string]: unknown;
          }[],
      >

      A list of NPC factions

    • Retrieves information about a specific graphic asset used in the EVE client.

      Parameters

      • graphicId: number

        The ID of the graphic

      Returns Promise<
          {
              graphic_id: number;
              collision_file?: string;
              graphic_file?: string;
              icon_folder?: string;
              sof_dna?: string;
              sof_fation_name?: string;
              sof_hull_name?: string;
              sof_race_name?: string;
              [key: string]: unknown;
          },
      >

      Detailed graphic information

    • Retrieves a list of all graphic asset IDs.

      Returns Promise<number[]>

      A list of graphic IDs

    • Retrieves a list of all item category IDs in the EVE universe.

      Returns Promise<number[]>

      A list of item category IDs

    • Retrieves information about a specific item category, including its groups.

      Parameters

      • categoryId: number

        The ID of the item category

      Returns Promise<
          {
              category_id: number;
              name: string;
              groups: number[];
              published: boolean;
              [key: string]: unknown;
          },
      >

      Detailed item category information

    • Retrieves information about a specific item group, including its types.

      Parameters

      • groupId: number

        The ID of the item group

      Returns Promise<
          {
              group_id: number;
              name: string;
              category_id: number;
              types: number[];
              published: boolean;
              [key: string]: unknown;
          },
      >

      Detailed item group information

    • Retrieves a list of all item group IDs in the EVE universe.

      Returns Promise<number[]>

      A list of item group IDs

    • Retrieves information about a moon, including its name and position.

      Parameters

      • moonId: number

        The ID of the moon

      Returns Promise<
          {
              moon_id: number;
              name: string;
              system_id: number;
              position: { x: number; y: number; z: number; [key: string]: unknown };
              [key: string]: unknown;
          },
      >

      Detailed moon information

    • Retrieves information about a planet, including its name, type, and position.

      Parameters

      • planetId: number

        The ID of the planet

      Returns Promise<
          {
              planet_id: number;
              name: string;
              system_id: number;
              type_id: number;
              position: { x: number; y: number; z: number; [key: string]: unknown };
              [key: string]: unknown;
          },
      >

      Detailed planet information

    • Retrieves all playable races in the EVE universe.

      Returns Promise<
          {
              race_id: number;
              name: string;
              description: string;
              alliance_id: number;
              [key: string]: unknown;
          }[],
      >

      A list of playable races

    • Retrieves information about a region, including its constellations and name.

      Parameters

      • regionId: number

        The ID of the region

      Returns Promise<
          {
              region_id: number;
              name: string;
              description?: string;
              constellations: number[];
              [key: string]: unknown;
          },
      >

      Detailed region information

    • Retrieves information about a star, including its spectral class and luminosity.

      Parameters

      • starId: number

        The ID of the star

      Returns Promise<
          {
              star_id?: number;
              solar_system_id: number;
              name: string;
              type_id: number;
              age: number;
              luminosity: number;
              radius: number;
              spectral_class: string;
              temperature: number;
              [key: string]: unknown;
          },
      >

      Detailed star information

    • Retrieves information about a stargate, including its destination and position.

      Parameters

      • stargateId: number

        The ID of the stargate

      Returns Promise<
          {
              stargate_id: number;
              name: string;
              system_id: number;
              type_id: number;
              position: { x: number; y: number; z: number; [key: string]: unknown };
              destination: {
                  system_id: number;
                  stargate_id: number;
                  [key: string]: unknown;
              };
              [key: string]: unknown;
          },
      >

      Detailed stargate information

    • Retrieves public information about a station, including its services and location.

      Parameters

      • stationId: number

        The ID of the station

      Returns Promise<
          {
              station_id: number;
              name: string;
              owner?: number;
              system_id: number;
              type_id: number;
              race_id?: number;
              reprocessing_efficiency: number;
              reprocessing_stations_take: number;
              max_dockable_ship_volume: number;
              office_rental_cost: number;
              services: string[];
              position: { x: number; y: number; z: number; [key: string]: unknown };
              [key: string]: unknown;
          },
      >

      Detailed station information

    • Retrieves information about a player-owned structure by its ID.

      Parameters

      • structureId: number

        The ID of the structure

      Returns Promise<
          {
              structure_id?: number;
              name: string;
              owner_id: number;
              solar_system_id: number;
              type_id?: number;
              position?: { x: number; y: number; z: number; [key: string]: unknown };
              [key: string]: unknown;
          },
      >

      Detailed structure information

      Authentication

    • Retrieves a list of all publicly visible player-owned structure IDs.

      Returns Promise<number[]>

      A list of structure IDs

    • Retrieves information about a solar system, including its planets, stargates, and security status.

      Parameters

      • systemId: number

        The ID of the solar system

      Returns Promise<
          {
              system_id: number;
              name: string;
              constellation_id: number;
              position: { x: number; y: number; z: number; [key: string]: unknown };
              security_class?: string;
              security_status: number;
              star_id?: number;
              stargates?: number[];
              stations?: number[];
              planets?: {
                  asteroid_belts?: number[];
                  moons?: number[];
                  planet_id: number;
                  [key: string]: unknown;
              }[];
              [key: string]: unknown;
          },
      >

      Detailed solar system information

    • Retrieves the number of ship jumps per solar system within the last hour.

      Returns Promise<{ system_id: number; ship_jumps: number; [key: string]: unknown }[]>

      A list of solar systems with their jump counts

    • Retrieves the number of NPC and player ship kills per solar system within the last hour.

      Returns Promise<
          {
              system_id: number;
              npc_kills: number;
              pod_kills: number;
              ship_kills: number;
              [key: string]: unknown;
          }[],
      >

      A list of solar systems with their kill counts

    • Retrieves a list of all solar system IDs in the EVE universe.

      Returns Promise<number[]>

      A list of solar system IDs

    • Retrieves information about a specific item type, including its description and attributes.

      Parameters

      • typeId: number

        The ID of the item type

      Returns Promise<
          {
              type_id: number;
              name: string;
              description: string;
              published: boolean;
              group_id: number;
              market_group_id?: number;
              radius?: number;
              volume?: number;
              packaged_volume?: number;
              capacity?: number;
              portion_size?: number;
              mass?: number;
              icon_id?: number;
              graphic_id?: number;
              dogma_attributes?: {
                  attribute_id: number;
                  value: number;
                  [key: string]: unknown;
              }[];
              dogma_effects?: {
                  effect_id: number;
                  is_default: boolean;
                  [key: string]: unknown;
              }[];
              [key: string]: unknown;
          },
      >

      Detailed item type information

    • Retrieves a list of all item type IDs in the EVE universe.

      Returns Promise<number[]>

      A list of item type IDs

    • Resolves a list of names to their corresponding IDs via a bulk POST operation.

      Parameters

      • names: string[]

        An array of names to resolve to IDs

      Returns Promise<
          {
              agents?: { id?: number; name?: string; [key: string]: unknown }[];
              alliances?: { id?: number; name?: string; [key: string]: unknown }[];
              characters?: { id?: number; name?: string; [key: string]: unknown }[];
              constellations?: { id?: number; name?: string; [key: string]: unknown }[];
              corporations?: { id?: number; name?: string; [key: string]: unknown }[];
              factions?: { id?: number; name?: string; [key: string]: unknown }[];
              inventory_types?: { id?: number; name?: string; [key: string]: unknown }[];
              regions?: { id?: number; name?: string; [key: string]: unknown }[];
              systems?: { id?: number; name?: string; [key: string]: unknown }[];
              stations?: { id?: number; name?: string; [key: string]: unknown }[];
              [key: string]: unknown;
          },
      >

      The resolved IDs grouped by entity category

    • Resolves a list of IDs to their names and categories via a bulk POST operation.

      Parameters

      • ids: number[]

        An array of entity IDs to resolve

      Returns Promise<
          {
              id: number;
              name: string;
              category: | string & {}
              | "faction"
              | "character"
              | "corporation"
              | "alliance"
              | "constellation"
              | "inventory_type"
              | "region"
              | "solar_system"
              | "station";
              [key: string]: unknown;
          }[],
      >

      A list of names with their corresponding categories

    • Retrieves information about a planetary interaction schematic.

      Parameters

      • schematicId: number

        The ID of the PI schematic

      Returns Promise<{ schematic_name: string; cycle_time: number; [key: string]: unknown }>

      Detailed schematic information including inputs and outputs

    • Retrieves a list of all region IDs in the EVE universe.

      Returns Promise<number[]>

      A list of region IDs

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods