/* 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';

export interface CharacterResponse {
    'characterId': number;
    'name': string;
}
export interface CombinedLedgerResponse extends LedgerResponse {
    'ledgerId': string;
    'name': string;
    'balance': number;
    'memberLedgerIds': Array<string>;
    'type'?: CombinedLedgerResponseTypeEnum;
}

export const CombinedLedgerResponseTypeEnum = {
    Combined: 'COMBINED',
} as const;

export type CombinedLedgerResponseTypeEnum = typeof CombinedLedgerResponseTypeEnum[keyof typeof CombinedLedgerResponseTypeEnum];

export interface CreateCombinedLedgerRequest {
    'name': string;
    'memberLedgerIds': Array<string>;
}
export interface CreateMainLedgerRequest {
    'name': string;
}
export interface CreateRuleBookRequest {
    'name': string;
    'ledgerRefs': Array<string>;
    'rules': { [key: string]: RuleResponse; };
}
/**
 * @type FindAllLedgers200ResponseInner
 */
export type FindAllLedgers200ResponseInner = CombinedLedgerResponse | MainLedgerResponse;

export interface LedgerResponse {
    'type'?: LedgerResponseTypeEnum;
}

export const LedgerResponseTypeEnum = {
    Main: 'MAIN',
    Combined: 'COMBINED',
} as const;

export type LedgerResponseTypeEnum = typeof LedgerResponseTypeEnum[keyof typeof LedgerResponseTypeEnum];

export interface MainLedgerResponse extends LedgerResponse {
    'ledgerId': string;
    'name': string;
    'balance': number;
    'type'?: MainLedgerResponseTypeEnum;
}

export const MainLedgerResponseTypeEnum = {
    Main: 'MAIN',
} as const;

export type MainLedgerResponseTypeEnum = typeof MainLedgerResponseTypeEnum[keyof typeof MainLedgerResponseTypeEnum];

export interface RuleBookResponse {
    'ruleBookId': string;
    'name': string;
    'ledgerRefs': Array<string>;
    'rules': { [key: string]: RuleResponse; };
}
export interface RuleClauseResponse {
    'rate': RuleClauseResponseRateEnum;
    'fromLedgerRef': string;
    'toLedgerRef': string;
}

export const RuleClauseResponseRateEnum = {
    None: 'NONE',
    Value: 'VALUE',
    JitaBuy: 'JITA_BUY',
    JitaSell: 'JITA_SELL',
    EveEstimate: 'EVE_ESTIMATE',
} as const;

export type RuleClauseResponseRateEnum = typeof RuleClauseResponseRateEnum[keyof typeof RuleClauseResponseRateEnum];

export interface RuleResponse {
    'rules': Array<RuleClauseResponse>;
}
export interface UpdateCombinedLedgerRequest {
    'name': string;
    'memberLedgerIds': Array<string>;
}
export interface UpdateMainLedgerRequest {
    'name': string;
}
export interface UpdateRuleBookRequest {
    'name': string;
    'ledgerRefs': Array<string>;
    'rules': { [key: string]: RuleResponse; };
}

/**
 * ActivityControllerApi - axios parameter creator
 */
export const ActivityControllerApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * 
         * @param {number} characterId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        fetchNewActivitiesForCharacter: async (characterId: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'characterId' is not null or undefined
            assertParamExists('fetchNewActivitiesForCharacter', 'characterId', characterId)
            const localVarPath = `/activity/fetch/{characterId}`
                .replace('{characterId}', encodeURIComponent(String(characterId)));
            // 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,
            };
        },
    }
};

/**
 * ActivityControllerApi - functional programming interface
 */
export const ActivityControllerApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = ActivityControllerApiAxiosParamCreator(configuration)
    return {
        /**
         * 
         * @param {number} characterId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.fetchNewActivitiesForCharacter(characterId, options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['ActivityControllerApi.fetchNewActivitiesForCharacter']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * ActivityControllerApi - factory interface
 */
export const ActivityControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = ActivityControllerApiFp(configuration)
    return {
        /**
         * 
         * @param {number} characterId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig): AxiosPromise<void> {
            return localVarFp.fetchNewActivitiesForCharacter(characterId, options).then((request) => request(axios, basePath));
        },
    };
};

/**
 * ActivityControllerApi - object-oriented interface
 */
export class ActivityControllerApi extends BaseAPI {
    /**
     * 
     * @param {number} characterId 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig) {
        return ActivityControllerApiFp(this.configuration).fetchNewActivitiesForCharacter(characterId, options).then((request) => request(this.axios, this.basePath));
    }
}



/**
 * CharacterControllerApi - axios parameter creator
 */
export const CharacterControllerApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * 
         * @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,
            };
        },
    }
};

/**
 * CharacterControllerApi - functional programming interface
 */
export const CharacterControllerApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = CharacterControllerApiAxiosParamCreator(configuration)
    return {
        /**
         * 
         * @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['CharacterControllerApi.findAllCharacters']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * CharacterControllerApi - factory interface
 */
export const CharacterControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = CharacterControllerApiFp(configuration)
    return {
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findAllCharacters(options?: RawAxiosRequestConfig): AxiosPromise<Array<CharacterResponse>> {
            return localVarFp.findAllCharacters(options).then((request) => request(axios, basePath));
        },
    };
};

/**
 * CharacterControllerApi - object-oriented interface
 */
export class CharacterControllerApi extends BaseAPI {
    /**
     * 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public findAllCharacters(options?: RawAxiosRequestConfig) {
        return CharacterControllerApiFp(this.configuration).findAllCharacters(options).then((request) => request(this.axios, this.basePath));
    }
}



/**
 * LedgerControllerApi - axios parameter creator
 */
export const LedgerControllerApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * 
         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
         * @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,
            };
        },
        /**
         * 
         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
         * @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,
            };
        },
        /**
         * 
         * @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,
            };
        },
        /**
         * 
         * @param {string} ledgerId 
         * @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,
            };
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
         * @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,
            };
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
         * @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,
            };
        },
    }
};

/**
 * LedgerControllerApi - functional programming interface
 */
export const LedgerControllerApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = LedgerControllerApiAxiosParamCreator(configuration)
    return {
        /**
         * 
         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
         * @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['LedgerControllerApi.createCombinedLedger']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
         * @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['LedgerControllerApi.createMainLedger']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async findAllLedgers(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<FindAllLedgers200ResponseInner>>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.findAllLedgers(options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.findAllLedgers']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FindAllLedgers200ResponseInner>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.findLedgerById(ledgerId, options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.findLedgerById']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
         * @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['LedgerControllerApi.updateCombinedLedger']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
         * @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['LedgerControllerApi.updateMainLedger']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * LedgerControllerApi - factory interface
 */
export const LedgerControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = LedgerControllerApiFp(configuration)
    return {
        /**
         * 
         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
         * @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));
        },
        /**
         * 
         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
         * @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));
        },
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findAllLedgers(options?: RawAxiosRequestConfig): AxiosPromise<Array<FindAllLedgers200ResponseInner>> {
            return localVarFp.findAllLedgers(options).then((request) => request(axios, basePath));
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<FindAllLedgers200ResponseInner> {
            return localVarFp.findLedgerById(ledgerId, options).then((request) => request(axios, basePath));
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
         * @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));
        },
        /**
         * 
         * @param {string} ledgerId 
         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
         * @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));
        },
    };
};

/**
 * LedgerControllerApi - object-oriented interface
 */
export class LedgerControllerApi extends BaseAPI {
    /**
     * 
     * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).createCombinedLedger(createCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {CreateMainLedgerRequest} createMainLedgerRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).createMainLedger(createMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public findAllLedgers(options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).findAllLedgers(options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {string} ledgerId 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public findLedgerById(ledgerId: string, options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).findLedgerById(ledgerId, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {string} ledgerId 
     * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {string} ledgerId 
     * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig) {
        return LedgerControllerApiFp(this.configuration).updateMainLedger(ledgerId, updateMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
    }
}



/**
 * ProcessingControllerApi - axios parameter creator
 */
export const ProcessingControllerApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        processNewActivities: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            const localVarPath = `/process-activities`;
            // 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,
            };
        },
    }
};

/**
 * ProcessingControllerApi - functional programming interface
 */
export const ProcessingControllerApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = ProcessingControllerApiAxiosParamCreator(configuration)
    return {
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async processNewActivities(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.processNewActivities(options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['ProcessingControllerApi.processNewActivities']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * ProcessingControllerApi - factory interface
 */
export const ProcessingControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = ProcessingControllerApiFp(configuration)
    return {
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        processNewActivities(options?: RawAxiosRequestConfig): AxiosPromise<void> {
            return localVarFp.processNewActivities(options).then((request) => request(axios, basePath));
        },
    };
};

/**
 * ProcessingControllerApi - object-oriented interface
 */
export class ProcessingControllerApi extends BaseAPI {
    /**
     * 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public processNewActivities(options?: RawAxiosRequestConfig) {
        return ProcessingControllerApiFp(this.configuration).processNewActivities(options).then((request) => request(this.axios, this.basePath));
    }
}



/**
 * RuleBookControllerApi - axios parameter creator
 */
export const RuleBookControllerApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * 
         * @param {CreateRuleBookRequest} createRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        createRuleBook: async (createRuleBookRequest: CreateRuleBookRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'createRuleBookRequest' is not null or undefined
            assertParamExists('createRuleBook', 'createRuleBookRequest', createRuleBookRequest)
            const localVarPath = `/rule-books`;
            // 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(createRuleBookRequest, localVarRequestOptions, configuration)

            return {
                url: toPathString(localVarUrlObj),
                options: localVarRequestOptions,
            };
        },
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findAllRuleBooks: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            const localVarPath = `/rule-books`;
            // 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,
            };
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findRuleBookById: async (ruleBookId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'ruleBookId' is not null or undefined
            assertParamExists('findRuleBookById', 'ruleBookId', ruleBookId)
            const localVarPath = `/rule-books/{ruleBookId}`
                .replace('{ruleBookId}', encodeURIComponent(String(ruleBookId)));
            // 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,
            };
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {UpdateRuleBookRequest} updateRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        updateRuleBook: async (ruleBookId: string, updateRuleBookRequest: UpdateRuleBookRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'ruleBookId' is not null or undefined
            assertParamExists('updateRuleBook', 'ruleBookId', ruleBookId)
            // verify required parameter 'updateRuleBookRequest' is not null or undefined
            assertParamExists('updateRuleBook', 'updateRuleBookRequest', updateRuleBookRequest)
            const localVarPath = `/rule-books/{ruleBookId}`
                .replace('{ruleBookId}', encodeURIComponent(String(ruleBookId)));
            // 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,
            };
        },
    }
};

/**
 * RuleBookControllerApi - functional programming interface
 */
export const RuleBookControllerApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = RuleBookControllerApiAxiosParamCreator(configuration)
    return {
        /**
         * 
         * @param {CreateRuleBookRequest} createRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async createRuleBook(createRuleBookRequest: CreateRuleBookRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.createRuleBook(createRuleBookRequest, options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.createRuleBook']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async findAllRuleBooks(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<RuleBookResponse>>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.findAllRuleBooks(options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.findAllRuleBooks']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async findRuleBookById(ruleBookId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.findRuleBookById(ruleBookId, options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.findRuleBookById']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {UpdateRuleBookRequest} updateRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        async updateRuleBook(ruleBookId: string, updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.updateRuleBook(ruleBookId, updateRuleBookRequest, options);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.updateRuleBook']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * RuleBookControllerApi - factory interface
 */
export const RuleBookControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = RuleBookControllerApiFp(configuration)
    return {
        /**
         * 
         * @param {CreateRuleBookRequest} createRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        createRuleBook(createRuleBookRequest: CreateRuleBookRequest, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
            return localVarFp.createRuleBook(createRuleBookRequest, options).then((request) => request(axios, basePath));
        },
        /**
         * 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findAllRuleBooks(options?: RawAxiosRequestConfig): AxiosPromise<Array<RuleBookResponse>> {
            return localVarFp.findAllRuleBooks(options).then((request) => request(axios, basePath));
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        findRuleBookById(ruleBookId: string, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
            return localVarFp.findRuleBookById(ruleBookId, options).then((request) => request(axios, basePath));
        },
        /**
         * 
         * @param {string} ruleBookId 
         * @param {UpdateRuleBookRequest} updateRuleBookRequest 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
        updateRuleBook(ruleBookId: string, updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
            return localVarFp.updateRuleBook(ruleBookId, updateRuleBookRequest, options).then((request) => request(axios, basePath));
        },
    };
};

/**
 * RuleBookControllerApi - object-oriented interface
 */
export class RuleBookControllerApi extends BaseAPI {
    /**
     * 
     * @param {CreateRuleBookRequest} createRuleBookRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public createRuleBook(createRuleBookRequest: CreateRuleBookRequest, options?: RawAxiosRequestConfig) {
        return RuleBookControllerApiFp(this.configuration).createRuleBook(createRuleBookRequest, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public findAllRuleBooks(options?: RawAxiosRequestConfig) {
        return RuleBookControllerApiFp(this.configuration).findAllRuleBooks(options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {string} ruleBookId 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public findRuleBookById(ruleBookId: string, options?: RawAxiosRequestConfig) {
        return RuleBookControllerApiFp(this.configuration).findRuleBookById(ruleBookId, options).then((request) => request(this.axios, this.basePath));
    }

    /**
     * 
     * @param {string} ruleBookId 
     * @param {UpdateRuleBookRequest} updateRuleBookRequest 
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    public updateRuleBook(ruleBookId: string, updateRuleBookRequest: UpdateRuleBookRequest, options?: RawAxiosRequestConfig) {
        return RuleBookControllerApiFp(this.configuration).updateRuleBook(ruleBookId, updateRuleBookRequest, options).then((request) => request(this.axios, this.basePath));
    }
}