Interface PublicScopeTree

interface PublicScopeTree {
    alliance: (
        allianceId: number,
    ) => {
        get(): Promise<AlliancesDetail>;
        corporations: { get(): Promise<AlliancesAllianceIdCorporationsGet> };
        icons: { get(): Promise<AlliancesAllianceIdIconsGet> };
    };
    alliances: { get(): Promise<AlliancesGet> };
    character: (
        characterId: number,
    ) => {
        get(): Promise<CharactersDetail>;
        corporationhistory: {
            get(): Promise<CharactersCharacterIdCorporationhistoryGet>;
        };
        portrait: { get(): Promise<CharactersCharacterIdPortraitGet> };
    };
    characters: {
        affiliation: {
            post(
                body: PostCharactersAffiliationBody,
            ): Promise<CharactersAffiliationPost>;
        };
    };
    contracts: {
        public: {
            bids: (
                contractId: number,
            ) => {
                get(): AsyncIterable<
                    { amount: number; bid_id: number; date_bid: string },
                >;
            };
            items: (
                contractId: number,
            ) => {
                get(): AsyncIterable<
                    {
                        is_blueprint_copy?: boolean;
                        is_included: boolean;
                        item_id?: number;
                        material_efficiency?: number;
                        quantity: number;
                        record_id: number;
                        runs?: number;
                        time_efficiency?: number;
                        type_id: number;
                    },
                >;
            };
            (
                regionId: number,
            ): {
                get(): AsyncIterable<
                    {
                        buyout?: number;
                        collateral?: number;
                        contract_id: number;
                        date_expired: string;
                        date_issued: string;
                        days_to_complete?: number;
                        end_location_id?: number;
                        for_corporation?: boolean;
                        issuer_corporation_id: number;
                        issuer_id: number;
                        price?: number;
                        reward?: number;
                        start_location_id?: number;
                        title?: string;
                        type: "unknown"
                        | "item_exchange"
                        | "auction"
                        | "courier"
                        | "loan";
                        volume?: number;
                    },
                >;
            };
        };
    };
    corporation: (
        corporationId: number,
    ) => {
        get(): Promise<CorporationsDetail>;
        alliancehistory: {
            get(): Promise<CorporationsCorporationIdAlliancehistoryGet>;
        };
        icons: { get(): Promise<CorporationsCorporationIdIconsGet> };
    };
    corporations: { npccorps: { get(): Promise<CorporationsNpccorpsGet> } };
    cosmetics: {
        skinr: (skinrId: string) => { get(): Promise<CosmeticsSkinr> };
    };
    dogma: {
        attributes: {
            get(): Promise<DogmaAttributesGet>;
            (attributeId: number): { get(): Promise<DogmaAttributesAttributeIdGet> };
        };
        dynamic: {
            items: (
                typeId: number,
                itemId: number,
            ) => { get(): Promise<DogmaDynamicItemsTypeIdItemIdGet> };
        };
        effects: {
            get(): Promise<DogmaEffectsGet>;
            (effectId: number): { get(): Promise<DogmaEffectsEffectIdGet> };
        };
    };
    freelanceJob: (jobId: string) => { get(): Promise<FreelanceJobsDetail> };
    freelanceJobs: {
        get(
            params?: GetFreelanceJobsListingParams,
        ): Promise<FreelanceJobsListing>;
    };
    fw: {
        leaderboards: {
            get(): Promise<FwLeaderboardsGet>;
            characters: { get(): Promise<FwLeaderboardsCharactersGet> };
            corporations: { get(): Promise<FwLeaderboardsCorporationsGet> };
        };
        stats: { get(): Promise<FwStatsGet> };
        systems: { get(): Promise<FwSystemsGet> };
        wars: { get(): Promise<FwWarsGet> };
    };
    incursions: { get(): Promise<IncursionsGet> };
    industry: {
        facilities: { get(): Promise<IndustryFacilitiesGet> };
        systems: { get(): Promise<IndustrySystemsGet> };
    };
    insurance: { prices: { get(): Promise<InsurancePricesGet> } };
    killmail: (
        killmailId: number,
        killmailHash: string,
    ) => { get(): Promise<KillmailsKillmailIdKillmailHashGet> };
    loyalty: {
        stores: (
            corporationId: number,
        ) => { offers: { get(): Promise<LoyaltyStoresCorporationIdOffersGet> } };
    };
    market: (
        regionId: number,
    ) => {
        history: {
            get(
                params: Omit<GetMarketsRegionIdHistoryParams, "region_id">,
            ): Promise<MarketsRegionIdHistoryGet>;
        };
        orders: {
            get(
                params: Omit<GetMarketsRegionIdOrdersParams, "region_id">,
            ): AsyncIterable<
                {
                    duration: number;
                    is_buy_order: boolean;
                    issued: string;
                    location_id: number;
                    min_volume: number;
                    order_id: number;
                    price: number;
                    range: | "1"
                    | "2"
                    | "3"
                    | "4"
                    | "5"
                    | "region"
                    | "station"
                    | "10"
                    | "20"
                    | "30"
                    | "40"
                    | "solarsystem";
                    system_id: number;
                    type_id: number;
                    volume_remain: number;
                    volume_total: number;
                },
            >;
        };
        types: { get(): AsyncIterable<number> };
    };
    markets: {
        groups: {
            get(): Promise<MarketsGroupsGet>;
            (
                marketGroupId: number,
            ): { get(): Promise<MarketsGroupsMarketGroupIdGet> };
        };
        prices: { get(): Promise<MarketsPricesGet> };
    };
    meta: {
        changelog: { get(): Promise<MetaChangelog> };
        compatibilityDates: { get(): Promise<MetaCompatibilityDates> };
        name: { get(): Promise<MetaName> };
        openapiJson: { get(): Promise<Readonly<Record<string, unknown>>> };
        openapiYaml: { get(): Promise<string> };
        status: { get(): Promise<MetaStatus> };
    };
    militaryCampaign: (
        campaignId: string,
    ) => {
        get(): Promise<MilitaryCampaignsDetail>;
        objectives: {
            get(
                params?: Omit<
                    GetMilitaryCampaignsObjectivesListingParams,
                    "campaign_id",
                >,
            ): Promise<MilitaryCampaignsObjectivesListing>;
            (
                objectiveId: string,
            ): { get(): Promise<MilitaryCampaignsObjectivesDetail> };
        };
    };
    militaryCampaigns: { get(): Promise<MilitaryCampaignsListing> };
    paragonHub: {
        skinr: {
            get(params?: GetParagonHubSkinrParams): Promise<ParagonHubSkinr>;
        };
    };
    route: (
        originSystemId: number,
        destinationSystemId: number,
    ) => { post(body: RouteRequestBody): Promise<Route> };
    skyhooks: { raidable: { get(): Promise<SkyhooksRaidable> } };
    sovereignty: {
        campaigns: { get(): Promise<SovereigntyCampaignsGet> };
        systems: { get(): Promise<SovereigntySystems> };
    };
    status: { get(): Promise<Status> };
    universe: {
        ancestries: { get(): Promise<UniverseAncestriesGet> };
        asteroidBelts: (
            asteroidBeltId: number,
        ) => { get(): Promise<UniverseAsteroidBeltsAsteroidBeltIdGet> };
        bloodlines: { get(): Promise<UniverseBloodlinesGet> };
        categories: {
            get(): Promise<UniverseCategoriesGet>;
            (categoryId: number): { get(): Promise<UniverseCategoriesCategoryIdGet> };
        };
        constellations: {
            get(): Promise<UniverseConstellationsGet>;
            (
                constellationId: number,
            ): { get(): Promise<UniverseConstellationsConstellationIdGet> };
        };
        factions: { get(): Promise<UniverseFactionsGet> };
        graphics: {
            get(): Promise<UniverseGraphicsGet>;
            (graphicId: number): { get(): Promise<UniverseGraphicsGraphicIdGet> };
        };
        groups: {
            get(): AsyncIterable<number>;
            (groupId: number): { get(): Promise<UniverseGroupsGroupIdGet> };
        };
        ids: { post(body: PostUniverseIdsBody): Promise<UniverseIdsPost> };
        moons: (moonId: number) => { get(): Promise<UniverseMoonsMoonIdGet> };
        names: { post(body: PostUniverseNamesBody): Promise<UniverseNamesPost> };
        planets: (
            planetId: number,
        ) => { get(): Promise<UniversePlanetsPlanetIdGet> };
        races: { get(): Promise<UniverseRacesGet> };
        regions: {
            get(): Promise<UniverseRegionsGet>;
            (regionId: number): { get(): Promise<UniverseRegionsRegionIdGet> };
        };
        schematics: (
            schematicId: number,
        ) => { get(): Promise<UniverseSchematicsSchematicIdGet> };
        stargates: (
            stargateId: number,
        ) => { get(): Promise<UniverseStargatesStargateIdGet> };
        stars: (starId: number) => { get(): Promise<UniverseStarsStarIdGet> };
        stations: (
            stationId: number,
        ) => { get(): Promise<UniverseStationsStationIdGet> };
        structures: {
            get(
                params?: GetUniverseStructuresParams,
            ): Promise<UniverseStructuresGet>;
        };
        systemJumps: { get(): Promise<UniverseSystemJumpsGet> };
        systemKills: { get(): Promise<UniverseSystemKillsGet> };
        systems: {
            get(): Promise<UniverseSystemsGet>;
            (systemId: number): { get(): Promise<UniverseSystemsSystemIdGet> };
        };
        types: {
            get(): AsyncIterable<number>;
            (typeId: number): { get(): Promise<UniverseTypesTypeIdGet> };
        };
    };
    war: (
        warId: number,
    ) => {
        get(): Promise<WarsWarIdGet>;
        killmails: {
            get(): AsyncIterable<{ killmail_hash: string; killmail_id: number }>;
        };
    };
    wars: { get(params?: GetWarsParams): Promise<WarsGet> };
}