/* 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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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&#x3D;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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\&#39;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));
    }
}