/* tslint:disable */
// @ts-nocheck
/* eslint-disable */
/**
 * Audius API
 *
 * The version of the OpenAPI document: 1.0
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import type {
  ClaimRewardsResponse,
  CoinInsightsResponse,
  CoinMembersCountResponse,
  CoinMembersResponse,
  CoinResponse,
  CoinsResponse,
  CoinsVolumeLeadersResponse,
  CreateCoinRequest,
  CreateCoinResponse,
  RedeemAmountResponse,
  RewardCodeErrorResponse,
  RewardCodeResponse,
  UpdateCoinRequest,
  UpdateCoinResponse,
} from '../models';
import {
    ClaimRewardsResponseFromJSON,
    ClaimRewardsResponseToJSON,
    CoinInsightsResponseFromJSON,
    CoinInsightsResponseToJSON,
    CoinMembersCountResponseFromJSON,
    CoinMembersCountResponseToJSON,
    CoinMembersResponseFromJSON,
    CoinMembersResponseToJSON,
    CoinResponseFromJSON,
    CoinResponseToJSON,
    CoinsResponseFromJSON,
    CoinsResponseToJSON,
    CoinsVolumeLeadersResponseFromJSON,
    CoinsVolumeLeadersResponseToJSON,
    CreateCoinRequestFromJSON,
    CreateCoinRequestToJSON,
    CreateCoinResponseFromJSON,
    CreateCoinResponseToJSON,
    RedeemAmountResponseFromJSON,
    RedeemAmountResponseToJSON,
    RewardCodeErrorResponseFromJSON,
    RewardCodeErrorResponseToJSON,
    RewardCodeResponseFromJSON,
    RewardCodeResponseToJSON,
    UpdateCoinRequestFromJSON,
    UpdateCoinRequestToJSON,
    UpdateCoinResponseFromJSON,
    UpdateCoinResponseToJSON,
} from '../models';

export interface ClaimCoinRewardRequest {
    mint: string;
    userId: string;
}

export interface ClaimCoinRewardCodeRequest {
    mint: string;
    code: string;
    userId: string;
}

export interface CreateCoinOperationRequest {
    userId: string;
    createCoinRequest: CreateCoinRequest;
}

export interface GetCoinRequest {
    mint: string;
}

export interface GetCoinByTickerRequest {
    ticker: string;
}

export interface GetCoinInsightsRequest {
    mint: string;
}

export interface GetCoinMembersRequest {
    mint: string;
    offset?: number;
    limit?: number;
    sortDirection?: GetCoinMembersSortDirectionEnum;
}

export interface GetCoinMembersCountRequest {
    mint: string;
}

export interface GetCoinRedeemAmountRequest {
    mint: string;
}

export interface GetCoinsRequest {
    ticker?: Array<string>;
    mint?: Array<string>;
    ownerId?: Array<string>;
    limit?: number;
    offset?: number;
    query?: string;
    sortMethod?: GetCoinsSortMethodEnum;
    sortDirection?: GetCoinsSortDirectionEnum;
}

export interface GetRewardCodeRequest {
    mint: string;
    code: string;
}

export interface GetVolumeLeadersRequest {
    from?: string;
    to?: string;
    offset?: number;
    limit?: number;
}

export interface UpdateCoinOperationRequest {
    mint: string;
    userId: string;
    updateCoinRequest: UpdateCoinRequest;
}

/**
 * 
 */
export class CoinsApi extends runtime.BaseAPI {

    /**
     * @hidden
     * Claims a coin reward for a given mint
     */
    async claimCoinRewardRaw(params: ClaimCoinRewardRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClaimRewardsResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling claimCoinReward.');
        }

        if (params.userId === null || params.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter params.userId was null or undefined when calling claimCoinReward.');
        }

        const queryParameters: any = {};

        if (params.userId !== undefined) {
            queryParameters['user_id'] = params.userId;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/redeem`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ClaimRewardsResponseFromJSON(jsonValue));
    }

    /**
     * Claims a coin reward for a given mint
     */
    async claimCoinReward(params: ClaimCoinRewardRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClaimRewardsResponse> {
        const response = await this.claimCoinRewardRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Claims a coin reward using a given code
     */
    async claimCoinRewardCodeRaw(params: ClaimCoinRewardCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClaimRewardsResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling claimCoinRewardCode.');
        }

        if (params.code === null || params.code === undefined) {
            throw new runtime.RequiredError('code','Required parameter params.code was null or undefined when calling claimCoinRewardCode.');
        }

        if (params.userId === null || params.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter params.userId was null or undefined when calling claimCoinRewardCode.');
        }

        const queryParameters: any = {};

        if (params.userId !== undefined) {
            queryParameters['user_id'] = params.userId;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/redeem/{code}`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))).replace(`{${"code"}}`, encodeURIComponent(String(params.code))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ClaimRewardsResponseFromJSON(jsonValue));
    }

    /**
     * Claims a coin reward using a given code
     */
    async claimCoinRewardCode(params: ClaimCoinRewardCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClaimRewardsResponse> {
        const response = await this.claimCoinRewardCodeRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Creates a new artist coin
     */
    async createCoinRaw(params: CreateCoinOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateCoinResponse>> {
        if (params.userId === null || params.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter params.userId was null or undefined when calling createCoin.');
        }

        if (params.createCoinRequest === null || params.createCoinRequest === undefined) {
            throw new runtime.RequiredError('createCoinRequest','Required parameter params.createCoinRequest was null or undefined when calling createCoin.');
        }

        const queryParameters: any = {};

        if (params.userId !== undefined) {
            queryParameters['user_id'] = params.userId;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/coins`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateCoinRequestToJSON(params.createCoinRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CreateCoinResponseFromJSON(jsonValue));
    }

    /**
     * Creates a new artist coin
     */
    async createCoin(params: CreateCoinOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateCoinResponse> {
        const response = await this.createCoinRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets information about a specific coin by its mint address
     */
    async getCoinRaw(params: GetCoinRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getCoin.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinResponseFromJSON(jsonValue));
    }

    /**
     * Gets information about a specific coin by its mint address
     */
    async getCoin(params: GetCoinRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinResponse> {
        const response = await this.getCoinRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets information about a specific coin by its ticker
     */
    async getCoinByTickerRaw(params: GetCoinByTickerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinResponse>> {
        if (params.ticker === null || params.ticker === undefined) {
            throw new runtime.RequiredError('ticker','Required parameter params.ticker was null or undefined when calling getCoinByTicker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/ticker/{ticker}`.replace(`{${"ticker"}}`, encodeURIComponent(String(params.ticker))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinResponseFromJSON(jsonValue));
    }

    /**
     * Gets information about a specific coin by its ticker
     */
    async getCoinByTicker(params: GetCoinByTickerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinResponse> {
        const response = await this.getCoinByTickerRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets insights about a specific coin by its mint address
     */
    async getCoinInsightsRaw(params: GetCoinInsightsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinInsightsResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getCoinInsights.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/insights`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinInsightsResponseFromJSON(jsonValue));
    }

    /**
     * Gets insights about a specific coin by its mint address
     */
    async getCoinInsights(params: GetCoinInsightsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinInsightsResponse> {
        const response = await this.getCoinInsightsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of Audius users with a non-zero balance of a specific coin
     */
    async getCoinMembersRaw(params: GetCoinMembersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinMembersResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getCoinMembers.');
        }

        const queryParameters: any = {};

        if (params.offset !== undefined) {
            queryParameters['offset'] = params.offset;
        }

        if (params.limit !== undefined) {
            queryParameters['limit'] = params.limit;
        }

        if (params.sortDirection !== undefined) {
            queryParameters['sort_direction'] = params.sortDirection;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/members`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinMembersResponseFromJSON(jsonValue));
    }

    /**
     * Gets a list of Audius users with a non-zero balance of a specific coin
     */
    async getCoinMembers(params: GetCoinMembersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinMembersResponse> {
        const response = await this.getCoinMembersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the total number of Audius users with a non-zero balance of a specific coin
     */
    async getCoinMembersCountRaw(params: GetCoinMembersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinMembersCountResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getCoinMembersCount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/members/count`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinMembersCountResponseFromJSON(jsonValue));
    }

    /**
     * Gets the total number of Audius users with a non-zero balance of a specific coin
     */
    async getCoinMembersCount(params: GetCoinMembersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinMembersCountResponse> {
        const response = await this.getCoinMembersCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the availability indicator for reward codes for a specific coin
     */
    async getCoinRedeemAmountRaw(params: GetCoinRedeemAmountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedeemAmountResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getCoinRedeemAmount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/redeem`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RedeemAmountResponseFromJSON(jsonValue));
    }

    /**
     * Gets the availability indicator for reward codes for a specific coin
     */
    async getCoinRedeemAmount(params: GetCoinRedeemAmountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedeemAmountResponse> {
        const response = await this.getCoinRedeemAmountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of coins with optional filtering
     */
    async getCoinsRaw(params: GetCoinsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinsResponse>> {
        const queryParameters: any = {};

        if (params.ticker) {
            queryParameters['ticker'] = params.ticker;
        }

        if (params.mint) {
            queryParameters['mint'] = params.mint;
        }

        if (params.ownerId) {
            queryParameters['owner_id'] = params.ownerId;
        }

        if (params.limit !== undefined) {
            queryParameters['limit'] = params.limit;
        }

        if (params.offset !== undefined) {
            queryParameters['offset'] = params.offset;
        }

        if (params.query !== undefined) {
            queryParameters['query'] = params.query;
        }

        if (params.sortMethod !== undefined) {
            queryParameters['sort_method'] = params.sortMethod;
        }

        if (params.sortDirection !== undefined) {
            queryParameters['sort_direction'] = params.sortDirection;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinsResponseFromJSON(jsonValue));
    }

    /**
     * Gets a list of coins with optional filtering
     */
    async getCoins(params: GetCoinsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinsResponse> {
        const response = await this.getCoinsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets information about a specific reward code for a coin
     */
    async getRewardCodeRaw(params: GetRewardCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RewardCodeResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling getRewardCode.');
        }

        if (params.code === null || params.code === undefined) {
            throw new runtime.RequiredError('code','Required parameter params.code was null or undefined when calling getRewardCode.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/{mint}/redeem/{code}`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))).replace(`{${"code"}}`, encodeURIComponent(String(params.code))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RewardCodeResponseFromJSON(jsonValue));
    }

    /**
     * Gets information about a specific reward code for a coin
     */
    async getRewardCode(params: GetRewardCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RewardCodeResponse> {
        const response = await this.getRewardCodeRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets top coin<>AUDIO trading addresses by volume
     */
    async getVolumeLeadersRaw(params: GetVolumeLeadersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CoinsVolumeLeadersResponse>> {
        const queryParameters: any = {};

        if (params.from !== undefined) {
            queryParameters['from'] = params.from;
        }

        if (params.to !== undefined) {
            queryParameters['to'] = params.to;
        }

        if (params.offset !== undefined) {
            queryParameters['offset'] = params.offset;
        }

        if (params.limit !== undefined) {
            queryParameters['limit'] = params.limit;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/coins/volume-leaders`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CoinsVolumeLeadersResponseFromJSON(jsonValue));
    }

    /**
     * Gets top coin<>AUDIO trading addresses by volume
     */
    async getVolumeLeaders(params: GetVolumeLeadersRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CoinsVolumeLeadersResponse> {
        const response = await this.getVolumeLeadersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Updates information about a specific coin by its mint address
     */
    async updateCoinRaw(params: UpdateCoinOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UpdateCoinResponse>> {
        if (params.mint === null || params.mint === undefined) {
            throw new runtime.RequiredError('mint','Required parameter params.mint was null or undefined when calling updateCoin.');
        }

        if (params.userId === null || params.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter params.userId was null or undefined when calling updateCoin.');
        }

        if (params.updateCoinRequest === null || params.updateCoinRequest === undefined) {
            throw new runtime.RequiredError('updateCoinRequest','Required parameter params.updateCoinRequest was null or undefined when calling updateCoin.');
        }

        const queryParameters: any = {};

        if (params.userId !== undefined) {
            queryParameters['user_id'] = params.userId;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/coins/{mint}`.replace(`{${"mint"}}`, encodeURIComponent(String(params.mint))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateCoinRequestToJSON(params.updateCoinRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UpdateCoinResponseFromJSON(jsonValue));
    }

    /**
     * Updates information about a specific coin by its mint address
     */
    async updateCoin(params: UpdateCoinOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UpdateCoinResponse> {
        const response = await this.updateCoinRaw(params, initOverrides);
        return await response.value();
    }

}

/**
 * @export
 */
export const GetCoinMembersSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetCoinMembersSortDirectionEnum = typeof GetCoinMembersSortDirectionEnum[keyof typeof GetCoinMembersSortDirectionEnum];
/**
 * @export
 */
export const GetCoinsSortMethodEnum = {
    MarketCap: 'market_cap',
    Price: 'price',
    Volume: 'volume',
    CreatedAt: 'created_at',
    Holder: 'holder'
} as const;
export type GetCoinsSortMethodEnum = typeof GetCoinsSortMethodEnum[keyof typeof GetCoinsSortMethodEnum];
/**
 * @export
 */
export const GetCoinsSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetCoinsSortDirectionEnum = typeof GetCoinsSortDirectionEnum[keyof typeof GetCoinsSortDirectionEnum];