4398 lines
196 KiB
TypeScript
4398 lines
196 KiB
TypeScript
/* tslint:disable */
|
|
/* eslint-disable */
|
|
/**
|
|
* OpenAPI definition
|
|
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
|
|
*
|
|
* The version of the OpenAPI document: v0
|
|
*
|
|
*
|
|
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
|
|
* https://openapi-generator.tech
|
|
* Do not edit the class manually.
|
|
*/
|
|
|
|
|
|
import type { Configuration } from './configuration';
|
|
import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
|
|
import globalAxios from 'axios';
|
|
// Some imports not used depending on template conditions
|
|
// @ts-ignore
|
|
import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setOAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction, replaceWithSerializableTypeIfNeeded } from './common';
|
|
import type { RequestArgs } from './base';
|
|
// @ts-ignore
|
|
import { BASE_PATH, COLLECTION_FORMATS, BaseAPI, RequiredError, operationServerMap } from './base';
|
|
|
|
/**
|
|
* A single acquisition of a market type, tracking the remaining quantity available in the FIFO cost pool.
|
|
*/
|
|
export interface AcquisitionResponse {
|
|
/**
|
|
* Unique acquisition identifier.
|
|
*/
|
|
'acquisitionId': string;
|
|
/**
|
|
* Ledger the acquisition is held in.
|
|
*/
|
|
'ledgerId': string;
|
|
/**
|
|
* Where the acquisition came from: a character, a corporation, or nothing.
|
|
*/
|
|
'source': ActivitySourceResponse;
|
|
/**
|
|
* EVE market type (item) id that was acquired.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* When the acquisition occurred.
|
|
*/
|
|
'datetime': string;
|
|
/**
|
|
* Quantity originally acquired.
|
|
*/
|
|
'quantity': number;
|
|
/**
|
|
* Quantity still remaining in the FIFO cost pool.
|
|
*/
|
|
'remaining': number;
|
|
/**
|
|
* Cost per unit at acquisition time, in ISK.
|
|
*/
|
|
'unitCost': number;
|
|
}
|
|
/**
|
|
* Where a manual activity is attributed: a character, a ledger, or nothing. CORPORATION is not accepted.
|
|
*/
|
|
export interface ActivitySourceRequest {
|
|
/**
|
|
* The kind of source.
|
|
*/
|
|
'type': ActivitySourceRequestTypeEnum;
|
|
/**
|
|
* EVE character id, when the source is a character.
|
|
*/
|
|
'characterId': number | null;
|
|
/**
|
|
* Ledger id, when the source is a ledger.
|
|
*/
|
|
'ledgerId': string | null;
|
|
}
|
|
|
|
export const ActivitySourceRequestTypeEnum = {
|
|
Character: 'CHARACTER',
|
|
Ledger: 'LEDGER',
|
|
None: 'NONE',
|
|
} as const;
|
|
|
|
export type ActivitySourceRequestTypeEnum = typeof ActivitySourceRequestTypeEnum[keyof typeof ActivitySourceRequestTypeEnum];
|
|
|
|
/**
|
|
* Where an activity or transaction came from: a character, a corporation wallet, a ledger, or nothing (a manual entry).
|
|
*/
|
|
export interface ActivitySourceResponse {
|
|
/**
|
|
* The kind of source.
|
|
*/
|
|
'type': ActivitySourceResponseTypeEnum;
|
|
/**
|
|
* EVE character id, when the source is a character.
|
|
*/
|
|
'characterId': number | null;
|
|
/**
|
|
* EVE corporation id, when the source is a corporation.
|
|
*/
|
|
'corporationId': number | null;
|
|
/**
|
|
* Corporation wallet division (1-7), when the source is a corporation and it is known.
|
|
*/
|
|
'division': number | null;
|
|
/**
|
|
* Ledger id, when the source is a ledger.
|
|
*/
|
|
'ledgerId': string | null;
|
|
}
|
|
|
|
export const ActivitySourceResponseTypeEnum = {
|
|
Character: 'CHARACTER',
|
|
Corporation: 'CORPORATION',
|
|
Ledger: 'LEDGER',
|
|
None: 'NONE',
|
|
} as const;
|
|
|
|
export type ActivitySourceResponseTypeEnum = typeof ActivitySourceResponseTypeEnum[keyof typeof ActivitySourceResponseTypeEnum];
|
|
|
|
/**
|
|
* The balance of a ledger: its ISK total plus the quantity of each item type held.
|
|
*/
|
|
export interface BalanceResponse {
|
|
/**
|
|
* ISK balance of the ledger.
|
|
*/
|
|
'iskBalance': number;
|
|
/**
|
|
* Per-item-type quantities held in the ledger.
|
|
*/
|
|
'itemBalances': Array<ItemBalanceResponse>;
|
|
}
|
|
/**
|
|
* An EVE Online character.
|
|
*/
|
|
export interface CharacterResponse {
|
|
/**
|
|
* EVE character id.
|
|
*/
|
|
'characterId': number;
|
|
/**
|
|
* Character name.
|
|
*/
|
|
'name': string;
|
|
}
|
|
/**
|
|
* A combined ledger: an aggregate whose balance is the sum of its member ledgers.
|
|
*/
|
|
export interface CombinedLedgerResponse extends LedgerResponse {
|
|
/**
|
|
* Unique ledger identifier.
|
|
*/
|
|
'ledgerId': string;
|
|
/**
|
|
* Ledger name.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Aggregate ISK balance across all member ledgers.
|
|
*/
|
|
'balance': number;
|
|
/**
|
|
* Ids of the ledgers aggregated by this combined ledger.
|
|
*/
|
|
'memberLedgerIds': Array<string>;
|
|
}
|
|
/**
|
|
* An EVE Online corporation.
|
|
*/
|
|
export interface CorporationResponse {
|
|
/**
|
|
* EVE corporation id.
|
|
*/
|
|
'corporationId': number;
|
|
/**
|
|
* Corporation name.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Corporation ticker.
|
|
*/
|
|
'ticker': string;
|
|
/**
|
|
* EVE alliance id, null when the corporation is not in an alliance.
|
|
*/
|
|
'allianceId': number;
|
|
}
|
|
/**
|
|
* Request to create a new combined ledger aggregating the given member ledgers.
|
|
*/
|
|
export interface CreateCombinedLedgerRequest {
|
|
/**
|
|
* Name for the new combined ledger.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Ids of the ledgers to aggregate.
|
|
*/
|
|
'memberLedgerIds': Array<string>;
|
|
}
|
|
/**
|
|
* Request to create a new main ledger.
|
|
*/
|
|
export interface CreateMainLedgerRequest {
|
|
/**
|
|
* Name for the new ledger.
|
|
*/
|
|
'name': string;
|
|
}
|
|
/**
|
|
* Profit for a single day: ISK in, ISK out, and their difference.
|
|
*/
|
|
export interface DailyProfitResponse {
|
|
/**
|
|
* The UTC (EVE) day this profit is for.
|
|
*/
|
|
'date': string;
|
|
/**
|
|
* Total ISK that entered the ledger on this day.
|
|
*/
|
|
'iskIn': number;
|
|
/**
|
|
* Total ISK that left the ledger on this day.
|
|
*/
|
|
'iskOut': number;
|
|
/**
|
|
* Profit for the day: iskIn minus iskOut.
|
|
*/
|
|
'profit': number;
|
|
}
|
|
/**
|
|
* A market location (NPC station) with its containing solar system and region.
|
|
*/
|
|
export interface DockableLocationResponse {
|
|
/**
|
|
* EVE market location id (station id).
|
|
*/
|
|
'id': number;
|
|
/**
|
|
* Location name.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Id of the solar system the location is in.
|
|
*/
|
|
'systemId': number;
|
|
/**
|
|
* Name of the solar system the location is in.
|
|
*/
|
|
'systemName': string;
|
|
/**
|
|
* Id of the region the location is in.
|
|
*/
|
|
'regionId': number;
|
|
/**
|
|
* Name of the region the location is in.
|
|
*/
|
|
'regionName': string;
|
|
}
|
|
/**
|
|
* Quartile statistics computed over a market type\'s price history.
|
|
*/
|
|
export interface HistoryQuartilesResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* First quartile (25th percentile) price, in ISK.
|
|
*/
|
|
'q1': number;
|
|
/**
|
|
* Median (50th percentile) price, in ISK.
|
|
*/
|
|
'median': number;
|
|
/**
|
|
* Third quartile (75th percentile) price, in ISK.
|
|
*/
|
|
'q3': number;
|
|
/**
|
|
* Total traded volume over the period.
|
|
*/
|
|
'totalVolume': number;
|
|
/**
|
|
* Overall price trend over the period.
|
|
*/
|
|
'trend': HistoryQuartilesResponseTrendEnum;
|
|
}
|
|
|
|
export const HistoryQuartilesResponseTrendEnum = {
|
|
Up: 'UP',
|
|
Down: 'DOWN',
|
|
Flat: 'FLAT',
|
|
} as const;
|
|
|
|
export type HistoryQuartilesResponseTrendEnum = typeof HistoryQuartilesResponseTrendEnum[keyof typeof HistoryQuartilesResponseTrendEnum];
|
|
|
|
/**
|
|
* A transfer of ISK from one ledger to another.
|
|
*/
|
|
export interface IskTransferResponse extends TransferResponse {
|
|
/**
|
|
* Id of the ledger the ISK is debited from.
|
|
*/
|
|
'fromLedgerId': string;
|
|
/**
|
|
* Id of the ledger the ISK is credited to.
|
|
*/
|
|
'toLedgerId': string;
|
|
/**
|
|
* Amount of ISK transferred.
|
|
*/
|
|
'amount': number;
|
|
}
|
|
/**
|
|
* Quantity of a single item type held in a ledger.
|
|
*/
|
|
export interface ItemBalanceResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'typeId': number;
|
|
/**
|
|
* Number of units held.
|
|
*/
|
|
'quantity': number;
|
|
}
|
|
/**
|
|
* A transfer of an item stack from one ledger to another.
|
|
*/
|
|
export interface ItemTransferResponse extends TransferResponse {
|
|
/**
|
|
* Id of the ledger the items are debited from.
|
|
*/
|
|
'fromLedgerId': string;
|
|
/**
|
|
* Id of the ledger the items are credited to.
|
|
*/
|
|
'toLedgerId': string;
|
|
/**
|
|
* EVE market type (item) id transferred.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Number of units transferred.
|
|
*/
|
|
'quantity': number;
|
|
}
|
|
/**
|
|
* @type LedgerResponse
|
|
* A ledger, either a standalone main ledger or a combined ledger aggregating others.
|
|
*/
|
|
export type LedgerResponse = { type: 'COMBINED' } & CombinedLedgerResponse | { type: 'MAIN' } & MainLedgerResponse;
|
|
|
|
/**
|
|
* A main ledger: a standalone ledger with its own balance.
|
|
*/
|
|
export interface MainLedgerResponse extends LedgerResponse {
|
|
/**
|
|
* Unique ledger identifier.
|
|
*/
|
|
'ledgerId': string;
|
|
/**
|
|
* Ledger name.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Current ISK balance of the ledger.
|
|
*/
|
|
'balance': number;
|
|
}
|
|
/**
|
|
* Request to manually record an acquisition (buy) or consumption (sell) of an item.
|
|
*/
|
|
export interface ManualActivityRequest {
|
|
/**
|
|
* Where the activity is attributed.
|
|
*/
|
|
'source': ActivitySourceRequest;
|
|
/**
|
|
* EVE type id of the traded item.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Number of units.
|
|
*/
|
|
'quantity': number;
|
|
/**
|
|
* Price per unit.
|
|
*/
|
|
'unitPrice': number;
|
|
/**
|
|
* When the activity happened. Defaults to now when omitted.
|
|
*/
|
|
'datetime': string | null;
|
|
/**
|
|
* Taxes paid. Defaults to 0 when omitted.
|
|
*/
|
|
'taxes': number | null;
|
|
/**
|
|
* Free-form description.
|
|
*/
|
|
'description': string | null;
|
|
}
|
|
/**
|
|
* A single day of market history for a market type.
|
|
*/
|
|
export interface MarketHistoryResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Date the history entry covers.
|
|
*/
|
|
'date': string;
|
|
/**
|
|
* Average price for the day, in ISK.
|
|
*/
|
|
'average': number;
|
|
/**
|
|
* Highest price for the day, in ISK.
|
|
*/
|
|
'highest': number;
|
|
/**
|
|
* Lowest price for the day, in ISK.
|
|
*/
|
|
'lowest': number;
|
|
/**
|
|
* Number of orders for the day.
|
|
*/
|
|
'orderCount': number;
|
|
/**
|
|
* Traded volume for the day.
|
|
*/
|
|
'volume': number;
|
|
}
|
|
/**
|
|
* An open market order placed by one of the authenticated user\'s characters.
|
|
*/
|
|
export interface MarketOrderResponse {
|
|
/**
|
|
* EVE market order id.
|
|
*/
|
|
'orderId': number;
|
|
/**
|
|
* EVE character id that owns the order.
|
|
*/
|
|
'characterId': number;
|
|
/**
|
|
* Name of the character that owns the order.
|
|
*/
|
|
'characterName': string;
|
|
/**
|
|
* EVE market type (item) id being traded.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Location id (station or structure) the order is placed at.
|
|
*/
|
|
'locationId': number;
|
|
/**
|
|
* Region id the order resides in.
|
|
*/
|
|
'regionId': number;
|
|
/**
|
|
* Trade direction of the order.
|
|
*/
|
|
'direction': MarketOrderResponseDirectionEnum;
|
|
/**
|
|
* Price per unit, in ISK.
|
|
*/
|
|
'price': number;
|
|
/**
|
|
* Total volume the order was created with.
|
|
*/
|
|
'volumeTotal': number;
|
|
/**
|
|
* Volume still remaining on the order.
|
|
*/
|
|
'volumeRemain': number;
|
|
/**
|
|
* Minimum volume that must be bought or sold in a single transaction.
|
|
*/
|
|
'minVolume': number;
|
|
/**
|
|
* Order range. For buy orders the matching range, for sell orders always \'region\'.
|
|
*/
|
|
'range': string;
|
|
/**
|
|
* Duration of the order, in days.
|
|
*/
|
|
'duration': number;
|
|
/**
|
|
* When the order was issued.
|
|
*/
|
|
'issued': string;
|
|
/**
|
|
* ISK held in escrow for a buy order; null for sell orders.
|
|
*/
|
|
'escrow': number;
|
|
}
|
|
|
|
export const MarketOrderResponseDirectionEnum = {
|
|
Buy: 'BUY',
|
|
Sell: 'SELL',
|
|
} as const;
|
|
|
|
export type MarketOrderResponseDirectionEnum = typeof MarketOrderResponseDirectionEnum[keyof typeof MarketOrderResponseDirectionEnum];
|
|
|
|
/**
|
|
* Current best buy and sell prices for a market type.
|
|
*/
|
|
export interface MarketPriceResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Best buy price, in ISK.
|
|
*/
|
|
'buy': number;
|
|
/**
|
|
* Best sell price, in ISK.
|
|
*/
|
|
'sell': number;
|
|
/**
|
|
* Number of market orders considered.
|
|
*/
|
|
'orderCount': number;
|
|
}
|
|
/**
|
|
* Result of a market scan combining current prices, history quartiles and a computed profitability score for a market type.
|
|
*/
|
|
export interface MarketScanResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Current best buy price, in ISK.
|
|
*/
|
|
'buy': number;
|
|
/**
|
|
* Current best sell price, in ISK.
|
|
*/
|
|
'sell': number;
|
|
/**
|
|
* First quartile (25th percentile) historical price, in ISK.
|
|
*/
|
|
'q1': number;
|
|
/**
|
|
* Median (50th percentile) historical price, in ISK.
|
|
*/
|
|
'median': number;
|
|
/**
|
|
* Third quartile (75th percentile) historical price, in ISK.
|
|
*/
|
|
'q3': number;
|
|
/**
|
|
* Total traded volume over the scanned period.
|
|
*/
|
|
'totalVolume': number;
|
|
/**
|
|
* Overall price trend over the scanned period.
|
|
*/
|
|
'trend': MarketScanResponseTrendEnum;
|
|
/**
|
|
* Estimated profit per unit after fees and taxes, in ISK.
|
|
*/
|
|
'profit': number;
|
|
/**
|
|
* Computed profitability score used to rank scan results.
|
|
*/
|
|
'score': number;
|
|
}
|
|
|
|
export const MarketScanResponseTrendEnum = {
|
|
Up: 'UP',
|
|
Down: 'DOWN',
|
|
Flat: 'FLAT',
|
|
} as const;
|
|
|
|
export type MarketScanResponseTrendEnum = typeof MarketScanResponseTrendEnum[keyof typeof MarketScanResponseTrendEnum];
|
|
|
|
/**
|
|
* An EVE Online market type (item) and its static attributes.
|
|
*/
|
|
export interface MarketTypeResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'id': number;
|
|
/**
|
|
* Item name.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Group id the item belongs to.
|
|
*/
|
|
'groupId': number;
|
|
/**
|
|
* Market group id the item is listed under.
|
|
*/
|
|
'marketGroupId': number;
|
|
/**
|
|
* Item description.
|
|
*/
|
|
'description': string;
|
|
/**
|
|
* Whether the item is published and visible in game.
|
|
*/
|
|
'published': boolean;
|
|
/**
|
|
* Base price of the item, in ISK, if defined.
|
|
*/
|
|
'basePrice': number | null;
|
|
/**
|
|
* Packaged volume of a single unit, in m³.
|
|
*/
|
|
'volume': number;
|
|
/**
|
|
* Number of units produced or reprocessed per portion.
|
|
*/
|
|
'portionSize': number;
|
|
/**
|
|
* Icon id for the item, if defined.
|
|
*/
|
|
'iconId': number | null;
|
|
}
|
|
/**
|
|
* A market type stack valued at current buy and sell prices.
|
|
*/
|
|
export interface MarketTypeStackAppraisalResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Number of units in the stack.
|
|
*/
|
|
'quantity': number;
|
|
/**
|
|
* Total buy value of the stack, in ISK.
|
|
*/
|
|
'buy': number;
|
|
/**
|
|
* Total sell value of the stack, in ISK.
|
|
*/
|
|
'sell': number;
|
|
/**
|
|
* Number of market orders considered for the valuation.
|
|
*/
|
|
'orderCount': number;
|
|
}
|
|
/**
|
|
* A quantity of a single market type to reprocess.
|
|
*/
|
|
export interface MarketTypeStackRequest {
|
|
/**
|
|
* EVE market type (item) id to reprocess.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Number of units to reprocess.
|
|
*/
|
|
'quantity': number;
|
|
}
|
|
/**
|
|
* A quantity of a single market type.
|
|
*/
|
|
export interface MarketTypeStackResponse {
|
|
/**
|
|
* EVE market type (item) id.
|
|
*/
|
|
'marketTypeId': number;
|
|
/**
|
|
* Number of units in the stack.
|
|
*/
|
|
'quantity': number;
|
|
}
|
|
/**
|
|
* The authenticated user and the characters they own.
|
|
*/
|
|
export interface MeResponse {
|
|
/**
|
|
* Unique user identifier.
|
|
*/
|
|
'userId': string;
|
|
/**
|
|
* Characters owned by the user.
|
|
*/
|
|
'characters': Array<CharacterResponse>;
|
|
}
|
|
/**
|
|
* A freshly minted access token.
|
|
*/
|
|
export interface RefreshResponse {
|
|
/**
|
|
* Short-lived bearer access token (JWT) for the Authorization header.
|
|
*/
|
|
'accessToken': string;
|
|
}
|
|
/**
|
|
* Request to reprocess a set of item stacks on behalf of a character.
|
|
*/
|
|
export interface ReprocessItemsRequest {
|
|
/**
|
|
* EVE character id whose reprocessing skills and facility standings are applied.
|
|
*/
|
|
'characterId': number;
|
|
/**
|
|
* Item stacks to reprocess.
|
|
*/
|
|
'items': Array<MarketTypeStackRequest>;
|
|
}
|
|
/**
|
|
* Result of reprocessing an item stack: the input stack and the resulting material outputs, each valued at market prices.
|
|
*/
|
|
export interface ReprocessingResultResponse {
|
|
/**
|
|
* The input stack that was reprocessed.
|
|
*/
|
|
'input': MarketTypeStackAppraisalResponse;
|
|
/**
|
|
* Material stacks yielded by reprocessing the input.
|
|
*/
|
|
'output': Array<MarketTypeStackAppraisalResponse>;
|
|
}
|
|
/**
|
|
* The caller\'s rule book: the named rule scripts that classify transactions, each with its scope.
|
|
*/
|
|
export interface RuleBookResponse {
|
|
/**
|
|
* Owning user identifier.
|
|
*/
|
|
'userId': string;
|
|
/**
|
|
* The rule scripts making up the book.
|
|
*/
|
|
'scripts': Array<RuleScriptResponse>;
|
|
}
|
|
/**
|
|
* The ledgers and other resources to bind to a rule script.
|
|
*/
|
|
export interface RuleScopeRequest {
|
|
/**
|
|
* Ledger references the script writes to, each bound to one of the user\'s own main ledgers.
|
|
*/
|
|
'ledgers': { [key: string]: string; };
|
|
/**
|
|
* Character references the script can read, each bound to one of the user\'s own characters.
|
|
*/
|
|
'characters': { [key: string]: number; };
|
|
/**
|
|
* Corporation references the script can read, each bound to a corporation of one of the user\'s own characters.
|
|
*/
|
|
'corporations': { [key: string]: number; };
|
|
/**
|
|
* Corporation wallet division references the script can read, each bound to a corporation of one of the user\'s own characters.
|
|
*/
|
|
'walletDivisions': { [key: string]: WalletDivisionTargetRequest; };
|
|
}
|
|
/**
|
|
* The ledgers and other resources bound to a rule script.
|
|
*/
|
|
export interface RuleScopeResponse {
|
|
/**
|
|
* Ledger references the script writes to, each bound to one of the user\'s own main ledgers.
|
|
*/
|
|
'ledgers': { [key: string]: string; };
|
|
/**
|
|
* Character references the script can read, each bound to one of the user\'s own characters.
|
|
*/
|
|
'characters': { [key: string]: number; };
|
|
/**
|
|
* Corporation references the script can read, each bound to a corporation of one of the user\'s own characters.
|
|
*/
|
|
'corporations': { [key: string]: number; };
|
|
/**
|
|
* Corporation wallet division references the script can read, each bound to a corporation of one of the user\'s own characters.
|
|
*/
|
|
'walletDivisions': { [key: string]: WalletDivisionTargetResponse; };
|
|
}
|
|
/**
|
|
* A named rule script to store in the book, together with its scope.
|
|
*/
|
|
export interface RuleScriptRequest {
|
|
/**
|
|
* Unique script name within the book; a lowercase alphanumeric identifier.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* The ledgers and other resources bound to this script.
|
|
*/
|
|
'scope': RuleScopeRequest;
|
|
/**
|
|
* The classification script source.
|
|
*/
|
|
'script': string;
|
|
}
|
|
/**
|
|
* A named rule script within the book, together with its scope.
|
|
*/
|
|
export interface RuleScriptResponse {
|
|
/**
|
|
* Unique script name within the book.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* The ledgers and other resources bound to this script.
|
|
*/
|
|
'scope': RuleScopeResponse;
|
|
/**
|
|
* The classification script source.
|
|
*/
|
|
'script': string;
|
|
}
|
|
export interface SseEmitter {
|
|
'timeout': number;
|
|
}
|
|
/**
|
|
* A transaction: a dated, described group of transfers between ledgers.
|
|
*/
|
|
export interface TransactionResponse {
|
|
/**
|
|
* Unique transaction identifier.
|
|
*/
|
|
'transactionId': string;
|
|
/**
|
|
* Where the transaction is attributed: a character, a corporation, or nothing.
|
|
*/
|
|
'source': ActivitySourceResponse;
|
|
/**
|
|
* When the transaction occurred.
|
|
*/
|
|
'datetime': string;
|
|
/**
|
|
* Human-readable description of the transaction.
|
|
*/
|
|
'description': string;
|
|
/**
|
|
* The transfers that make up this transaction.
|
|
*/
|
|
'transfers': Array<TransferResponse>;
|
|
}
|
|
/**
|
|
* @type TransferResponse
|
|
* A transfer between two ledgers, either of ISK or of an item stack.
|
|
*/
|
|
export type TransferResponse = { type: 'ISK' } & IskTransferResponse | { type: 'ITEM' } & ItemTransferResponse;
|
|
|
|
/**
|
|
* Request to update an existing combined ledger; replaces its name and member set.
|
|
*/
|
|
export interface UpdateCombinedLedgerRequest {
|
|
/**
|
|
* New name for the combined ledger.
|
|
*/
|
|
'name': string;
|
|
/**
|
|
* Ids of the ledgers to aggregate.
|
|
*/
|
|
'memberLedgerIds': Array<string>;
|
|
}
|
|
/**
|
|
* Request to update an existing main ledger.
|
|
*/
|
|
export interface UpdateMainLedgerRequest {
|
|
/**
|
|
* New name for the ledger.
|
|
*/
|
|
'name': string;
|
|
}
|
|
/**
|
|
* Request to update the caller\'s rule book; replaces its rule scripts.
|
|
*/
|
|
export interface UpdateRuleBookRequest {
|
|
/**
|
|
* The rule scripts making up the book.
|
|
*/
|
|
'scripts': Array<RuleScriptRequest>;
|
|
}
|
|
/**
|
|
* A corporation wallet division to bind.
|
|
*/
|
|
export interface WalletDivisionTargetRequest {
|
|
/**
|
|
* The corporation the wallet division belongs to.
|
|
*/
|
|
'corporationId': number;
|
|
/**
|
|
* The wallet division number, from 1 to 7.
|
|
*/
|
|
'division': number;
|
|
}
|
|
/**
|
|
* A corporation wallet division bound to the script.
|
|
*/
|
|
export interface WalletDivisionTargetResponse {
|
|
/**
|
|
* The corporation the wallet division belongs to.
|
|
*/
|
|
'corporationId': number;
|
|
/**
|
|
* The wallet division number, from 1 to 7.
|
|
*/
|
|
'division': number;
|
|
}
|
|
|
|
/**
|
|
* AcquisitionApi - axios parameter creator
|
|
*/
|
|
export const AcquisitionApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s acquisitions, optionally filtered by ledger, market type and consumption state
|
|
* @param {string} [ledgerId] Only return acquisitions held in this ledger
|
|
* @param {number} [marketTypeId] Only return acquisitions of this market type
|
|
* @param {boolean} [includeConsumed] Include fully consumed acquisitions (no remaining stock)
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllAcquisitions: async (ledgerId?: string, marketTypeId?: number, includeConsumed?: boolean, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/acquisitions`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (ledgerId !== undefined) {
|
|
localVarQueryParameter['ledgerId'] = ledgerId;
|
|
}
|
|
|
|
if (marketTypeId !== undefined) {
|
|
localVarQueryParameter['marketTypeId'] = marketTypeId;
|
|
}
|
|
|
|
if (includeConsumed !== undefined) {
|
|
localVarQueryParameter['includeConsumed'] = includeConsumed;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* AcquisitionApi - functional programming interface
|
|
*/
|
|
export const AcquisitionApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = AcquisitionApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s acquisitions, optionally filtered by ledger, market type and consumption state
|
|
* @param {string} [ledgerId] Only return acquisitions held in this ledger
|
|
* @param {number} [marketTypeId] Only return acquisitions of this market type
|
|
* @param {boolean} [includeConsumed] Include fully consumed acquisitions (no remaining stock)
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findAllAcquisitions(ledgerId?: string, marketTypeId?: number, includeConsumed?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<AcquisitionResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findAllAcquisitions(ledgerId, marketTypeId, includeConsumed, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['AcquisitionApi.findAllAcquisitions']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* AcquisitionApi - factory interface
|
|
*/
|
|
export const AcquisitionApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = AcquisitionApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s acquisitions, optionally filtered by ledger, market type and consumption state
|
|
* @param {string} [ledgerId] Only return acquisitions held in this ledger
|
|
* @param {number} [marketTypeId] Only return acquisitions of this market type
|
|
* @param {boolean} [includeConsumed] Include fully consumed acquisitions (no remaining stock)
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllAcquisitions(ledgerId?: string, marketTypeId?: number, includeConsumed?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<Array<AcquisitionResponse>> {
|
|
return localVarFp.findAllAcquisitions(ledgerId, marketTypeId, includeConsumed, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* AcquisitionApi - object-oriented interface
|
|
*/
|
|
export class AcquisitionApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s acquisitions, optionally filtered by ledger, market type and consumption state
|
|
* @param {string} [ledgerId] Only return acquisitions held in this ledger
|
|
* @param {number} [marketTypeId] Only return acquisitions of this market type
|
|
* @param {boolean} [includeConsumed] Include fully consumed acquisitions (no remaining stock)
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findAllAcquisitions(ledgerId?: string, marketTypeId?: number, includeConsumed?: boolean, options?: RawAxiosRequestConfig) {
|
|
return AcquisitionApiFp(this.configuration).findAllAcquisitions(ledgerId, marketTypeId, includeConsumed, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* ActivityApi - axios parameter creator
|
|
*/
|
|
export const ActivityApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Manually record an acquisition (buy) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
acquire: async (manualActivityRequest: ManualActivityRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'manualActivityRequest' is not null or undefined
|
|
assertParamExists('acquire', 'manualActivityRequest', manualActivityRequest)
|
|
const localVarPath = `/activity/acquire`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(manualActivityRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Manually record a consumption (sell) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
consume: async (manualActivityRequest: ManualActivityRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'manualActivityRequest' is not null or undefined
|
|
assertParamExists('consume', 'manualActivityRequest', manualActivityRequest)
|
|
const localVarPath = `/activity/consume`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(manualActivityRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Process new activities for the authenticated user\'s characters
|
|
* @param {string} [from] Reprocess by walking the processed tail back to this UTC datetime (ISO-8601); omit to only process new activities
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
processNewActivities: async (from?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/activities/process`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (from !== undefined) {
|
|
localVarQueryParameter['from'] = (from as any instanceof Date) ?
|
|
(from as any).toISOString() :
|
|
from;
|
|
}
|
|
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Stream a notification when the user\'s activity processing completes
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
streamProcessing: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/activities/processed`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = 'text/event-stream';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* ActivityApi - functional programming interface
|
|
*/
|
|
export const ActivityApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = ActivityApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Manually record an acquisition (buy) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async acquire(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.acquire(manualActivityRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ActivityApi.acquire']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Manually record a consumption (sell) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async consume(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.consume(manualActivityRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ActivityApi.consume']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Process new activities for the authenticated user\'s characters
|
|
* @param {string} [from] Reprocess by walking the processed tail back to this UTC datetime (ISO-8601); omit to only process new activities
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async processNewActivities(from?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.processNewActivities(from, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ActivityApi.processNewActivities']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Stream a notification when the user\'s activity processing completes
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async streamProcessing(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SseEmitter>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.streamProcessing(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ActivityApi.streamProcessing']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* ActivityApi - factory interface
|
|
*/
|
|
export const ActivityApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = ActivityApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Manually record an acquisition (buy) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
acquire(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.acquire(manualActivityRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Manually record a consumption (sell) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
consume(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.consume(manualActivityRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Process new activities for the authenticated user\'s characters
|
|
* @param {string} [from] Reprocess by walking the processed tail back to this UTC datetime (ISO-8601); omit to only process new activities
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
processNewActivities(from?: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.processNewActivities(from, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Stream a notification when the user\'s activity processing completes
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
streamProcessing(options?: RawAxiosRequestConfig): AxiosPromise<SseEmitter> {
|
|
return localVarFp.streamProcessing(options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* ActivityApi - object-oriented interface
|
|
*/
|
|
export class ActivityApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Manually record an acquisition (buy) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public acquire(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig) {
|
|
return ActivityApiFp(this.configuration).acquire(manualActivityRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Manually record a consumption (sell) of an item. Call POST /activities/process to fold it into acquisitions.
|
|
* @param {ManualActivityRequest} manualActivityRequest
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public consume(manualActivityRequest: ManualActivityRequest, options?: RawAxiosRequestConfig) {
|
|
return ActivityApiFp(this.configuration).consume(manualActivityRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Process new activities for the authenticated user\'s characters
|
|
* @param {string} [from] Reprocess by walking the processed tail back to this UTC datetime (ISO-8601); omit to only process new activities
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public processNewActivities(from?: string, options?: RawAxiosRequestConfig) {
|
|
return ActivityApiFp(this.configuration).processNewActivities(from, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Stream a notification when the user\'s activity processing completes
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public streamProcessing(options?: RawAxiosRequestConfig) {
|
|
return ActivityApiFp(this.configuration).streamProcessing(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* AuthApi - axios parameter creator
|
|
*/
|
|
export const AuthApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Seed the current user in the session so the next SSO links the new character to them
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
addCharacter: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/characters/add`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Revoke the refresh session and clear the refresh cookie
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
logout: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/logout`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the authenticated user and the characters they own
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
me: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/me`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Rotate the refresh session and mint a fresh access token
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
refresh: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/refresh`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* AuthApi - functional programming interface
|
|
*/
|
|
export const AuthApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = AuthApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Seed the current user in the session so the next SSO links the new character to them
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async addCharacter(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.addCharacter(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['AuthApi.addCharacter']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Revoke the refresh session and clear the refresh cookie
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async logout(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.logout(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['AuthApi.logout']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the authenticated user and the characters they own
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async me(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MeResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.me(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['AuthApi.me']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Rotate the refresh session and mint a fresh access token
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async refresh(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RefreshResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.refresh(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['AuthApi.refresh']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* AuthApi - factory interface
|
|
*/
|
|
export const AuthApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = AuthApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Seed the current user in the session so the next SSO links the new character to them
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
addCharacter(options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.addCharacter(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Revoke the refresh session and clear the refresh cookie
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
logout(options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.logout(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the authenticated user and the characters they own
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
me(options?: RawAxiosRequestConfig): AxiosPromise<MeResponse> {
|
|
return localVarFp.me(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Rotate the refresh session and mint a fresh access token
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
refresh(options?: RawAxiosRequestConfig): AxiosPromise<RefreshResponse> {
|
|
return localVarFp.refresh(options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* AuthApi - object-oriented interface
|
|
*/
|
|
export class AuthApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Seed the current user in the session so the next SSO links the new character to them
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public addCharacter(options?: RawAxiosRequestConfig) {
|
|
return AuthApiFp(this.configuration).addCharacter(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Revoke the refresh session and clear the refresh cookie
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public logout(options?: RawAxiosRequestConfig) {
|
|
return AuthApiFp(this.configuration).logout(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Return the authenticated user and the characters they own
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public me(options?: RawAxiosRequestConfig) {
|
|
return AuthApiFp(this.configuration).me(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Rotate the refresh session and mint a fresh access token
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public refresh(options?: RawAxiosRequestConfig) {
|
|
return AuthApiFp(this.configuration).refresh(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* BalanceRebuildAdminControllerApi - axios parameter creator
|
|
*/
|
|
export const BalanceRebuildAdminControllerApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @param {Array<string>} ledgerIds
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
rebuild: async (ledgerIds: Array<string>, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerIds' is not null or undefined
|
|
assertParamExists('rebuild', 'ledgerIds', ledgerIds)
|
|
const localVarPath = `/balances/rebuild`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (ledgerIds) {
|
|
localVarQueryParameter['ledgerIds'] = ledgerIds;
|
|
}
|
|
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* BalanceRebuildAdminControllerApi - functional programming interface
|
|
*/
|
|
export const BalanceRebuildAdminControllerApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = BalanceRebuildAdminControllerApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @param {Array<string>} ledgerIds
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async rebuild(ledgerIds: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.rebuild(ledgerIds, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['BalanceRebuildAdminControllerApi.rebuild']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* BalanceRebuildAdminControllerApi - factory interface
|
|
*/
|
|
export const BalanceRebuildAdminControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = BalanceRebuildAdminControllerApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @param {Array<string>} ledgerIds
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
rebuild(ledgerIds: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.rebuild(ledgerIds, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* BalanceRebuildAdminControllerApi - object-oriented interface
|
|
*/
|
|
export class BalanceRebuildAdminControllerApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @param {Array<string>} ledgerIds
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public rebuild(ledgerIds: Array<string>, options?: RawAxiosRequestConfig) {
|
|
return BalanceRebuildAdminControllerApiFp(this.configuration).rebuild(ledgerIds, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* CharacterApi - axios parameter creator
|
|
*/
|
|
export const CharacterApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllCharacters: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/characters`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* CharacterApi - functional programming interface
|
|
*/
|
|
export const CharacterApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = CharacterApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findAllCharacters(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<CharacterResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findAllCharacters(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['CharacterApi.findAllCharacters']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* CharacterApi - factory interface
|
|
*/
|
|
export const CharacterApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = CharacterApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllCharacters(options?: RawAxiosRequestConfig): AxiosPromise<Array<CharacterResponse>> {
|
|
return localVarFp.findAllCharacters(options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* CharacterApi - object-oriented interface
|
|
*/
|
|
export class CharacterApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Find the characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findAllCharacters(options?: RawAxiosRequestConfig) {
|
|
return CharacterApiFp(this.configuration).findAllCharacters(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* CorporationApi - axios parameter creator
|
|
*/
|
|
export const CorporationApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve public information (name, ticker, alliance) for a corporation id
|
|
* @param {number} corporationId Corporation id to resolve, e.g. 98000001
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findCorporation: async (corporationId: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'corporationId' is not null or undefined
|
|
assertParamExists('findCorporation', 'corporationId', corporationId)
|
|
const localVarPath = `/corporations/{corporationId}`
|
|
.replace('{corporationId}', encodeURIComponent(String(corporationId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Resolve public information for several corporation ids at once, silently omitting ids ESI cannot resolve
|
|
* @param {Array<number>} ids Corporation ids to resolve, e.g. ids=98000001,98000002
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findCorporations: async (ids: Array<number>, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ids' is not null or undefined
|
|
assertParamExists('findCorporations', 'ids', ids)
|
|
const localVarPath = `/corporations`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (ids) {
|
|
localVarQueryParameter['ids'] = ids;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* CorporationApi - functional programming interface
|
|
*/
|
|
export const CorporationApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = CorporationApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve public information (name, ticker, alliance) for a corporation id
|
|
* @param {number} corporationId Corporation id to resolve, e.g. 98000001
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findCorporation(corporationId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CorporationResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findCorporation(corporationId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['CorporationApi.findCorporation']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Resolve public information for several corporation ids at once, silently omitting ids ESI cannot resolve
|
|
* @param {Array<number>} ids Corporation ids to resolve, e.g. ids=98000001,98000002
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findCorporations(ids: Array<number>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<CorporationResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findCorporations(ids, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['CorporationApi.findCorporations']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* CorporationApi - factory interface
|
|
*/
|
|
export const CorporationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = CorporationApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve public information (name, ticker, alliance) for a corporation id
|
|
* @param {number} corporationId Corporation id to resolve, e.g. 98000001
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findCorporation(corporationId: number, options?: RawAxiosRequestConfig): AxiosPromise<CorporationResponse> {
|
|
return localVarFp.findCorporation(corporationId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Resolve public information for several corporation ids at once, silently omitting ids ESI cannot resolve
|
|
* @param {Array<number>} ids Corporation ids to resolve, e.g. ids=98000001,98000002
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findCorporations(ids: Array<number>, options?: RawAxiosRequestConfig): AxiosPromise<Array<CorporationResponse>> {
|
|
return localVarFp.findCorporations(ids, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* CorporationApi - object-oriented interface
|
|
*/
|
|
export class CorporationApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Resolve public information (name, ticker, alliance) for a corporation id
|
|
* @param {number} corporationId Corporation id to resolve, e.g. 98000001
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findCorporation(corporationId: number, options?: RawAxiosRequestConfig) {
|
|
return CorporationApiFp(this.configuration).findCorporation(corporationId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Resolve public information for several corporation ids at once, silently omitting ids ESI cannot resolve
|
|
* @param {Array<number>} ids Corporation ids to resolve, e.g. ids=98000001,98000002
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findCorporations(ids: Array<number>, options?: RawAxiosRequestConfig) {
|
|
return CorporationApiFp(this.configuration).findCorporations(ids, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* LedgerApi - axios parameter creator
|
|
*/
|
|
export const LedgerApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Create a combined ledger
|
|
* @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest Combined ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
createCombinedLedger: async (createCombinedLedgerRequest: CreateCombinedLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'createCombinedLedgerRequest' is not null or undefined
|
|
assertParamExists('createCombinedLedger', 'createCombinedLedgerRequest', createCombinedLedgerRequest)
|
|
const localVarPath = `/ledgers/combined`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(createCombinedLedgerRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Create a main ledger
|
|
* @param {CreateMainLedgerRequest} createMainLedgerRequest Main ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
createMainLedger: async (createMainLedgerRequest: CreateMainLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'createMainLedgerRequest' is not null or undefined
|
|
assertParamExists('createMainLedger', 'createMainLedgerRequest', createMainLedgerRequest)
|
|
const localVarPath = `/ledgers/main`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(createMainLedgerRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find all ledgers owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllLedgers: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/ledgers`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the balance of a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findBalanceByLedgerId: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('findBalanceByLedgerId', 'ledgerId', ledgerId)
|
|
const localVarPath = `/ledgers/{ledgerId}/balance`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find a ledger by its id
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findLedgerById: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('findLedgerById', 'ledgerId', ledgerId)
|
|
const localVarPath = `/ledgers/{ledgerId}`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a combined ledger
|
|
* @param {string} ledgerId Id of the combined ledger
|
|
* @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest New state of the combined ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateCombinedLedger: async (ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('updateCombinedLedger', 'ledgerId', ledgerId)
|
|
// verify required parameter 'updateCombinedLedgerRequest' is not null or undefined
|
|
assertParamExists('updateCombinedLedger', 'updateCombinedLedgerRequest', updateCombinedLedgerRequest)
|
|
const localVarPath = `/ledgers/combined/{ledgerId}`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(updateCombinedLedgerRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a main ledger
|
|
* @param {string} ledgerId Id of the main ledger
|
|
* @param {UpdateMainLedgerRequest} updateMainLedgerRequest New state of the main ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateMainLedger: async (ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('updateMainLedger', 'ledgerId', ledgerId)
|
|
// verify required parameter 'updateMainLedgerRequest' is not null or undefined
|
|
assertParamExists('updateMainLedger', 'updateMainLedgerRequest', updateMainLedgerRequest)
|
|
const localVarPath = `/ledgers/main/{ledgerId}`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(updateMainLedgerRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* LedgerApi - functional programming interface
|
|
*/
|
|
export const LedgerApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = LedgerApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Create a combined ledger
|
|
* @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest Combined ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CombinedLedgerResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.createCombinedLedger(createCombinedLedgerRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.createCombinedLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Create a main ledger
|
|
* @param {CreateMainLedgerRequest} createMainLedgerRequest Main ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MainLedgerResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.createMainLedger(createMainLedgerRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.createMainLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find all ledgers owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findAllLedgers(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<LedgerResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findAllLedgers(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.findAllLedgers']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the balance of a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findBalanceByLedgerId(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BalanceResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findBalanceByLedgerId(ledgerId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.findBalanceByLedgerId']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find a ledger by its id
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LedgerResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findLedgerById(ledgerId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.findLedgerById']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a combined ledger
|
|
* @param {string} ledgerId Id of the combined ledger
|
|
* @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest New state of the combined ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CombinedLedgerResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.updateCombinedLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a main ledger
|
|
* @param {string} ledgerId Id of the main ledger
|
|
* @param {UpdateMainLedgerRequest} updateMainLedgerRequest New state of the main ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MainLedgerResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.updateMainLedger(ledgerId, updateMainLedgerRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LedgerApi.updateMainLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* LedgerApi - factory interface
|
|
*/
|
|
export const LedgerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = LedgerApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Create a combined ledger
|
|
* @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest Combined ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<CombinedLedgerResponse> {
|
|
return localVarFp.createCombinedLedger(createCombinedLedgerRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Create a main ledger
|
|
* @param {CreateMainLedgerRequest} createMainLedgerRequest Main ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<MainLedgerResponse> {
|
|
return localVarFp.createMainLedger(createMainLedgerRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find all ledgers owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllLedgers(options?: RawAxiosRequestConfig): AxiosPromise<Array<LedgerResponse>> {
|
|
return localVarFp.findAllLedgers(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the balance of a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findBalanceByLedgerId(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<BalanceResponse> {
|
|
return localVarFp.findBalanceByLedgerId(ledgerId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find a ledger by its id
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<LedgerResponse> {
|
|
return localVarFp.findLedgerById(ledgerId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a combined ledger
|
|
* @param {string} ledgerId Id of the combined ledger
|
|
* @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest New state of the combined ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<CombinedLedgerResponse> {
|
|
return localVarFp.updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update a main ledger
|
|
* @param {string} ledgerId Id of the main ledger
|
|
* @param {UpdateMainLedgerRequest} updateMainLedgerRequest New state of the main ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<MainLedgerResponse> {
|
|
return localVarFp.updateMainLedger(ledgerId, updateMainLedgerRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* LedgerApi - object-oriented interface
|
|
*/
|
|
export class LedgerApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Create a combined ledger
|
|
* @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest Combined ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).createCombinedLedger(createCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Create a main ledger
|
|
* @param {CreateMainLedgerRequest} createMainLedgerRequest Main ledger to create
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).createMainLedger(createMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Find all ledgers owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findAllLedgers(options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).findAllLedgers(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Find the balance of a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findBalanceByLedgerId(ledgerId: string, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).findBalanceByLedgerId(ledgerId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Find a ledger by its id
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).findLedgerById(ledgerId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Update a combined ledger
|
|
* @param {string} ledgerId Id of the combined ledger
|
|
* @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest New state of the combined ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Update a main ledger
|
|
* @param {string} ledgerId Id of the main ledger
|
|
* @param {UpdateMainLedgerRequest} updateMainLedgerRequest New state of the main ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig) {
|
|
return LedgerApiFp(this.configuration).updateMainLedger(ledgerId, updateMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* LocationApi - axios parameter creator
|
|
*/
|
|
export const LocationApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve a market location id (NPC station or public structure, or a private structure reachable by the authenticated caller\'s characters) to its name and containing solar system and region
|
|
* @param {number} id Market location id (station id) to resolve, e.g. 60003760
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findLocationById: async (id: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'id' is not null or undefined
|
|
assertParamExists('findLocationById', 'id', id)
|
|
const localVarPath = `/locations/{id}`
|
|
.replace('{id}', encodeURIComponent(String(id)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search market locations (NPC stations and public structures, plus private structures reachable by the authenticated caller\'s characters) whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the location name, e.g. name=jita
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
searchLocations: async (name: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'name' is not null or undefined
|
|
assertParamExists('searchLocations', 'name', name)
|
|
const localVarPath = `/locations/search`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (name !== undefined) {
|
|
localVarQueryParameter['name'] = name;
|
|
}
|
|
|
|
if (limit !== undefined) {
|
|
localVarQueryParameter['limit'] = limit;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* LocationApi - functional programming interface
|
|
*/
|
|
export const LocationApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = LocationApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve a market location id (NPC station or public structure, or a private structure reachable by the authenticated caller\'s characters) to its name and containing solar system and region
|
|
* @param {number} id Market location id (station id) to resolve, e.g. 60003760
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findLocationById(id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DockableLocationResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findLocationById(id, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LocationApi.findLocationById']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search market locations (NPC stations and public structures, plus private structures reachable by the authenticated caller\'s characters) whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the location name, e.g. name=jita
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async searchLocations(name: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DockableLocationResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.searchLocations(name, limit, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['LocationApi.searchLocations']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* LocationApi - factory interface
|
|
*/
|
|
export const LocationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = LocationApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Resolve a market location id (NPC station or public structure, or a private structure reachable by the authenticated caller\'s characters) to its name and containing solar system and region
|
|
* @param {number} id Market location id (station id) to resolve, e.g. 60003760
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findLocationById(id: number, options?: RawAxiosRequestConfig): AxiosPromise<DockableLocationResponse> {
|
|
return localVarFp.findLocationById(id, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search market locations (NPC stations and public structures, plus private structures reachable by the authenticated caller\'s characters) whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the location name, e.g. name=jita
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
searchLocations(name: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<DockableLocationResponse>> {
|
|
return localVarFp.searchLocations(name, limit, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* LocationApi - object-oriented interface
|
|
*/
|
|
export class LocationApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Resolve a market location id (NPC station or public structure, or a private structure reachable by the authenticated caller\'s characters) to its name and containing solar system and region
|
|
* @param {number} id Market location id (station id) to resolve, e.g. 60003760
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findLocationById(id: number, options?: RawAxiosRequestConfig) {
|
|
return LocationApiFp(this.configuration).findLocationById(id, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Search market locations (NPC stations and public structures, plus private structures reachable by the authenticated caller\'s characters) whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the location name, e.g. name=jita
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public searchLocations(name: string, limit?: number, options?: RawAxiosRequestConfig) {
|
|
return LocationApiFp(this.configuration).searchLocations(name, limit, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* MarketApi - axios parameter creator
|
|
*/
|
|
export const MarketApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Return the current order book (highest buy, lowest sell, order count) for each requested market type, priced at the given market location (Jita by default)
|
|
* @param {Array<number>} types Market type ids to price, e.g. types=34,35
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
currentPrices: async (types: Array<number>, locationId?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'types' is not null or undefined
|
|
assertParamExists('currentPrices', 'types', types)
|
|
const localVarPath = `/market/prices`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (types) {
|
|
localVarQueryParameter['types'] = types;
|
|
}
|
|
|
|
if (locationId !== undefined) {
|
|
localVarQueryParameter['locationId'] = locationId;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the open market orders across all characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllMarketOrders: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/market/orders`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend for each requested market type
|
|
* @param {Array<number>} types Market type ids to analyze, e.g. types=34,35
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllQuartiles: async (types: Array<number>, days?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'types' is not null or undefined
|
|
assertParamExists('findAllQuartiles', 'types', types)
|
|
const localVarPath = `/market/history/quartiles`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (types) {
|
|
localVarQueryParameter['types'] = types;
|
|
}
|
|
|
|
if (days !== undefined) {
|
|
localVarQueryParameter['days'] = days;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the market history of a type, most recent first
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to return; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findHistory: async (marketTypeId: number, days?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'marketTypeId' is not null or undefined
|
|
assertParamExists('findHistory', 'marketTypeId', marketTypeId)
|
|
const localVarPath = `/market/{marketTypeId}/history`
|
|
.replace('{marketTypeId}', encodeURIComponent(String(marketTypeId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (days !== undefined) {
|
|
localVarQueryParameter['days'] = days;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend from a type\'s market history
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findQuartiles: async (marketTypeId: number, days?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'marketTypeId' is not null or undefined
|
|
assertParamExists('findQuartiles', 'marketTypeId', marketTypeId)
|
|
const localVarPath = `/market/{marketTypeId}/history/quartiles`
|
|
.replace('{marketTypeId}', encodeURIComponent(String(marketTypeId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (days !== undefined) {
|
|
localVarQueryParameter['days'] = days;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the static market type details for each requested type id
|
|
* @param {Array<number>} ids Market type ids to look up, e.g. ids=34,35
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findTypes: async (ids: Array<number>, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ids' is not null or undefined
|
|
assertParamExists('findTypes', 'ids', ids)
|
|
const localVarPath = `/market/types`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (ids) {
|
|
localVarQueryParameter['ids'] = ids;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory listing into market type stacks, resolving names to type ids
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
parseStacks: async (body: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'body' is not null or undefined
|
|
assertParamExists('parseStacks', 'body', body)
|
|
const localVarPath = `/market/types/paste`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'text/plain';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory block (item name + quantity, tab/newline separated) and return the current valuation of each stack at the given market location (Jita by default)
|
|
* @param {string} body
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
pastePrices: async (body: string, locationId?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'body' is not null or undefined
|
|
assertParamExists('pastePrices', 'body', body)
|
|
const localVarPath = `/market/prices/paste`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (locationId !== undefined) {
|
|
localVarQueryParameter['locationId'] = locationId;
|
|
}
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'text/plain';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan every tracked market type, returning volume-weighted price quartiles and the recent price trend for each
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
scanMarket: async (days?: number, brokerFee?: number, salesTax?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/market/scan`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (days !== undefined) {
|
|
localVarQueryParameter['days'] = days;
|
|
}
|
|
|
|
if (brokerFee !== undefined) {
|
|
localVarQueryParameter['brokerFee'] = brokerFee;
|
|
}
|
|
|
|
if (salesTax !== undefined) {
|
|
localVarQueryParameter['salesTax'] = salesTax;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan a single market type, returning its volume-weighted price quartiles and recent price trend
|
|
* @param {number} marketTypeId The market type id to scan
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
scanMarketType: async (marketTypeId: number, days?: number, brokerFee?: number, salesTax?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'marketTypeId' is not null or undefined
|
|
assertParamExists('scanMarketType', 'marketTypeId', marketTypeId)
|
|
const localVarPath = `/market/{marketTypeId}/scan`
|
|
.replace('{marketTypeId}', encodeURIComponent(String(marketTypeId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (days !== undefined) {
|
|
localVarQueryParameter['days'] = days;
|
|
}
|
|
|
|
if (brokerFee !== undefined) {
|
|
localVarQueryParameter['brokerFee'] = brokerFee;
|
|
}
|
|
|
|
if (salesTax !== undefined) {
|
|
localVarQueryParameter['salesTax'] = salesTax;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search marketable types whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the type name, e.g. name=tritan
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
searchTypes: async (name: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'name' is not null or undefined
|
|
assertParamExists('searchTypes', 'name', name)
|
|
const localVarPath = `/market/types/search`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (name !== undefined) {
|
|
localVarQueryParameter['name'] = name;
|
|
}
|
|
|
|
if (limit !== undefined) {
|
|
localVarQueryParameter['limit'] = limit;
|
|
}
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* MarketApi - functional programming interface
|
|
*/
|
|
export const MarketApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = MarketApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Return the current order book (highest buy, lowest sell, order count) for each requested market type, priced at the given market location (Jita by default)
|
|
* @param {Array<number>} types Market type ids to price, e.g. types=34,35
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async currentPrices(types: Array<number>, locationId?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketPriceResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.currentPrices(types, locationId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.currentPrices']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the open market orders across all characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findAllMarketOrders(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketOrderResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findAllMarketOrders(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.findAllMarketOrders']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend for each requested market type
|
|
* @param {Array<number>} types Market type ids to analyze, e.g. types=34,35
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findAllQuartiles(types: Array<number>, days?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<HistoryQuartilesResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findAllQuartiles(types, days, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.findAllQuartiles']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the market history of a type, most recent first
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to return; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findHistory(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketHistoryResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findHistory(marketTypeId, days, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.findHistory']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend from a type\'s market history
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findQuartiles(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<HistoryQuartilesResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findQuartiles(marketTypeId, days, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.findQuartiles']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the static market type details for each requested type id
|
|
* @param {Array<number>} ids Market type ids to look up, e.g. ids=34,35
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findTypes(ids: Array<number>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketTypeResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findTypes(ids, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.findTypes']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory listing into market type stacks, resolving names to type ids
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async parseStacks(body: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketTypeStackResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.parseStacks(body, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.parseStacks']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory block (item name + quantity, tab/newline separated) and return the current valuation of each stack at the given market location (Jita by default)
|
|
* @param {string} body
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async pastePrices(body: string, locationId?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketTypeStackAppraisalResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.pastePrices(body, locationId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.pastePrices']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan every tracked market type, returning volume-weighted price quartiles and the recent price trend for each
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async scanMarket(days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketScanResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.scanMarket(days, brokerFee, salesTax, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.scanMarket']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan a single market type, returning its volume-weighted price quartiles and recent price trend
|
|
* @param {number} marketTypeId The market type id to scan
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async scanMarketType(marketTypeId: number, days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MarketScanResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.scanMarketType(marketTypeId, days, brokerFee, salesTax, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.scanMarketType']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search marketable types whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the type name, e.g. name=tritan
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async searchTypes(name: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MarketTypeResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.searchTypes(name, limit, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketApi.searchTypes']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* MarketApi - factory interface
|
|
*/
|
|
export const MarketApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = MarketApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Return the current order book (highest buy, lowest sell, order count) for each requested market type, priced at the given market location (Jita by default)
|
|
* @param {Array<number>} types Market type ids to price, e.g. types=34,35
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
currentPrices(types: Array<number>, locationId?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketPriceResponse>> {
|
|
return localVarFp.currentPrices(types, locationId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the open market orders across all characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllMarketOrders(options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketOrderResponse>> {
|
|
return localVarFp.findAllMarketOrders(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend for each requested market type
|
|
* @param {Array<number>} types Market type ids to analyze, e.g. types=34,35
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findAllQuartiles(types: Array<number>, days?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<HistoryQuartilesResponse>> {
|
|
return localVarFp.findAllQuartiles(types, days, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Find the market history of a type, most recent first
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to return; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findHistory(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketHistoryResponse>> {
|
|
return localVarFp.findHistory(marketTypeId, days, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend from a type\'s market history
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findQuartiles(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig): AxiosPromise<HistoryQuartilesResponse> {
|
|
return localVarFp.findQuartiles(marketTypeId, days, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Return the static market type details for each requested type id
|
|
* @param {Array<number>} ids Market type ids to look up, e.g. ids=34,35
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findTypes(ids: Array<number>, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketTypeResponse>> {
|
|
return localVarFp.findTypes(ids, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory listing into market type stacks, resolving names to type ids
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
parseStacks(body: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketTypeStackResponse>> {
|
|
return localVarFp.parseStacks(body, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory block (item name + quantity, tab/newline separated) and return the current valuation of each stack at the given market location (Jita by default)
|
|
* @param {string} body
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
pastePrices(body: string, locationId?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketTypeStackAppraisalResponse>> {
|
|
return localVarFp.pastePrices(body, locationId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan every tracked market type, returning volume-weighted price quartiles and the recent price trend for each
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
scanMarket(days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketScanResponse>> {
|
|
return localVarFp.scanMarket(days, brokerFee, salesTax, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Scan a single market type, returning its volume-weighted price quartiles and recent price trend
|
|
* @param {number} marketTypeId The market type id to scan
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
scanMarketType(marketTypeId: number, days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig): AxiosPromise<MarketScanResponse> {
|
|
return localVarFp.scanMarketType(marketTypeId, days, brokerFee, salesTax, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Search marketable types whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the type name, e.g. name=tritan
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
searchTypes(name: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<MarketTypeResponse>> {
|
|
return localVarFp.searchTypes(name, limit, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* MarketApi - object-oriented interface
|
|
*/
|
|
export class MarketApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Return the current order book (highest buy, lowest sell, order count) for each requested market type, priced at the given market location (Jita by default)
|
|
* @param {Array<number>} types Market type ids to price, e.g. types=34,35
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public currentPrices(types: Array<number>, locationId?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).currentPrices(types, locationId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary List the open market orders across all characters owned by the authenticated user
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findAllMarketOrders(options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).findAllMarketOrders(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend for each requested market type
|
|
* @param {Array<number>} types Market type ids to analyze, e.g. types=34,35
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findAllQuartiles(types: Array<number>, days?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).findAllQuartiles(types, days, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Find the market history of a type, most recent first
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to return; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findHistory(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).findHistory(marketTypeId, days, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Compute volume-weighted price quartiles and the recent price trend from a type\'s market history
|
|
* @param {number} marketTypeId Id of the market type
|
|
* @param {number} [days] Optional number of most recent days to analyze; omit for the full history
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findQuartiles(marketTypeId: number, days?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).findQuartiles(marketTypeId, days, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Return the static market type details for each requested type id
|
|
* @param {Array<number>} ids Market type ids to look up, e.g. ids=34,35
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findTypes(ids: Array<number>, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).findTypes(ids, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory listing into market type stacks, resolving names to type ids
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public parseStacks(body: string, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).parseStacks(body, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Parse a pasted EVE inventory block (item name + quantity, tab/newline separated) and return the current valuation of each stack at the given market location (Jita by default)
|
|
* @param {string} body
|
|
* @param {number} [locationId] Station or structure id of the market to price against; defaults to Jita when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public pastePrices(body: string, locationId?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).pastePrices(body, locationId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Scan every tracked market type, returning volume-weighted price quartiles and the recent price trend for each
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public scanMarket(days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).scanMarket(days, brokerFee, salesTax, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Scan a single market type, returning its volume-weighted price quartiles and recent price trend
|
|
* @param {number} marketTypeId The market type id to scan
|
|
* @param {number} [days] Number of most recent days of history to analyse
|
|
* @param {number} [brokerFee] Broker fee as a fraction (e.g. 0.015 for 1.5%), paid on both buy and sell orders
|
|
* @param {number} [salesTax] Sales tax as a fraction (e.g. 0.03375 for 3.375%), paid on sell orders
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public scanMarketType(marketTypeId: number, days?: number, brokerFee?: number, salesTax?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).scanMarketType(marketTypeId, days, brokerFee, salesTax, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Search marketable types whose name contains the given text, case-insensitively
|
|
* @param {string} name Text to match against the type name, e.g. name=tritan
|
|
* @param {number} [limit] Maximum number of results to return, defaults to 50
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public searchTypes(name: string, limit?: number, options?: RawAxiosRequestConfig) {
|
|
return MarketApiFp(this.configuration).searchTypes(name, limit, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* MarketHistoryAdminControllerApi - axios parameter creator
|
|
*/
|
|
export const MarketHistoryAdminControllerApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
refresh1: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/market/history/refresh`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* MarketHistoryAdminControllerApi - functional programming interface
|
|
*/
|
|
export const MarketHistoryAdminControllerApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = MarketHistoryAdminControllerApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async refresh1(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.refresh1(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['MarketHistoryAdminControllerApi.refresh1']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* MarketHistoryAdminControllerApi - factory interface
|
|
*/
|
|
export const MarketHistoryAdminControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = MarketHistoryAdminControllerApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
refresh1(options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
return localVarFp.refresh1(options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* MarketHistoryAdminControllerApi - object-oriented interface
|
|
*/
|
|
export class MarketHistoryAdminControllerApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public refresh1(options?: RawAxiosRequestConfig) {
|
|
return MarketHistoryAdminControllerApiFp(this.configuration).refresh1(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* ReprocessingApi - axios parameter creator
|
|
*/
|
|
export const ReprocessingApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Reprocess the given item stacks for a character, appraising the input and resulting materials
|
|
* @param {ReprocessItemsRequest} reprocessItemsRequest Character and item stacks to reprocess
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
reprocessItems: async (reprocessItemsRequest: ReprocessItemsRequest, locationId?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'reprocessItemsRequest' is not null or undefined
|
|
assertParamExists('reprocessItems', 'reprocessItemsRequest', reprocessItemsRequest)
|
|
const localVarPath = `/reprocessing`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (locationId !== undefined) {
|
|
localVarQueryParameter['locationId'] = locationId;
|
|
}
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(reprocessItemsRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Reprocess a pasted EVE inventory listing for a character, resolving item names before appraising the input and resulting materials
|
|
* @param {number} characterId Character to reprocess for
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
reprocessRawItems: async (characterId: number, body: string, locationId?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'characterId' is not null or undefined
|
|
assertParamExists('reprocessRawItems', 'characterId', characterId)
|
|
// verify required parameter 'body' is not null or undefined
|
|
assertParamExists('reprocessRawItems', 'body', body)
|
|
const localVarPath = `/reprocessing/paste`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
if (characterId !== undefined) {
|
|
localVarQueryParameter['characterId'] = characterId;
|
|
}
|
|
|
|
if (locationId !== undefined) {
|
|
localVarQueryParameter['locationId'] = locationId;
|
|
}
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'text/plain';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* ReprocessingApi - functional programming interface
|
|
*/
|
|
export const ReprocessingApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = ReprocessingApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Reprocess the given item stacks for a character, appraising the input and resulting materials
|
|
* @param {ReprocessItemsRequest} reprocessItemsRequest Character and item stacks to reprocess
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async reprocessItems(reprocessItemsRequest: ReprocessItemsRequest, locationId?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ReprocessingResultResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.reprocessItems(reprocessItemsRequest, locationId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ReprocessingApi.reprocessItems']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Reprocess a pasted EVE inventory listing for a character, resolving item names before appraising the input and resulting materials
|
|
* @param {number} characterId Character to reprocess for
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async reprocessRawItems(characterId: number, body: string, locationId?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ReprocessingResultResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.reprocessRawItems(characterId, body, locationId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['ReprocessingApi.reprocessRawItems']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* ReprocessingApi - factory interface
|
|
*/
|
|
export const ReprocessingApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = ReprocessingApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Reprocess the given item stacks for a character, appraising the input and resulting materials
|
|
* @param {ReprocessItemsRequest} reprocessItemsRequest Character and item stacks to reprocess
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
reprocessItems(reprocessItemsRequest: ReprocessItemsRequest, locationId?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<ReprocessingResultResponse>> {
|
|
return localVarFp.reprocessItems(reprocessItemsRequest, locationId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Reprocess a pasted EVE inventory listing for a character, resolving item names before appraising the input and resulting materials
|
|
* @param {number} characterId Character to reprocess for
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
reprocessRawItems(characterId: number, body: string, locationId?: number, options?: RawAxiosRequestConfig): AxiosPromise<Array<ReprocessingResultResponse>> {
|
|
return localVarFp.reprocessRawItems(characterId, body, locationId, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* ReprocessingApi - object-oriented interface
|
|
*/
|
|
export class ReprocessingApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Reprocess the given item stacks for a character, appraising the input and resulting materials
|
|
* @param {ReprocessItemsRequest} reprocessItemsRequest Character and item stacks to reprocess
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public reprocessItems(reprocessItemsRequest: ReprocessItemsRequest, locationId?: number, options?: RawAxiosRequestConfig) {
|
|
return ReprocessingApiFp(this.configuration).reprocessItems(reprocessItemsRequest, locationId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Reprocess a pasted EVE inventory listing for a character, resolving item names before appraising the input and resulting materials
|
|
* @param {number} characterId Character to reprocess for
|
|
* @param {string} body Raw tab-separated inventory listing copied from the EVE client
|
|
* @param {number} [locationId] Location to derive reprocessing efficiency at; defaults to the character\'s current location when omitted
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public reprocessRawItems(characterId: number, body: string, locationId?: number, options?: RawAxiosRequestConfig) {
|
|
return ReprocessingApiFp(this.configuration).reprocessRawItems(characterId, body, locationId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* RuleBookApi - axios parameter creator
|
|
*/
|
|
export const RuleBookApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findRuleBook: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/rule-book`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update the caller\'s rule book
|
|
* @param {UpdateRuleBookRequest} updateRuleBookRequest New state of the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateRuleBook: async (updateRuleBookRequest: UpdateRuleBookRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'updateRuleBookRequest' is not null or undefined
|
|
assertParamExists('updateRuleBook', 'updateRuleBookRequest', updateRuleBookRequest)
|
|
const localVarPath = `/rule-book`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
localVarRequestOptions.data = serializeDataIfNeeded(updateRuleBookRequest, localVarRequestOptions, configuration)
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* RuleBookApi - functional programming interface
|
|
*/
|
|
export const RuleBookApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = RuleBookApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async findRuleBook(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.findRuleBook(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['RuleBookApi.findRuleBook']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update the caller\'s rule book
|
|
* @param {UpdateRuleBookRequest} updateRuleBookRequest New state of the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async updateRuleBook(updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.updateRuleBook(updateRuleBookRequest, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['RuleBookApi.updateRuleBook']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* RuleBookApi - factory interface
|
|
*/
|
|
export const RuleBookApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = RuleBookApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
findRuleBook(options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
|
|
return localVarFp.findRuleBook(options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Update the caller\'s rule book
|
|
* @param {UpdateRuleBookRequest} updateRuleBookRequest New state of the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
updateRuleBook(updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
|
|
return localVarFp.updateRuleBook(updateRuleBookRequest, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* RuleBookApi - object-oriented interface
|
|
*/
|
|
export class RuleBookApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Find the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public findRuleBook(options?: RawAxiosRequestConfig) {
|
|
return RuleBookApiFp(this.configuration).findRuleBook(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Update the caller\'s rule book
|
|
* @param {UpdateRuleBookRequest} updateRuleBookRequest New state of the caller\'s rule book
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public updateRuleBook(updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig) {
|
|
return RuleBookApiFp(this.configuration).updateRuleBook(updateRuleBookRequest, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* RuleScriptApi - axios parameter creator
|
|
*/
|
|
export const RuleScriptApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Download a rule script type definition file by name
|
|
* @param {string} name
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
getScriptDefinition: async (name: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'name' is not null or undefined
|
|
assertParamExists('getScriptDefinition', 'name', name)
|
|
const localVarPath = `/rule-scripts/definitions/{name}`
|
|
.replace('{name}', encodeURIComponent(String(name)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = 'text/plain';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the available rule script type definition files
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
listScriptDefinitions: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
const localVarPath = `/rule-scripts/definitions`;
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* RuleScriptApi - functional programming interface
|
|
*/
|
|
export const RuleScriptApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = RuleScriptApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Download a rule script type definition file by name
|
|
* @param {string} name
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async getScriptDefinition(name: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.getScriptDefinition(name, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['RuleScriptApi.getScriptDefinition']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the available rule script type definition files
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async listScriptDefinitions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<string>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.listScriptDefinitions(options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['RuleScriptApi.listScriptDefinitions']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* RuleScriptApi - factory interface
|
|
*/
|
|
export const RuleScriptApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = RuleScriptApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Download a rule script type definition file by name
|
|
* @param {string} name
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
getScriptDefinition(name: string, options?: RawAxiosRequestConfig): AxiosPromise<string> {
|
|
return localVarFp.getScriptDefinition(name, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary List the available rule script type definition files
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
listScriptDefinitions(options?: RawAxiosRequestConfig): AxiosPromise<Array<string>> {
|
|
return localVarFp.listScriptDefinitions(options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* RuleScriptApi - object-oriented interface
|
|
*/
|
|
export class RuleScriptApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Download a rule script type definition file by name
|
|
* @param {string} name
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public getScriptDefinition(name: string, options?: RawAxiosRequestConfig) {
|
|
return RuleScriptApiFp(this.configuration).getScriptDefinition(name, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary List the available rule script type definition files
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public listScriptDefinitions(options?: RawAxiosRequestConfig) {
|
|
return RuleScriptApiFp(this.configuration).listScriptDefinitions(options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* TransactionApi - axios parameter creator
|
|
*/
|
|
export const TransactionApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find all transactions in a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
finAllTransactionsInLedger: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('finAllTransactionsInLedger', 'ledgerId', ledgerId)
|
|
const localVarPath = `/ledgers/{ledgerId}/transactions`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily FIFO-realized profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
marginPerDayInLedger: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('marginPerDayInLedger', 'ledgerId', ledgerId)
|
|
const localVarPath = `/ledgers/{ledgerId}/margin`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
profitPerDayInLedger: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
// verify required parameter 'ledgerId' is not null or undefined
|
|
assertParamExists('profitPerDayInLedger', 'ledgerId', ledgerId)
|
|
const localVarPath = `/ledgers/{ledgerId}/profit`
|
|
.replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
|
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
let baseOptions;
|
|
if (configuration) {
|
|
baseOptions = configuration.baseOptions;
|
|
}
|
|
|
|
const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
|
|
const localVarHeaderParameter = {} as any;
|
|
const localVarQueryParameter = {} as any;
|
|
|
|
localVarHeaderParameter['Accept'] = '*/*';
|
|
|
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
|
|
return {
|
|
url: toPathString(localVarUrlObj),
|
|
options: localVarRequestOptions,
|
|
};
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* TransactionApi - functional programming interface
|
|
*/
|
|
export const TransactionApiFp = function(configuration?: Configuration) {
|
|
const localVarAxiosParamCreator = TransactionApiAxiosParamCreator(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find all transactions in a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async finAllTransactionsInLedger(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<TransactionResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.finAllTransactionsInLedger(ledgerId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['TransactionApi.finAllTransactionsInLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily FIFO-realized profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async marginPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DailyProfitResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.marginPerDayInLedger(ledgerId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['TransactionApi.marginPerDayInLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
async profitPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DailyProfitResponse>>> {
|
|
const localVarAxiosArgs = await localVarAxiosParamCreator.profitPerDayInLedger(ledgerId, options);
|
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
const localVarOperationServerBasePath = operationServerMap['TransactionApi.profitPerDayInLedger']?.[localVarOperationServerIndex]?.url;
|
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
},
|
|
}
|
|
};
|
|
|
|
/**
|
|
* TransactionApi - factory interface
|
|
*/
|
|
export const TransactionApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
|
|
const localVarFp = TransactionApiFp(configuration)
|
|
return {
|
|
/**
|
|
*
|
|
* @summary Find all transactions in a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
finAllTransactionsInLedger(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<TransactionResponse>> {
|
|
return localVarFp.finAllTransactionsInLedger(ledgerId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily FIFO-realized profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
marginPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<DailyProfitResponse>> {
|
|
return localVarFp.marginPerDayInLedger(ledgerId, options).then((request) => request(axios, basePath));
|
|
},
|
|
/**
|
|
*
|
|
* @summary Get the daily profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
profitPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<DailyProfitResponse>> {
|
|
return localVarFp.profitPerDayInLedger(ledgerId, options).then((request) => request(axios, basePath));
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* TransactionApi - object-oriented interface
|
|
*/
|
|
export class TransactionApi extends BaseAPI {
|
|
/**
|
|
*
|
|
* @summary Find all transactions in a ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public finAllTransactionsInLedger(ledgerId: string, options?: RawAxiosRequestConfig) {
|
|
return TransactionApiFp(this.configuration).finAllTransactionsInLedger(ledgerId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Get the daily FIFO-realized profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public marginPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig) {
|
|
return TransactionApiFp(this.configuration).marginPerDayInLedger(ledgerId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @summary Get the daily profit series for a single ledger
|
|
* @param {string} ledgerId Id of the ledger
|
|
* @param {*} [options] Override http request option.
|
|
* @throws {RequiredError}
|
|
*/
|
|
public profitPerDayInLedger(ledgerId: string, options?: RawAxiosRequestConfig) {
|
|
return TransactionApiFp(this.configuration).profitPerDayInLedger(ledgerId, options).then((request) => request(this.axios, this.basePath));
|
|
}
|
|
}
|
|
|
|
|
|
|