/* 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 {
  AddManagerRequestBody,
  AlbumsResponse,
  ApproveGrantRequestBody,
  AuthorizedApps,
  BalanceHistoryResponse,
  BulkSubscribersResponse,
  CollectiblesResponse,
  CollectionLibraryResponse,
  ConnectedWalletsResponse,
  CreateGrantRequestBody,
  CreateUserRequestBody,
  CreateUserResponse,
  EmailAccessResponse,
  FavoritesResponse,
  FollowersResponse,
  FollowingResponse,
  GetChallenges,
  GetSupportedUsers,
  GetSupporter,
  GetSupporters,
  GetSupporting,
  HistoryResponse,
  ManagedUsersResponse,
  ManagersResponse,
  MutualFollowersResponse,
  PlaylistsResponse,
  PurchasersCountResponse,
  PurchasersResponse,
  PurchasesCountResponse,
  PurchasesResponse,
  RelatedArtistResponse,
  RemixersCountResponse,
  RemixersResponse,
  Reposts,
  SalesAggregateResponse,
  SalesJsonResponse,
  SubscribersResponse,
  TagsResponse,
  TopGenreUsersResponse,
  TopUsersResponse,
  TrackLibraryResponse,
  Tracks,
  TracksCountResponse,
  TransactionHistoryCountResponse,
  TransactionHistoryResponse,
  UpdateUserRequestBody,
  UserAccountResponse,
  UserCoinResponse,
  UserCoinsResponse,
  UserCommentsResponse,
  UserFeedResponse,
  UserIdsAddressesResponse,
  UserResponse,
  UserResponseSingle,
  UserSearch,
  UserTrackListenCountsResponse,
  UserTracksDownloadCountResponse,
  UserTracksRemixedResponse,
  VerifyToken,
  WriteResponse,
} from '../models';
import {
    AddManagerRequestBodyFromJSON,
    AddManagerRequestBodyToJSON,
    AlbumsResponseFromJSON,
    AlbumsResponseToJSON,
    ApproveGrantRequestBodyFromJSON,
    ApproveGrantRequestBodyToJSON,
    AuthorizedAppsFromJSON,
    AuthorizedAppsToJSON,
    BalanceHistoryResponseFromJSON,
    BalanceHistoryResponseToJSON,
    BulkSubscribersResponseFromJSON,
    BulkSubscribersResponseToJSON,
    CollectiblesResponseFromJSON,
    CollectiblesResponseToJSON,
    CollectionLibraryResponseFromJSON,
    CollectionLibraryResponseToJSON,
    ConnectedWalletsResponseFromJSON,
    ConnectedWalletsResponseToJSON,
    CreateGrantRequestBodyFromJSON,
    CreateGrantRequestBodyToJSON,
    CreateUserRequestBodyFromJSON,
    CreateUserRequestBodyToJSON,
    CreateUserResponseFromJSON,
    CreateUserResponseToJSON,
    EmailAccessResponseFromJSON,
    EmailAccessResponseToJSON,
    FavoritesResponseFromJSON,
    FavoritesResponseToJSON,
    FollowersResponseFromJSON,
    FollowersResponseToJSON,
    FollowingResponseFromJSON,
    FollowingResponseToJSON,
    GetChallengesFromJSON,
    GetChallengesToJSON,
    GetSupportedUsersFromJSON,
    GetSupportedUsersToJSON,
    GetSupporterFromJSON,
    GetSupporterToJSON,
    GetSupportersFromJSON,
    GetSupportersToJSON,
    GetSupportingFromJSON,
    GetSupportingToJSON,
    HistoryResponseFromJSON,
    HistoryResponseToJSON,
    ManagedUsersResponseFromJSON,
    ManagedUsersResponseToJSON,
    ManagersResponseFromJSON,
    ManagersResponseToJSON,
    MutualFollowersResponseFromJSON,
    MutualFollowersResponseToJSON,
    PlaylistsResponseFromJSON,
    PlaylistsResponseToJSON,
    PurchasersCountResponseFromJSON,
    PurchasersCountResponseToJSON,
    PurchasersResponseFromJSON,
    PurchasersResponseToJSON,
    PurchasesCountResponseFromJSON,
    PurchasesCountResponseToJSON,
    PurchasesResponseFromJSON,
    PurchasesResponseToJSON,
    RelatedArtistResponseFromJSON,
    RelatedArtistResponseToJSON,
    RemixersCountResponseFromJSON,
    RemixersCountResponseToJSON,
    RemixersResponseFromJSON,
    RemixersResponseToJSON,
    RepostsFromJSON,
    RepostsToJSON,
    SalesAggregateResponseFromJSON,
    SalesAggregateResponseToJSON,
    SalesJsonResponseFromJSON,
    SalesJsonResponseToJSON,
    SubscribersResponseFromJSON,
    SubscribersResponseToJSON,
    TagsResponseFromJSON,
    TagsResponseToJSON,
    TopGenreUsersResponseFromJSON,
    TopGenreUsersResponseToJSON,
    TopUsersResponseFromJSON,
    TopUsersResponseToJSON,
    TrackLibraryResponseFromJSON,
    TrackLibraryResponseToJSON,
    TracksFromJSON,
    TracksToJSON,
    TracksCountResponseFromJSON,
    TracksCountResponseToJSON,
    TransactionHistoryCountResponseFromJSON,
    TransactionHistoryCountResponseToJSON,
    TransactionHistoryResponseFromJSON,
    TransactionHistoryResponseToJSON,
    UpdateUserRequestBodyFromJSON,
    UpdateUserRequestBodyToJSON,
    UserAccountResponseFromJSON,
    UserAccountResponseToJSON,
    UserCoinResponseFromJSON,
    UserCoinResponseToJSON,
    UserCoinsResponseFromJSON,
    UserCoinsResponseToJSON,
    UserCommentsResponseFromJSON,
    UserCommentsResponseToJSON,
    UserFeedResponseFromJSON,
    UserFeedResponseToJSON,
    UserIdsAddressesResponseFromJSON,
    UserIdsAddressesResponseToJSON,
    UserResponseFromJSON,
    UserResponseToJSON,
    UserResponseSingleFromJSON,
    UserResponseSingleToJSON,
    UserSearchFromJSON,
    UserSearchToJSON,
    UserTrackListenCountsResponseFromJSON,
    UserTrackListenCountsResponseToJSON,
    UserTracksDownloadCountResponseFromJSON,
    UserTracksDownloadCountResponseToJSON,
    UserTracksRemixedResponseFromJSON,
    UserTracksRemixedResponseToJSON,
    VerifyTokenFromJSON,
    VerifyTokenToJSON,
    WriteResponseFromJSON,
    WriteResponseToJSON,
} from '../models';

export interface AddManagerRequest {
    id: string;
    addManagerRequestBody: AddManagerRequestBody;
}

export interface ApproveGrantRequest {
    id: string;
    approveGrantRequestBody: ApproveGrantRequestBody;
}

export interface BulkGetSubscribersRequest {
    ids: Array<string>;
}

export interface BulkGetSubscribersViaJSONRequestRequest {
    ids: Array<string>;
}

export interface CreateGrantRequest {
    id: string;
    createGrantRequestBody: CreateGrantRequestBody;
}

export interface CreateUserRequest {
    metadata: CreateUserRequestBody;
}

export interface DownloadPurchasesAsCSVRequest {
    id: string;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface DownloadSalesAsCSVRequest {
    id: string;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface DownloadSalesAsJSONRequest {
    id: string;
    userId?: string;
    granteeUserId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface DownloadUSDCWithdrawalsAsCSVRequest {
    id: string;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface FollowUserRequest {
    id: string;
    userId: string;
}

export interface GetAIAttributedTracksByUserHandleRequest {
    handle: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sort?: GetAIAttributedTracksByUserHandleSortEnum;
    query?: string;
    sortMethod?: GetAIAttributedTracksByUserHandleSortMethodEnum;
    sortDirection?: GetAIAttributedTracksByUserHandleSortDirectionEnum;
    filterTracks?: GetAIAttributedTracksByUserHandleFilterTracksEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetAlbumsByUserRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sortMethod?: GetAlbumsByUserSortMethodEnum;
    query?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetAudioTransactionCountRequest {
    id: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetAudioTransactionsRequest {
    id: string;
    offset?: number;
    limit?: number;
    sortMethod?: GetAudioTransactionsSortMethodEnum;
    sortDirection?: GetAudioTransactionsSortDirectionEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetAuthorizedAppsRequest {
    id: string;
}

export interface GetBulkUsersRequest {
    userId?: string;
    id?: Array<string>;
}

export interface GetConnectedWalletsRequest {
    id: string;
}

export interface GetFollowersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetFollowingRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetGranteeUsersRequest {
    address: string;
    offset?: number;
    limit?: number;
    isApproved?: boolean;
    isRevoked?: boolean;
    userId?: string;
}

export interface GetManagedUsersRequest {
    id: string;
    isApproved?: boolean;
    isRevoked?: boolean;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetManagersRequest {
    id: string;
    isApproved?: boolean;
    isRevoked?: boolean;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetMutedUsersRequest {
    id: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetMutualFollowersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetPlaylistsByUserRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sortMethod?: GetPlaylistsByUserSortMethodEnum;
    query?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetPurchasersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    contentType?: string;
    contentId?: string;
}

export interface GetPurchasersCountRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    contentType?: string;
    contentId?: string;
}

export interface GetPurchasesRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sortMethod?: GetPurchasesSortMethodEnum;
    sortDirection?: GetPurchasesSortDirectionEnum;
    contentIds?: Array<string>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetPurchasesCountRequest {
    id: string;
    userId?: string;
    contentIds?: Array<string>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetRelatedUsersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    filterFollowed?: boolean;
}

export interface GetRemixersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    trackId?: string;
}

export interface GetRemixersCountRequest {
    id: string;
    userId?: string;
    trackId?: string;
}

export interface GetRepostsRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetRepostsByHandleRequest {
    handle: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetSalesRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sortMethod?: GetSalesSortMethodEnum;
    sortDirection?: GetSalesSortDirectionEnum;
    contentIds?: Array<string>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetSalesAggregateRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetSalesCountRequest {
    id: string;
    userId?: string;
    contentIds?: Array<string>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetSubscribersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetSupportedUsersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetSupporterRequest {
    id: string;
    supporterUserId: string;
    userId?: string;
}

export interface GetSupportersRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetSupportingRequest {
    id: string;
    supportedUserId: string;
    userId?: string;
}

export interface GetTopTrackTagsRequest {
    id: string;
    limit?: number;
    userId?: string;
}

export interface GetTopUsersRequest {
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetTopUsersInGenreRequest {
    offset?: number;
    limit?: number;
    genre?: Array<string>;
}

export interface GetTracksByUserRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sort?: GetTracksByUserSortEnum;
    query?: string;
    sortMethod?: GetTracksByUserSortMethodEnum;
    sortDirection?: GetTracksByUserSortDirectionEnum;
    filterTracks?: GetTracksByUserFilterTracksEnum;
    gateCondition?: Array<GetTracksByUserGateConditionEnum>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetTracksByUserHandleRequest {
    handle: string;
    offset?: number;
    limit?: number;
    userId?: string;
    sort?: GetTracksByUserHandleSortEnum;
    query?: string;
    sortMethod?: GetTracksByUserHandleSortMethodEnum;
    sortDirection?: GetTracksByUserHandleSortDirectionEnum;
    filterTracks?: GetTracksByUserHandleFilterTracksEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetTracksCountByUserRequest {
    id: string;
    userId?: string;
    filterTracks?: GetTracksCountByUserFilterTracksEnum;
    gateCondition?: Array<GetTracksCountByUserGateConditionEnum>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUSDCTransactionCountRequest {
    id: string;
    type?: Array<GetUSDCTransactionCountTypeEnum>;
    includeSystemTransactions?: boolean;
    method?: GetUSDCTransactionCountMethodEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUSDCTransactionsRequest {
    id: string;
    offset?: number;
    limit?: number;
    sortMethod?: GetUSDCTransactionsSortMethodEnum;
    sortDirection?: GetUSDCTransactionsSortDirectionEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
    type?: Array<GetUSDCTransactionsTypeEnum>;
    includeSystemTransactions?: boolean;
    method?: GetUSDCTransactionsMethodEnum;
}

export interface GetUserRequest {
    id: string;
    userId?: string;
}

export interface GetUserAccountRequest {
    wallet: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserBalanceHistoryRequest {
    id: string;
    startTime?: Date;
    endTime?: Date;
    granularity?: GetUserBalanceHistoryGranularityEnum;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserByHandleRequest {
    handle: string;
    userId?: string;
}

export interface GetUserChallengesRequest {
    id: string;
    showHistorical?: boolean;
}

export interface GetUserCoinRequest {
    id: string;
    mint: string;
}

export interface GetUserCoinsRequest {
    id: string;
    offset?: number;
    limit?: number;
}

export interface GetUserCollectiblesRequest {
    id: string;
}

export interface GetUserCommentsRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetUserEmailKeyRequest {
    receivingUserId: string;
    grantorUserId: string;
}

export interface GetUserFavoriteTracksRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    query?: string;
    sortMethod?: GetUserFavoriteTracksSortMethodEnum;
    sortDirection?: GetUserFavoriteTracksSortDirectionEnum;
}

export interface GetUserFavoritesRequest {
    id: string;
}

export interface GetUserFeedRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    filter?: GetUserFeedFilterEnum;
    tracksOnly?: boolean;
    withUsers?: boolean;
    followeeUserId?: Array<number>;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserIDsByAddressesRequest {
    address: Array<string>;
}

export interface GetUserLibraryAlbumsRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    query?: string;
    sortDirection?: GetUserLibraryAlbumsSortDirectionEnum;
    type?: GetUserLibraryAlbumsTypeEnum;
    sortMethod?: GetUserLibraryAlbumsSortMethodEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserLibraryPlaylistsRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    query?: string;
    sortDirection?: GetUserLibraryPlaylistsSortDirectionEnum;
    type?: GetUserLibraryPlaylistsTypeEnum;
    sortMethod?: GetUserLibraryPlaylistsSortMethodEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserLibraryTracksRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    query?: string;
    sortMethod?: GetUserLibraryTracksSortMethodEnum;
    sortDirection?: GetUserLibraryTracksSortDirectionEnum;
    type?: GetUserLibraryTracksTypeEnum;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface GetUserMonthlyTrackListensRequest {
    id: string;
    startTime: string;
    endTime: string;
}

export interface GetUserRecommendedTracksRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
    timeRange?: GetUserRecommendedTracksTimeRangeEnum;
}

export interface GetUserTracksDownloadCountRequest {
    id: string;
}

export interface GetUserTracksRemixedRequest {
    id: string;
    offset?: number;
    limit?: number;
    userId?: string;
}

export interface GetUsersTrackHistoryRequest {
    id: string;
    offset?: number;
    limit?: number;
    query?: string;
    sortMethod?: GetUsersTrackHistorySortMethodEnum;
    sortDirection?: GetUsersTrackHistorySortDirectionEnum;
    userId?: string;
    encodedDataMessage?: string;
    encodedDataSignature?: string;
}

export interface MuteUserRequest {
    id: string;
    userId: string;
}

export interface RemoveManagerRequest {
    id: string;
    managerUserId: string;
}

export interface RevokeGrantRequest {
    id: string;
    address: string;
}

export interface SearchUsersRequest {
    offset?: number;
    limit?: number;
    query?: string;
    genre?: Array<string>;
    sortMethod?: SearchUsersSortMethodEnum;
    isVerified?: string;
}

export interface SubscribeToUserRequest {
    id: string;
    userId: string;
}

export interface UnfollowUserRequest {
    id: string;
    userId: string;
}

export interface UnmuteUserRequest {
    id: string;
    userId: string;
}

export interface UnsubscribeFromUserRequest {
    id: string;
    userId: string;
}

export interface UpdateUserRequest {
    id: string;
    userId: string;
    metadata: UpdateUserRequestBody;
}

export interface VerifyIDTokenRequest {
    token: string;
}

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

    /**
     * @hidden
     * Add a manager (authorize another user to act on your behalf)
     */
    async addManagerRaw(params: AddManagerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling addManager.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/managers`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AddManagerRequestBodyToJSON(params.addManagerRequestBody),
        }, initOverrides);

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

    /**
     * Add a manager (authorize another user to act on your behalf)
     */
    async addManager(params: AddManagerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.addManagerRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Approve a manager request (manager approves being added by the child user)
     */
    async approveGrantRaw(params: ApproveGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling approveGrant.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/grants/approve`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ApproveGrantRequestBodyToJSON(params.approveGrantRequestBody),
        }, initOverrides);

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

    /**
     * Approve a manager request (manager approves being added by the child user)
     */
    async approveGrant(params: ApproveGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.approveGrantRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * All users that subscribe to the provided users
     */
    async bulkGetSubscribersRaw(params: BulkGetSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BulkSubscribersResponse>> {
        if (params.ids === null || params.ids === undefined) {
            throw new runtime.RequiredError('ids','Required parameter params.ids was null or undefined when calling bulkGetSubscribers.');
        }

        const queryParameters: any = {};

        if (params.ids) {
            queryParameters['ids'] = params.ids.join(runtime.COLLECTION_FORMATS["csv"]);
        }

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * All users that subscribe to the provided users
     */
    async bulkGetSubscribers(params: BulkGetSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BulkSubscribersResponse> {
        const response = await this.bulkGetSubscribersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get all users that subscribe to the users listed in the JSON request
     */
    async bulkGetSubscribersViaJSONRequestRaw(params: BulkGetSubscribersViaJSONRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BulkSubscribersResponse>> {
        if (params.ids === null || params.ids === undefined) {
            throw new runtime.RequiredError('ids','Required parameter params.ids was null or undefined when calling bulkGetSubscribersViaJSONRequest.');
        }

        const queryParameters: any = {};

        if (params.ids) {
            queryParameters['ids'] = params.ids.join(runtime.COLLECTION_FORMATS["csv"]);
        }

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get all users that subscribe to the users listed in the JSON request
     */
    async bulkGetSubscribersViaJSONRequest(params: BulkGetSubscribersViaJSONRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BulkSubscribersResponse> {
        const response = await this.bulkGetSubscribersViaJSONRequestRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Create a grant (authorize an app to act on the user\'s behalf)
     */
    async createGrantRaw(params: CreateGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling createGrant.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/grants`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateGrantRequestBodyToJSON(params.createGrantRequestBody),
        }, initOverrides);

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

    /**
     * Create a grant (authorize an app to act on the user\'s behalf)
     */
    async createGrant(params: CreateGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.createGrantRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Creates a new user
     */
    async createUserRaw(params: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateUserResponse>> {
        if (params.metadata === null || params.metadata === undefined) {
            throw new runtime.RequiredError('metadata','Required parameter params.metadata was null or undefined when calling createUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateUserRequestBodyToJSON(params.metadata),
        }, initOverrides);

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

    /**
     * Creates a new user
     */
    async createUser(params: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateUserResponse> {
        const response = await this.createUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Downloads the purchases the user has made as a CSV file
     */
    async downloadPurchasesAsCSVRaw(params: DownloadPurchasesAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling downloadPurchasesAsCSV.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Downloads the purchases the user has made as a CSV file
     */
    async downloadPurchasesAsCSV(params: DownloadPurchasesAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.downloadPurchasesAsCSVRaw(params, initOverrides);
    }

    /**
     * @hidden
     * Downloads the sales the user has made as a CSV file
     */
    async downloadSalesAsCSVRaw(params: DownloadSalesAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling downloadSalesAsCSV.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Downloads the sales the user has made as a CSV file
     */
    async downloadSalesAsCSV(params: DownloadSalesAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.downloadSalesAsCSVRaw(params, initOverrides);
    }

    /**
     * @hidden
     * Gets the sales data for the user in JSON format
     */
    async downloadSalesAsJSONRaw(params: DownloadSalesAsJSONRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SalesJsonResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling downloadSalesAsJSON.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the sales data for the user in JSON format
     */
    async downloadSalesAsJSON(params: DownloadSalesAsJSONRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SalesJsonResponse> {
        const response = await this.downloadSalesAsJSONRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Downloads the USDC withdrawals the user has made as a CSV file
     */
    async downloadUSDCWithdrawalsAsCSVRaw(params: DownloadUSDCWithdrawalsAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling downloadUSDCWithdrawalsAsCSV.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Downloads the USDC withdrawals the user has made as a CSV file
     */
    async downloadUSDCWithdrawalsAsCSV(params: DownloadUSDCWithdrawalsAsCSVRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.downloadUSDCWithdrawalsAsCSVRaw(params, initOverrides);
    }

    /**
     * @hidden
     * Follow a user
     */
    async followUserRaw(params: FollowUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling followUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/follow`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Follow a user
     */
    async followUser(params: FollowUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.followUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the AI generated tracks attributed to a user using the user\'s handle
     */
    async getAIAttributedTracksByUserHandleRaw(params: GetAIAttributedTracksByUserHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Tracks>> {
        if (params.handle === null || params.handle === undefined) {
            throw new runtime.RequiredError('handle','Required parameter params.handle was null or undefined when calling getAIAttributedTracksByUserHandle.');
        }

        const queryParameters: any = {};

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

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

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

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

        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;
        }

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the AI generated tracks attributed to a user using the user\'s handle
     */
    async getAIAttributedTracksByUserHandle(params: GetAIAttributedTracksByUserHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Tracks> {
        const response = await this.getAIAttributedTracksByUserHandleRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the albums created by a user using their user ID
     */
    async getAlbumsByUserRaw(params: GetAlbumsByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AlbumsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getAlbumsByUser.');
        }

        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the albums created by a user using their user ID
     */
    async getAlbumsByUser(params: GetAlbumsByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AlbumsResponse> {
        const response = await this.getAlbumsByUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of the user\'s $AUDIO transaction history within the App
     */
    async getAudioTransactionCountRaw(params: GetAudioTransactionCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TransactionHistoryCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getAudioTransactionCount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets the count of the user\'s $AUDIO transaction history within the App
     */
    async getAudioTransactionCount(params: GetAudioTransactionCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransactionHistoryCountResponse> {
        const response = await this.getAudioTransactionCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the user\'s $AUDIO transaction history within the App
     */
    async getAudioTransactionsRaw(params: GetAudioTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TransactionHistoryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getAudioTransactions.');
        }

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets the user\'s $AUDIO transaction history within the App
     */
    async getAudioTransactions(params: GetAudioTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransactionHistoryResponse> {
        const response = await this.getAudioTransactionsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the apps that user has authorized to write to their account
     */
    async getAuthorizedAppsRaw(params: GetAuthorizedAppsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AuthorizedApps>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getAuthorizedApps.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get the apps that user has authorized to write to their account
     */
    async getAuthorizedApps(params: GetAuthorizedAppsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AuthorizedApps> {
        const response = await this.getAuthorizedAppsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of users by ID
     */
    async getBulkUsersRaw(params: GetBulkUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserResponse>> {
        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a list of users by ID
     */
    async getBulkUsers(params: GetBulkUsersRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserResponse> {
        const response = await this.getBulkUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the User\'s ERC and SPL connected wallets
     */
    async getConnectedWalletsRaw(params: GetConnectedWalletsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ConnectedWalletsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getConnectedWallets.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get the User\'s ERC and SPL connected wallets
     */
    async getConnectedWallets(params: GetConnectedWalletsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ConnectedWalletsResponse> {
        const response = await this.getConnectedWalletsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * All users that follow the provided user
     */
    async getFollowersRaw(params: GetFollowersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FollowersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getFollowers.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * All users that follow the provided user
     */
    async getFollowers(params: GetFollowersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FollowersResponse> {
        const response = await this.getFollowersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * All users that the provided user follows
     */
    async getFollowingRaw(params: GetFollowingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FollowingResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getFollowing.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * All users that the provided user follows
     */
    async getFollowing(params: GetFollowingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FollowingResponse> {
        const response = await this.getFollowingRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get all users who have authorized a particular grantee (developer app) identified by their wallet address. Supports pagination.
     */
    async getGranteeUsersRaw(params: GetGranteeUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FollowersResponse>> {
        if (params.address === null || params.address === undefined) {
            throw new runtime.RequiredError('address','Required parameter params.address was null or undefined when calling getGranteeUsers.');
        }

        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get all users who have authorized a particular grantee (developer app) identified by their wallet address. Supports pagination.
     */
    async getGranteeUsers(params: GetGranteeUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FollowersResponse> {
        const response = await this.getGranteeUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of users managed by the given user
     */
    async getManagedUsersRaw(params: GetManagedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagedUsersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getManagedUsers.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets a list of users managed by the given user
     */
    async getManagedUsers(params: GetManagedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedUsersResponse> {
        const response = await this.getManagedUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of users managing the given user
     */
    async getManagersRaw(params: GetManagersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getManagers.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets a list of users managing the given user
     */
    async getManagers(params: GetManagersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagersResponse> {
        const response = await this.getManagersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Returns the full profile of the currently authenticated user based on the Bearer access token obtained via OAuth.
     * Get authenticated user
     */
    async getMeRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserResponseSingle>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Returns the full profile of the currently authenticated user based on the Bearer access token obtained via OAuth.
     * Get authenticated user
     */
    async getMe(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserResponseSingle> {
        const response = await this.getMeRaw(initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets users muted by the given user
     */
    async getMutedUsersRaw(params: GetMutedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getMutedUsers.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets users muted by the given user
     */
    async getMutedUsers(params: GetMutedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserResponse> {
        const response = await this.getMutedUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get intersection of users that follow followeeUserId and users that are followed by followerUserId
     */
    async getMutualFollowersRaw(params: GetMutualFollowersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MutualFollowersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getMutualFollowers.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Get intersection of users that follow followeeUserId and users that are followed by followerUserId
     */
    async getMutualFollowers(params: GetMutualFollowersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MutualFollowersResponse> {
        const response = await this.getMutualFollowersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the playlists created by a user using their user ID
     */
    async getPlaylistsByUserRaw(params: GetPlaylistsByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PlaylistsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getPlaylistsByUser.');
        }

        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the playlists created by a user using their user ID
     */
    async getPlaylistsByUser(params: GetPlaylistsByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PlaylistsResponse> {
        const response = await this.getPlaylistsByUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the list of unique users who have purchased content by the given user
     */
    async getPurchasersRaw(params: GetPurchasersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getPurchasers.');
        }

        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the list of unique users who have purchased content by the given user
     */
    async getPurchasers(params: GetPurchasersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasersResponse> {
        const response = await this.getPurchasersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the list of users who have purchased content by the given user
     */
    async getPurchasersCountRaw(params: GetPurchasersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasersCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getPurchasersCount.');
        }

        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the list of users who have purchased content by the given user
     */
    async getPurchasersCount(params: GetPurchasersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasersCountResponse> {
        const response = await this.getPurchasersCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the purchases the user has made
     */
    async getPurchasesRaw(params: GetPurchasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasesResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getPurchases.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the purchases the user has made
     */
    async getPurchases(params: GetPurchasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasesResponse> {
        const response = await this.getPurchasesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of purchases the user has made
     */
    async getPurchasesCountRaw(params: GetPurchasesCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasesCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getPurchasesCount.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the count of purchases the user has made
     */
    async getPurchasesCount(params: GetPurchasesCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasesCountResponse> {
        const response = await this.getPurchasesCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of users that might be of interest to followers of this user.
     */
    async getRelatedUsersRaw(params: GetRelatedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RelatedArtistResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getRelatedUsers.');
        }

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a list of users that might be of interest to followers of this user.
     */
    async getRelatedUsers(params: GetRelatedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RelatedArtistResponse> {
        const response = await this.getRelatedUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the list of unique users who have remixed tracks by the given user, or a specific track by that user if provided
     */
    async getRemixersRaw(params: GetRemixersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RemixersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getRemixers.');
        }

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the list of unique users who have remixed tracks by the given user, or a specific track by that user if provided
     */
    async getRemixers(params: GetRemixersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RemixersResponse> {
        const response = await this.getRemixersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of unique users who have remixed tracks by the given user, or a specific track by that user if provided
     */
    async getRemixersCountRaw(params: GetRemixersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RemixersCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getRemixersCount.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the count of unique users who have remixed tracks by the given user, or a specific track by that user if provided
     */
    async getRemixersCount(params: GetRemixersCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RemixersCountResponse> {
        const response = await this.getRemixersCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the given user\'s reposts
     */
    async getRepostsRaw(params: GetRepostsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Reposts>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getReposts.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the given user\'s reposts
     */
    async getReposts(params: GetRepostsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Reposts> {
        const response = await this.getRepostsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the user\'s reposts by the user handle
     */
    async getRepostsByHandleRaw(params: GetRepostsByHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Reposts>> {
        if (params.handle === null || params.handle === undefined) {
            throw new runtime.RequiredError('handle','Required parameter params.handle was null or undefined when calling getRepostsByHandle.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the user\'s reposts by the user handle
     */
    async getRepostsByHandle(params: GetRepostsByHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Reposts> {
        const response = await this.getRepostsByHandleRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the sales the user has made
     */
    async getSalesRaw(params: GetSalesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasesResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSales.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the sales the user has made
     */
    async getSales(params: GetSalesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasesResponse> {
        const response = await this.getSalesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the aggregated sales data for the user
     */
    async getSalesAggregateRaw(params: GetSalesAggregateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SalesAggregateResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSalesAggregate.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the aggregated sales data for the user
     */
    async getSalesAggregate(params: GetSalesAggregateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SalesAggregateResponse> {
        const response = await this.getSalesAggregateRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of sales the user has made
     */
    async getSalesCountRaw(params: GetSalesCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PurchasesCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSalesCount.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the count of sales the user has made
     */
    async getSalesCount(params: GetSalesCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PurchasesCountResponse> {
        const response = await this.getSalesCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * All users that subscribe to the provided user
     */
    async getSubscribersRaw(params: GetSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscribersResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSubscribers.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * All users that subscribe to the provided user
     */
    async getSubscribers(params: GetSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscribersResponse> {
        const response = await this.getSubscribersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the users that the given user supports
     */
    async getSupportedUsersRaw(params: GetSupportedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSupportedUsers>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSupportedUsers.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the users that the given user supports
     */
    async getSupportedUsers(params: GetSupportedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSupportedUsers> {
        const response = await this.getSupportedUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the specified supporter of the given user
     */
    async getSupporterRaw(params: GetSupporterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSupporter>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSupporter.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the specified supporter of the given user
     */
    async getSupporter(params: GetSupporterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSupporter> {
        const response = await this.getSupporterRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the supporters of the given user
     */
    async getSupportersRaw(params: GetSupportersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSupporters>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSupporters.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the supporters of the given user
     */
    async getSupporters(params: GetSupportersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSupporters> {
        const response = await this.getSupportersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the support from the given user to the supported user
     */
    async getSupportingRaw(params: GetSupportingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSupporting>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getSupporting.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the support from the given user to the supported user
     */
    async getSupporting(params: GetSupportingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSupporting> {
        const response = await this.getSupportingRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the most used track tags by a user.
     * Fetch most used tags in a user\'s tracks
     */
    async getTopTrackTagsRaw(params: GetTopTrackTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TagsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getTopTrackTags.');
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the most used track tags by a user.
     * Fetch most used tags in a user\'s tracks
     */
    async getTopTrackTags(params: GetTopTrackTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TagsResponse> {
        const response = await this.getTopTrackTagsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the Top Users having at least one track by follower count
     */
    async getTopUsersRaw(params: GetTopUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TopUsersResponse>> {
        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Get the Top Users having at least one track by follower count
     */
    async getTopUsers(params: GetTopUsersRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TopUsersResponse> {
        const response = await this.getTopUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the Top Users for a Given Genre
     */
    async getTopUsersInGenreRaw(params: GetTopUsersInGenreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TopGenreUsersResponse>> {
        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get the Top Users for a Given Genre
     */
    async getTopUsersInGenre(params: GetTopUsersInGenreRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TopGenreUsersResponse> {
        const response = await this.getTopUsersInGenreRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the tracks created by a user using their user ID
     */
    async getTracksByUserRaw(params: GetTracksByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Tracks>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getTracksByUser.');
        }

        const queryParameters: any = {};

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

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

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

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

        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;
        }

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the tracks created by a user using their user ID
     */
    async getTracksByUser(params: GetTracksByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Tracks> {
        const response = await this.getTracksByUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the tracks created by a user using the user\'s handle
     */
    async getTracksByUserHandleRaw(params: GetTracksByUserHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Tracks>> {
        if (params.handle === null || params.handle === undefined) {
            throw new runtime.RequiredError('handle','Required parameter params.handle was null or undefined when calling getTracksByUserHandle.');
        }

        const queryParameters: any = {};

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

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

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

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

        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;
        }

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the tracks created by a user using the user\'s handle
     */
    async getTracksByUserHandle(params: GetTracksByUserHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Tracks> {
        const response = await this.getTracksByUserHandleRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of tracks created by a user
     */
    async getTracksCountByUserRaw(params: GetTracksCountByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TracksCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getTracksCountByUser.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the count of tracks created by a user
     */
    async getTracksCountByUser(params: GetTracksCountByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TracksCountResponse> {
        const response = await this.getTracksCountByUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the count of the user\'s $USDC transaction history within the App
     */
    async getUSDCTransactionCountRaw(params: GetUSDCTransactionCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TransactionHistoryCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUSDCTransactionCount.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets the count of the user\'s $USDC transaction history within the App
     */
    async getUSDCTransactionCount(params: GetUSDCTransactionCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransactionHistoryCountResponse> {
        const response = await this.getUSDCTransactionCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the user\'s $USDC transaction history within the App
     */
    async getUSDCTransactionsRaw(params: GetUSDCTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TransactionHistoryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUSDCTransactions.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets the user\'s $USDC transaction history within the App
     */
    async getUSDCTransactions(params: GetUSDCTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransactionHistoryResponse> {
        const response = await this.getUSDCTransactionsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a single user by their user ID
     */
    async getUserRaw(params: GetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserResponseSingle>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUser.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a single user by their user ID
     */
    async getUser(params: GetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserResponseSingle> {
        const response = await this.getUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the account for a given user
     */
    async getUserAccountRaw(params: GetUserAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserAccountResponse>> {
        if (params.wallet === null || params.wallet === undefined) {
            throw new runtime.RequiredError('wallet','Required parameter params.wallet was null or undefined when calling getUserAccount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

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

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

    /**
     * Gets the account for a given user
     */
    async getUserAccount(params: GetUserAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserAccountResponse> {
        const response = await this.getUserAccountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the user\'s historical portfolio balance data
     */
    async getUserBalanceHistoryRaw(params: GetUserBalanceHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BalanceHistoryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserBalanceHistory.');
        }

        const queryParameters: any = {};

        if (params.startTime !== undefined) {
            queryParameters['start_time'] = (params.startTime as any).toISOString();
        }

        if (params.endTime !== undefined) {
            queryParameters['end_time'] = (params.endTime as any).toISOString();
        }

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Get the user\'s historical portfolio balance data
     */
    async getUserBalanceHistory(params: GetUserBalanceHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BalanceHistoryResponse> {
        const response = await this.getUserBalanceHistoryRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a single user by their handle
     */
    async getUserByHandleRaw(params: GetUserByHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserResponseSingle>> {
        if (params.handle === null || params.handle === undefined) {
            throw new runtime.RequiredError('handle','Required parameter params.handle was null or undefined when calling getUserByHandle.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a single user by their handle
     */
    async getUserByHandle(params: GetUserByHandleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserResponseSingle> {
        const response = await this.getUserByHandleRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets all challenges for the given user
     */
    async getUserChallengesRaw(params: GetUserChallengesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetChallenges>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserChallenges.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Gets all challenges for the given user
     */
    async getUserChallenges(params: GetUserChallengesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetChallenges> {
        const response = await this.getUserChallengesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets information about a specific coin owned by the user and their wallets
     */
    async getUserCoinRaw(params: GetUserCoinRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserCoinResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserCoin.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Gets information about a specific coin owned by the user and their wallets
     */
    async getUserCoin(params: GetUserCoinRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserCoinResponse> {
        const response = await this.getUserCoinRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a list of the coins owned by the user and their balances
     */
    async getUserCoinsRaw(params: GetUserCoinsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserCoinsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserCoins.');
        }

        const queryParameters: any = {};

        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: `/users/{id}/coins`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Gets a list of the coins owned by the user and their balances
     */
    async getUserCoins(params: GetUserCoinsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserCoinsResponse> {
        const response = await this.getUserCoinsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the User\'s indexed collectibles data
     */
    async getUserCollectiblesRaw(params: GetUserCollectiblesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CollectiblesResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserCollectibles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get the User\'s indexed collectibles data
     */
    async getUserCollectibles(params: GetUserCollectiblesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CollectiblesResponse> {
        const response = await this.getUserCollectiblesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get user comment history
     */
    async getUserCommentsRaw(params: GetUserCommentsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserCommentsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserComments.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Get user comment history
     */
    async getUserComments(params: GetUserCommentsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserCommentsResponse> {
        const response = await this.getUserCommentsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the encrypted key for email access between the receiving user and granting user.
     */
    async getUserEmailKeyRaw(params: GetUserEmailKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmailAccessResponse>> {
        if (params.receivingUserId === null || params.receivingUserId === undefined) {
            throw new runtime.RequiredError('receivingUserId','Required parameter params.receivingUserId was null or undefined when calling getUserEmailKey.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/users/{receiving_user_id}/emails/{grantor_user_id}/key`.replace(`{${"receiving_user_id"}}`, encodeURIComponent(String(params.receivingUserId))).replace(`{${"grantor_user_id"}}`, encodeURIComponent(String(params.grantorUserId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Gets the encrypted key for email access between the receiving user and granting user.
     */
    async getUserEmailKey(params: GetUserEmailKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailAccessResponse> {
        const response = await this.getUserEmailKeyRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a user\'s favorite tracks
     */
    async getUserFavoriteTracksRaw(params: GetUserFavoriteTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TrackLibraryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserFavoriteTracks.');
        }

        const queryParameters: any = {};

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

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

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

        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 = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a user\'s favorite tracks
     */
    async getUserFavoriteTracks(params: GetUserFavoriteTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TrackLibraryResponse> {
        const response = await this.getUserFavoriteTracksRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a user\'s favorite tracks
     */
    async getUserFavoritesRaw(params: GetUserFavoritesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FavoritesResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserFavorites.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Gets a user\'s favorite tracks
     */
    async getUserFavorites(params: GetUserFavoritesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FavoritesResponse> {
        const response = await this.getUserFavoritesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the feed for the user
     */
    async getUserFeedRaw(params: GetUserFeedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserFeedResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserFeed.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the feed for the user
     */
    async getUserFeed(params: GetUserFeedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserFeedResponse> {
        const response = await this.getUserFeedRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets User IDs from any Ethereum wallet address or Solana account address associated with their Audius account.
     */
    async getUserIDsByAddressesRaw(params: GetUserIDsByAddressesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserIdsAddressesResponse>> {
        if (params.address === null || params.address === undefined) {
            throw new runtime.RequiredError('address','Required parameter params.address was null or undefined when calling getUserIDsByAddresses.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Gets User IDs from any Ethereum wallet address or Solana account address associated with their Audius account.
     */
    async getUserIDsByAddresses(params: GetUserIDsByAddressesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserIdsAddressesResponse> {
        const response = await this.getUserIDsByAddressesRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a user\'s saved/reposted/purchased/all albums
     * Fetch a user\'s full library playlists
     */
    async getUserLibraryAlbumsRaw(params: GetUserLibraryAlbumsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CollectionLibraryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserLibraryAlbums.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a user\'s saved/reposted/purchased/all albums
     * Fetch a user\'s full library playlists
     */
    async getUserLibraryAlbums(params: GetUserLibraryAlbumsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CollectionLibraryResponse> {
        const response = await this.getUserLibraryAlbumsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a user\'s saved/reposted/purchased/all playlists
     * Fetch a user\'s full library playlists
     */
    async getUserLibraryPlaylistsRaw(params: GetUserLibraryPlaylistsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CollectionLibraryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserLibraryPlaylists.');
        }

        const queryParameters: any = {};

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a user\'s saved/reposted/purchased/all playlists
     * Fetch a user\'s full library playlists
     */
    async getUserLibraryPlaylists(params: GetUserLibraryPlaylistsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CollectionLibraryResponse> {
        const response = await this.getUserLibraryPlaylistsRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets a user\'s saved/reposted/purchased/all tracks
     * Fetch a user\'s full library tracks
     */
    async getUserLibraryTracksRaw(params: GetUserLibraryTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TrackLibraryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserLibraryTracks.');
        }

        const queryParameters: any = {};

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

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

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

        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;
        }

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets a user\'s saved/reposted/purchased/all tracks
     * Fetch a user\'s full library tracks
     */
    async getUserLibraryTracks(params: GetUserLibraryTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TrackLibraryResponse> {
        const response = await this.getUserLibraryTracksRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the listen data for a user by month and track within a given time frame.
     */
    async getUserMonthlyTrackListensRaw(params: GetUserMonthlyTrackListensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserTrackListenCountsResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserMonthlyTrackListens.');
        }

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

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

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Gets the listen data for a user by month and track within a given time frame.
     */
    async getUserMonthlyTrackListens(params: GetUserMonthlyTrackListensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserTrackListenCountsResponse> {
        const response = await this.getUserMonthlyTrackListensRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the recommended tracks for the user
     */
    async getUserRecommendedTracksRaw(params: GetUserRecommendedTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Tracks>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserRecommendedTracks.');
        }

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the recommended tracks for the user
     */
    async getUserRecommendedTracks(params: GetUserRecommendedTracksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Tracks> {
        const response = await this.getUserRecommendedTracksRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets the total download count for all tracks (and stems) owned by the user. Use for dashboard \"Downloads\" tile.
     */
    async getUserTracksDownloadCountRaw(params: GetUserTracksDownloadCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserTracksDownloadCountResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserTracksDownloadCount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets the total download count for all tracks (and stems) owned by the user. Use for dashboard \"Downloads\" tile.
     */
    async getUserTracksDownloadCount(params: GetUserTracksDownloadCountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserTracksDownloadCountResponse> {
        const response = await this.getUserTracksDownloadCountRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Gets tracks owned by the user which have been remixed by another track
     */
    async getUserTracksRemixedRaw(params: GetUserTracksRemixedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserTracksRemixedResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUserTracksRemixed.');
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Gets tracks owned by the user which have been remixed by another track
     */
    async getUserTracksRemixed(params: GetUserTracksRemixedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserTracksRemixedResponse> {
        const response = await this.getUserTracksRemixedRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Get the tracks the user recently listened to.
     */
    async getUsersTrackHistoryRaw(params: GetUsersTrackHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HistoryResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling getUsersTrackHistory.');
        }

        const queryParameters: any = {};

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

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

        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;
        }

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (params.encodedDataMessage !== undefined && params.encodedDataMessage !== null) {
            headerParameters['Encoded-Data-Message'] = String(params.encodedDataMessage);
        }

        if (params.encodedDataSignature !== undefined && params.encodedDataSignature !== null) {
            headerParameters['Encoded-Data-Signature'] = String(params.encodedDataSignature);
        }

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["read"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

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

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

    /**
     * Get the tracks the user recently listened to.
     */
    async getUsersTrackHistory(params: GetUsersTrackHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<HistoryResponse> {
        const response = await this.getUsersTrackHistoryRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Mute a user
     */
    async muteUserRaw(params: MuteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling muteUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/muted`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Mute a user
     */
    async muteUser(params: MuteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.muteUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Remove a manager (revoke user-to-user grant). Can be called by the child user or the manager.
     */
    async removeManagerRaw(params: RemoveManagerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling removeManager.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/managers/{managerUserId}`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))).replace(`{${"managerUserId"}}`, encodeURIComponent(String(params.managerUserId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Remove a manager (revoke user-to-user grant). Can be called by the child user or the manager.
     */
    async removeManager(params: RemoveManagerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.removeManagerRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Revoke a grant (remove app authorization)
     */
    async revokeGrantRaw(params: RevokeGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling revokeGrant.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/grants/{address}`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))).replace(`{${"address"}}`, encodeURIComponent(String(params.address))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Revoke a grant (remove app authorization)
     */
    async revokeGrant(params: RevokeGrantRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.revokeGrantRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Search for users that match the given query
     */
    async searchUsersRaw(params: SearchUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSearch>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Search for users that match the given query
     */
    async searchUsers(params: SearchUsersRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSearch> {
        const response = await this.searchUsersRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Subscribe to a user
     */
    async subscribeToUserRaw(params: SubscribeToUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling subscribeToUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/subscribers`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Subscribe to a user
     */
    async subscribeToUser(params: SubscribeToUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.subscribeToUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Unfollow a user
     */
    async unfollowUserRaw(params: UnfollowUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling unfollowUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/follow`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Unfollow a user
     */
    async unfollowUser(params: UnfollowUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.unfollowUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Unmute a user
     */
    async unmuteUserRaw(params: UnmuteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling unmuteUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/muted`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Unmute a user
     */
    async unmuteUser(params: UnmuteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.unmuteUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Unsubscribe from a user
     */
    async unsubscribeFromUserRaw(params: UnsubscribeFromUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling unsubscribeFromUser.');
        }

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}/subscribers`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Unsubscribe from a user
     */
    async unsubscribeFromUser(params: UnsubscribeFromUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.unsubscribeFromUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Updates an existing user profile
     */
    async updateUserRaw(params: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WriteResponse>> {
        if (params.id === null || params.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter params.id was null or undefined when calling updateUser.');
        }

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

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

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = await this.configuration.accessToken("OAuth2", ["write"]);
            if (token) {
                headerParameters["Authorization"] = token;
            }
        }

        if (!headerParameters["Authorization"] && this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
        }
        if (!headerParameters["Authorization"] && this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("BearerAuth", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(params.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateUserRequestBodyToJSON(params.metadata),
        }, initOverrides);

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

    /**
     * Updates an existing user profile
     */
    async updateUser(params: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WriteResponse> {
        const response = await this.updateUserRaw(params, initOverrides);
        return await response.value();
    }

    /**
     * @hidden
     * Verify if the given jwt ID token was signed by the subject (user) in the payload
     */
    async verifyIDTokenRaw(params: VerifyIDTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerifyToken>> {
        if (params.token === null || params.token === undefined) {
            throw new runtime.RequiredError('token','Required parameter params.token was null or undefined when calling verifyIDToken.');
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Verify if the given jwt ID token was signed by the subject (user) in the payload
     */
    async verifyIDToken(params: VerifyIDTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerifyToken> {
        const response = await this.verifyIDTokenRaw(params, initOverrides);
        return await response.value();
    }

}

/**
 * @export
 */
export const GetAIAttributedTracksByUserHandleSortEnum = {
    Date: 'date',
    Plays: 'plays'
} as const;
export type GetAIAttributedTracksByUserHandleSortEnum = typeof GetAIAttributedTracksByUserHandleSortEnum[keyof typeof GetAIAttributedTracksByUserHandleSortEnum];
/**
 * @export
 */
export const GetAIAttributedTracksByUserHandleSortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetAIAttributedTracksByUserHandleSortMethodEnum = typeof GetAIAttributedTracksByUserHandleSortMethodEnum[keyof typeof GetAIAttributedTracksByUserHandleSortMethodEnum];
/**
 * @export
 */
export const GetAIAttributedTracksByUserHandleSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetAIAttributedTracksByUserHandleSortDirectionEnum = typeof GetAIAttributedTracksByUserHandleSortDirectionEnum[keyof typeof GetAIAttributedTracksByUserHandleSortDirectionEnum];
/**
 * @export
 */
export const GetAIAttributedTracksByUserHandleFilterTracksEnum = {
    All: 'all',
    Public: 'public'
} as const;
export type GetAIAttributedTracksByUserHandleFilterTracksEnum = typeof GetAIAttributedTracksByUserHandleFilterTracksEnum[keyof typeof GetAIAttributedTracksByUserHandleFilterTracksEnum];
/**
 * @export
 */
export const GetAlbumsByUserSortMethodEnum = {
    Recent: 'recent',
    Popular: 'popular'
} as const;
export type GetAlbumsByUserSortMethodEnum = typeof GetAlbumsByUserSortMethodEnum[keyof typeof GetAlbumsByUserSortMethodEnum];
/**
 * @export
 */
export const GetAudioTransactionsSortMethodEnum = {
    Date: 'date',
    TransactionType: 'transaction_type'
} as const;
export type GetAudioTransactionsSortMethodEnum = typeof GetAudioTransactionsSortMethodEnum[keyof typeof GetAudioTransactionsSortMethodEnum];
/**
 * @export
 */
export const GetAudioTransactionsSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetAudioTransactionsSortDirectionEnum = typeof GetAudioTransactionsSortDirectionEnum[keyof typeof GetAudioTransactionsSortDirectionEnum];
/**
 * @export
 */
export const GetPlaylistsByUserSortMethodEnum = {
    Recent: 'recent',
    Popular: 'popular'
} as const;
export type GetPlaylistsByUserSortMethodEnum = typeof GetPlaylistsByUserSortMethodEnum[keyof typeof GetPlaylistsByUserSortMethodEnum];
/**
 * @export
 */
export const GetPurchasesSortMethodEnum = {
    ContentTitle: 'content_title',
    ArtistName: 'artist_name',
    BuyerName: 'buyer_name',
    Date: 'date'
} as const;
export type GetPurchasesSortMethodEnum = typeof GetPurchasesSortMethodEnum[keyof typeof GetPurchasesSortMethodEnum];
/**
 * @export
 */
export const GetPurchasesSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetPurchasesSortDirectionEnum = typeof GetPurchasesSortDirectionEnum[keyof typeof GetPurchasesSortDirectionEnum];
/**
 * @export
 */
export const GetSalesSortMethodEnum = {
    ContentTitle: 'content_title',
    ArtistName: 'artist_name',
    BuyerName: 'buyer_name',
    Date: 'date'
} as const;
export type GetSalesSortMethodEnum = typeof GetSalesSortMethodEnum[keyof typeof GetSalesSortMethodEnum];
/**
 * @export
 */
export const GetSalesSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetSalesSortDirectionEnum = typeof GetSalesSortDirectionEnum[keyof typeof GetSalesSortDirectionEnum];
/**
 * @export
 */
export const GetTracksByUserSortEnum = {
    Date: 'date',
    Plays: 'plays'
} as const;
export type GetTracksByUserSortEnum = typeof GetTracksByUserSortEnum[keyof typeof GetTracksByUserSortEnum];
/**
 * @export
 */
export const GetTracksByUserSortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetTracksByUserSortMethodEnum = typeof GetTracksByUserSortMethodEnum[keyof typeof GetTracksByUserSortMethodEnum];
/**
 * @export
 */
export const GetTracksByUserSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetTracksByUserSortDirectionEnum = typeof GetTracksByUserSortDirectionEnum[keyof typeof GetTracksByUserSortDirectionEnum];
/**
 * @export
 */
export const GetTracksByUserFilterTracksEnum = {
    All: 'all',
    Public: 'public'
} as const;
export type GetTracksByUserFilterTracksEnum = typeof GetTracksByUserFilterTracksEnum[keyof typeof GetTracksByUserFilterTracksEnum];
/**
 * @export
 */
export const GetTracksByUserGateConditionEnum = {
    Ungated: 'ungated',
    UsdcPurchase: 'usdc_purchase',
    Follow: 'follow',
    Tip: 'tip',
    Nft: 'nft',
    Token: 'token'
} as const;
export type GetTracksByUserGateConditionEnum = typeof GetTracksByUserGateConditionEnum[keyof typeof GetTracksByUserGateConditionEnum];
/**
 * @export
 */
export const GetTracksByUserHandleSortEnum = {
    Date: 'date',
    Plays: 'plays'
} as const;
export type GetTracksByUserHandleSortEnum = typeof GetTracksByUserHandleSortEnum[keyof typeof GetTracksByUserHandleSortEnum];
/**
 * @export
 */
export const GetTracksByUserHandleSortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetTracksByUserHandleSortMethodEnum = typeof GetTracksByUserHandleSortMethodEnum[keyof typeof GetTracksByUserHandleSortMethodEnum];
/**
 * @export
 */
export const GetTracksByUserHandleSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetTracksByUserHandleSortDirectionEnum = typeof GetTracksByUserHandleSortDirectionEnum[keyof typeof GetTracksByUserHandleSortDirectionEnum];
/**
 * @export
 */
export const GetTracksByUserHandleFilterTracksEnum = {
    All: 'all',
    Public: 'public'
} as const;
export type GetTracksByUserHandleFilterTracksEnum = typeof GetTracksByUserHandleFilterTracksEnum[keyof typeof GetTracksByUserHandleFilterTracksEnum];
/**
 * @export
 */
export const GetTracksCountByUserFilterTracksEnum = {
    All: 'all',
    Public: 'public'
} as const;
export type GetTracksCountByUserFilterTracksEnum = typeof GetTracksCountByUserFilterTracksEnum[keyof typeof GetTracksCountByUserFilterTracksEnum];
/**
 * @export
 */
export const GetTracksCountByUserGateConditionEnum = {
    Ungated: 'ungated',
    UsdcPurchase: 'usdc_purchase',
    Follow: 'follow',
    Tip: 'tip',
    Nft: 'nft',
    Token: 'token'
} as const;
export type GetTracksCountByUserGateConditionEnum = typeof GetTracksCountByUserGateConditionEnum[keyof typeof GetTracksCountByUserGateConditionEnum];
/**
 * @export
 */
export const GetUSDCTransactionCountTypeEnum = {
    PurchaseContent: 'purchase_content',
    Transfer: 'transfer',
    InternalTransfer: 'internal_transfer',
    PrepareWithdrawal: 'prepare_withdrawal',
    RecoverWithdrawal: 'recover_withdrawal',
    Withdrawal: 'withdrawal',
    PurchaseStripe: 'purchase_stripe'
} as const;
export type GetUSDCTransactionCountTypeEnum = typeof GetUSDCTransactionCountTypeEnum[keyof typeof GetUSDCTransactionCountTypeEnum];
/**
 * @export
 */
export const GetUSDCTransactionCountMethodEnum = {
    Send: 'send',
    Receive: 'receive'
} as const;
export type GetUSDCTransactionCountMethodEnum = typeof GetUSDCTransactionCountMethodEnum[keyof typeof GetUSDCTransactionCountMethodEnum];
/**
 * @export
 */
export const GetUSDCTransactionsSortMethodEnum = {
    Date: 'date',
    TransactionType: 'transaction_type'
} as const;
export type GetUSDCTransactionsSortMethodEnum = typeof GetUSDCTransactionsSortMethodEnum[keyof typeof GetUSDCTransactionsSortMethodEnum];
/**
 * @export
 */
export const GetUSDCTransactionsSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUSDCTransactionsSortDirectionEnum = typeof GetUSDCTransactionsSortDirectionEnum[keyof typeof GetUSDCTransactionsSortDirectionEnum];
/**
 * @export
 */
export const GetUSDCTransactionsTypeEnum = {
    PurchaseContent: 'purchase_content',
    Transfer: 'transfer',
    InternalTransfer: 'internal_transfer',
    PrepareWithdrawal: 'prepare_withdrawal',
    RecoverWithdrawal: 'recover_withdrawal',
    Withdrawal: 'withdrawal',
    PurchaseStripe: 'purchase_stripe'
} as const;
export type GetUSDCTransactionsTypeEnum = typeof GetUSDCTransactionsTypeEnum[keyof typeof GetUSDCTransactionsTypeEnum];
/**
 * @export
 */
export const GetUSDCTransactionsMethodEnum = {
    Send: 'send',
    Receive: 'receive'
} as const;
export type GetUSDCTransactionsMethodEnum = typeof GetUSDCTransactionsMethodEnum[keyof typeof GetUSDCTransactionsMethodEnum];
/**
 * @export
 */
export const GetUserBalanceHistoryGranularityEnum = {
    Hourly: 'hourly',
    Daily: 'daily'
} as const;
export type GetUserBalanceHistoryGranularityEnum = typeof GetUserBalanceHistoryGranularityEnum[keyof typeof GetUserBalanceHistoryGranularityEnum];
/**
 * @export
 */
export const GetUserFavoriteTracksSortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetUserFavoriteTracksSortMethodEnum = typeof GetUserFavoriteTracksSortMethodEnum[keyof typeof GetUserFavoriteTracksSortMethodEnum];
/**
 * @export
 */
export const GetUserFavoriteTracksSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUserFavoriteTracksSortDirectionEnum = typeof GetUserFavoriteTracksSortDirectionEnum[keyof typeof GetUserFavoriteTracksSortDirectionEnum];
/**
 * @export
 */
export const GetUserFeedFilterEnum = {
    All: 'all',
    Repost: 'repost',
    Original: 'original'
} as const;
export type GetUserFeedFilterEnum = typeof GetUserFeedFilterEnum[keyof typeof GetUserFeedFilterEnum];
/**
 * @export
 */
export const GetUserLibraryAlbumsSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUserLibraryAlbumsSortDirectionEnum = typeof GetUserLibraryAlbumsSortDirectionEnum[keyof typeof GetUserLibraryAlbumsSortDirectionEnum];
/**
 * @export
 */
export const GetUserLibraryAlbumsTypeEnum = {
    All: 'all',
    Repost: 'repost',
    Favorite: 'favorite',
    Purchase: 'purchase'
} as const;
export type GetUserLibraryAlbumsTypeEnum = typeof GetUserLibraryAlbumsTypeEnum[keyof typeof GetUserLibraryAlbumsTypeEnum];
/**
 * @export
 */
export const GetUserLibraryAlbumsSortMethodEnum = {
    AddedDate: 'added_date',
    Reposts: 'reposts',
    Saves: 'saves'
} as const;
export type GetUserLibraryAlbumsSortMethodEnum = typeof GetUserLibraryAlbumsSortMethodEnum[keyof typeof GetUserLibraryAlbumsSortMethodEnum];
/**
 * @export
 */
export const GetUserLibraryPlaylistsSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUserLibraryPlaylistsSortDirectionEnum = typeof GetUserLibraryPlaylistsSortDirectionEnum[keyof typeof GetUserLibraryPlaylistsSortDirectionEnum];
/**
 * @export
 */
export const GetUserLibraryPlaylistsTypeEnum = {
    All: 'all',
    Repost: 'repost',
    Favorite: 'favorite',
    Purchase: 'purchase'
} as const;
export type GetUserLibraryPlaylistsTypeEnum = typeof GetUserLibraryPlaylistsTypeEnum[keyof typeof GetUserLibraryPlaylistsTypeEnum];
/**
 * @export
 */
export const GetUserLibraryPlaylistsSortMethodEnum = {
    AddedDate: 'added_date',
    Reposts: 'reposts',
    Saves: 'saves'
} as const;
export type GetUserLibraryPlaylistsSortMethodEnum = typeof GetUserLibraryPlaylistsSortMethodEnum[keyof typeof GetUserLibraryPlaylistsSortMethodEnum];
/**
 * @export
 */
export const GetUserLibraryTracksSortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetUserLibraryTracksSortMethodEnum = typeof GetUserLibraryTracksSortMethodEnum[keyof typeof GetUserLibraryTracksSortMethodEnum];
/**
 * @export
 */
export const GetUserLibraryTracksSortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUserLibraryTracksSortDirectionEnum = typeof GetUserLibraryTracksSortDirectionEnum[keyof typeof GetUserLibraryTracksSortDirectionEnum];
/**
 * @export
 */
export const GetUserLibraryTracksTypeEnum = {
    All: 'all',
    Repost: 'repost',
    Favorite: 'favorite',
    Purchase: 'purchase'
} as const;
export type GetUserLibraryTracksTypeEnum = typeof GetUserLibraryTracksTypeEnum[keyof typeof GetUserLibraryTracksTypeEnum];
/**
 * @export
 */
export const GetUserRecommendedTracksTimeRangeEnum = {
    Week: 'week',
    Month: 'month',
    AllTime: 'allTime'
} as const;
export type GetUserRecommendedTracksTimeRangeEnum = typeof GetUserRecommendedTracksTimeRangeEnum[keyof typeof GetUserRecommendedTracksTimeRangeEnum];
/**
 * @export
 */
export const GetUsersTrackHistorySortMethodEnum = {
    Title: 'title',
    ArtistName: 'artist_name',
    ReleaseDate: 'release_date',
    LastListenDate: 'last_listen_date',
    AddedDate: 'added_date',
    Plays: 'plays',
    Reposts: 'reposts',
    Saves: 'saves',
    MostListensByUser: 'most_listens_by_user'
} as const;
export type GetUsersTrackHistorySortMethodEnum = typeof GetUsersTrackHistorySortMethodEnum[keyof typeof GetUsersTrackHistorySortMethodEnum];
/**
 * @export
 */
export const GetUsersTrackHistorySortDirectionEnum = {
    Asc: 'asc',
    Desc: 'desc'
} as const;
export type GetUsersTrackHistorySortDirectionEnum = typeof GetUsersTrackHistorySortDirectionEnum[keyof typeof GetUsersTrackHistorySortDirectionEnum];
/**
 * @export
 */
export const SearchUsersSortMethodEnum = {
    Relevant: 'relevant',
    Popular: 'popular',
    Recent: 'recent'
} as const;
export type SearchUsersSortMethodEnum = typeof SearchUsersSortMethodEnum[keyof typeof SearchUsersSortMethodEnum];