@footballbingo/client 1.0.0 → 2.0.0

package/dist/FootballBingoClient.d.ts

@@ -1,87 +1,113 @@
 import type { BaseHttpRequest } from './core/BaseHttpRequest';
 import type { OpenAPIConfig } from './core/OpenAPI';
 import { AchievementsService } from './services/AchievementsService';
-import { AchievementsDeprecatedService } from './services/AchievementsDeprecatedService';
 import { ActivitiesService } from './services/ActivitiesService';
 import { AdminService } from './services/AdminService';
-import { AdminPurchasesService } from './services/AdminPurchasesService';
+import { AdminModerationService } from './services/AdminModerationService';
 import { AdminUsersService } from './services/AdminUsersService';
 import { AiChatService } from './services/AiChatService';
+import { BingoService } from './services/BingoService';
+import { BingoPacksService } from './services/BingoPacksService';
 import { ChallengesService } from './services/ChallengesService';
-import { CommunityChallengesService } from './services/CommunityChallengesService';
+import { CommunitiesService } from './services/CommunitiesService';
+import { CommunityFollowService } from './services/CommunityFollowService';
 import { CommunityGameChatService } from './services/CommunityGameChatService';
 import { CommunityLineupsService } from './services/CommunityLineupsService';
-import { CommunitySharedGamesService } from './services/CommunitySharedGamesService';
+import { CommunityMatchCommentsService } from './services/CommunityMatchCommentsService';
+import { CommunityMatchRatingsService } from './services/CommunityMatchRatingsService';
+import { CommunityPostsService } from './services/CommunityPostsService';
+import { CommunityReportsService } from './services/CommunityReportsService';
 import { CommunityTacticsBoardsService } from './services/CommunityTacticsBoardsService';
 import { CommunityTransferPlansService } from './services/CommunityTransferPlansService';
+import { ConfigService } from './services/ConfigService';
 import { ContentCountriesService } from './services/ContentCountriesService';
 import { ContentFixturesService } from './services/ContentFixturesService';
+import { ContentHeadToHeadService } from './services/ContentHeadToHeadService';
 import { ContentLeaguesService } from './services/ContentLeaguesService';
 import { ContentNewsService } from './services/ContentNewsService';
 import { ContentOddsService } from './services/ContentOddsService';
 import { ContentPlayersService } from './services/ContentPlayersService';
+import { ContentRoundsService } from './services/ContentRoundsService';
+import { ContentSeasonsService } from './services/ContentSeasonsService';
 import { ContentStandingsService } from './services/ContentStandingsService';
 import { ContentStatisticsService } from './services/ContentStatisticsService';
 import { ContentTeamsService } from './services/ContentTeamsService';
 import { ContentTransfersService } from './services/ContentTransfersService';
 import { ContentTrophiesService } from './services/ContentTrophiesService';
-import { DailyChallengeCompletionsDeprecatedService } from './services/DailyChallengeCompletionsDeprecatedService';
-import { DailyChallengesDeprecatedService } from './services/DailyChallengesDeprecatedService';
 import { DailyLoginService } from './services/DailyLoginService';
-import { DailyStreaksDeprecatedService } from './services/DailyStreaksDeprecatedService';
 import { EventPoolsService } from './services/EventPoolsService';
+import { FlashPredictionsService } from './services/FlashPredictionsService';
 import { LeaderboardService } from './services/LeaderboardService';
+import { MiniGamesService } from './services/MiniGamesService';
 import { NotificationsService } from './services/NotificationsService';
 import { PredictionsService } from './services/PredictionsService';
+import { PreferencesStarredItemsService } from './services/PreferencesStarredItemsService';
 import { ProgressionService } from './services/ProgressionService';
+import { ReferralService } from './services/ReferralService';
+import { RewardsService } from './services/RewardsService';
+import { ShareService } from './services/ShareService';
 import { SponsorsService } from './services/SponsorsService';
-import { StoreService } from './services/StoreService';
-import { UserAchievementsDeprecatedService } from './services/UserAchievementsDeprecatedService';
+import { StakesService } from './services/StakesService';
+import { SubscriptionsService } from './services/SubscriptionsService';
 import { UserActivitiesService } from './services/UserActivitiesService';
 import { UsersService } from './services/UsersService';
 import { WalletService } from './services/WalletService';
+import { WebhooksService } from './services/WebhooksService';
 type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
 export declare class FootballBingoClient {
     readonly achievements: AchievementsService;
-    readonly achievementsDeprecated: AchievementsDeprecatedService;
     readonly activities: ActivitiesService;
     readonly admin: AdminService;
-    readonly adminPurchases: AdminPurchasesService;
+    readonly adminModeration: AdminModerationService;
     readonly adminUsers: AdminUsersService;
     readonly aiChat: AiChatService;
+    readonly bingo: BingoService;
+    readonly bingoPacks: BingoPacksService;
     readonly challenges: ChallengesService;
-    readonly communityChallenges: CommunityChallengesService;
+    readonly communities: CommunitiesService;
+    readonly communityFollow: CommunityFollowService;
     readonly communityGameChat: CommunityGameChatService;
     readonly communityLineups: CommunityLineupsService;
-    readonly communitySharedGames: CommunitySharedGamesService;
+    readonly communityMatchComments: CommunityMatchCommentsService;
+    readonly communityMatchRatings: CommunityMatchRatingsService;
+    readonly communityPosts: CommunityPostsService;
+    readonly communityReports: CommunityReportsService;
     readonly communityTacticsBoards: CommunityTacticsBoardsService;
     readonly communityTransferPlans: CommunityTransferPlansService;
+    readonly config: ConfigService;
     readonly contentCountries: ContentCountriesService;
     readonly contentFixtures: ContentFixturesService;
+    readonly contentHeadToHead: ContentHeadToHeadService;
     readonly contentLeagues: ContentLeaguesService;
     readonly contentNews: ContentNewsService;
     readonly contentOdds: ContentOddsService;
     readonly contentPlayers: ContentPlayersService;
+    readonly contentRounds: ContentRoundsService;
+    readonly contentSeasons: ContentSeasonsService;
     readonly contentStandings: ContentStandingsService;
     readonly contentStatistics: ContentStatisticsService;
     readonly contentTeams: ContentTeamsService;
     readonly contentTransfers: ContentTransfersService;
     readonly contentTrophies: ContentTrophiesService;
-    readonly dailyChallengeCompletionsDeprecated: DailyChallengeCompletionsDeprecatedService;
-    readonly dailyChallengesDeprecated: DailyChallengesDeprecatedService;
     readonly dailyLogin: DailyLoginService;
-    readonly dailyStreaksDeprecated: DailyStreaksDeprecatedService;
     readonly eventPools: EventPoolsService;
+    readonly flashPredictions: FlashPredictionsService;
     readonly leaderboard: LeaderboardService;
+    readonly miniGames: MiniGamesService;
     readonly notifications: NotificationsService;
     readonly predictions: PredictionsService;
+    readonly preferencesStarredItems: PreferencesStarredItemsService;
     readonly progression: ProgressionService;
+    readonly referral: ReferralService;
+    readonly rewards: RewardsService;
+    readonly share: ShareService;
     readonly sponsors: SponsorsService;
-    readonly store: StoreService;
-    readonly userAchievementsDeprecated: UserAchievementsDeprecatedService;
+    readonly stakes: StakesService;
+    readonly subscriptions: SubscriptionsService;
     readonly userActivities: UserActivitiesService;
     readonly users: UsersService;
     readonly wallet: WalletService;
+    readonly webhooks: WebhooksService;
     readonly request: BaseHttpRequest;
     constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
 }

package/dist/FootballBingoClient.js

@@ -3,45 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FootballBingoClient = void 0;
 const FetchHttpRequest_1 = require("./core/FetchHttpRequest");
 const AchievementsService_1 = require("./services/AchievementsService");
-const AchievementsDeprecatedService_1 = require("./services/AchievementsDeprecatedService");
 const ActivitiesService_1 = require("./services/ActivitiesService");
 const AdminService_1 = require("./services/AdminService");
-const AdminPurchasesService_1 = require("./services/AdminPurchasesService");
+const AdminModerationService_1 = require("./services/AdminModerationService");
 const AdminUsersService_1 = require("./services/AdminUsersService");
 const AiChatService_1 = require("./services/AiChatService");
+const BingoService_1 = require("./services/BingoService");
+const BingoPacksService_1 = require("./services/BingoPacksService");
 const ChallengesService_1 = require("./services/ChallengesService");
-const CommunityChallengesService_1 = require("./services/CommunityChallengesService");
+const CommunitiesService_1 = require("./services/CommunitiesService");
+const CommunityFollowService_1 = require("./services/CommunityFollowService");
 const CommunityGameChatService_1 = require("./services/CommunityGameChatService");
 const CommunityLineupsService_1 = require("./services/CommunityLineupsService");
-const CommunitySharedGamesService_1 = require("./services/CommunitySharedGamesService");
+const CommunityMatchCommentsService_1 = require("./services/CommunityMatchCommentsService");
+const CommunityMatchRatingsService_1 = require("./services/CommunityMatchRatingsService");
+const CommunityPostsService_1 = require("./services/CommunityPostsService");
+const CommunityReportsService_1 = require("./services/CommunityReportsService");
 const CommunityTacticsBoardsService_1 = require("./services/CommunityTacticsBoardsService");
 const CommunityTransferPlansService_1 = require("./services/CommunityTransferPlansService");
+const ConfigService_1 = require("./services/ConfigService");
 const ContentCountriesService_1 = require("./services/ContentCountriesService");
 const ContentFixturesService_1 = require("./services/ContentFixturesService");
+const ContentHeadToHeadService_1 = require("./services/ContentHeadToHeadService");
 const ContentLeaguesService_1 = require("./services/ContentLeaguesService");
 const ContentNewsService_1 = require("./services/ContentNewsService");
 const ContentOddsService_1 = require("./services/ContentOddsService");
 const ContentPlayersService_1 = require("./services/ContentPlayersService");
+const ContentRoundsService_1 = require("./services/ContentRoundsService");
+const ContentSeasonsService_1 = require("./services/ContentSeasonsService");
 const ContentStandingsService_1 = require("./services/ContentStandingsService");
 const ContentStatisticsService_1 = require("./services/ContentStatisticsService");
 const ContentTeamsService_1 = require("./services/ContentTeamsService");
 const ContentTransfersService_1 = require("./services/ContentTransfersService");
 const ContentTrophiesService_1 = require("./services/ContentTrophiesService");
-const DailyChallengeCompletionsDeprecatedService_1 = require("./services/DailyChallengeCompletionsDeprecatedService");
-const DailyChallengesDeprecatedService_1 = require("./services/DailyChallengesDeprecatedService");
 const DailyLoginService_1 = require("./services/DailyLoginService");
-const DailyStreaksDeprecatedService_1 = require("./services/DailyStreaksDeprecatedService");
 const EventPoolsService_1 = require("./services/EventPoolsService");
+const FlashPredictionsService_1 = require("./services/FlashPredictionsService");
 const LeaderboardService_1 = require("./services/LeaderboardService");
+const MiniGamesService_1 = require("./services/MiniGamesService");
 const NotificationsService_1 = require("./services/NotificationsService");
 const PredictionsService_1 = require("./services/PredictionsService");
+const PreferencesStarredItemsService_1 = require("./services/PreferencesStarredItemsService");
 const ProgressionService_1 = require("./services/ProgressionService");
+const ReferralService_1 = require("./services/ReferralService");
+const RewardsService_1 = require("./services/RewardsService");
+const ShareService_1 = require("./services/ShareService");
 const SponsorsService_1 = require("./services/SponsorsService");
-const StoreService_1 = require("./services/StoreService");
-const UserAchievementsDeprecatedService_1 = require("./services/UserAchievementsDeprecatedService");
+const StakesService_1 = require("./services/StakesService");
+const SubscriptionsService_1 = require("./services/SubscriptionsService");
 const UserActivitiesService_1 = require("./services/UserActivitiesService");
 const UsersService_1 = require("./services/UsersService");
 const WalletService_1 = require("./services/WalletService");
+const WebhooksService_1 = require("./services/WebhooksService");
 class FootballBingoClient {
     constructor(config, HttpRequest = FetchHttpRequest_1.FetchHttpRequest) {
         this.request = new HttpRequest({
@@ -56,45 +69,58 @@ class FootballBingoClient {
             ENCODE_PATH: config?.ENCODE_PATH,
         });
         this.achievements = new AchievementsService_1.AchievementsService(this.request);
-        this.achievementsDeprecated = new AchievementsDeprecatedService_1.AchievementsDeprecatedService(this.request);
         this.activities = new ActivitiesService_1.ActivitiesService(this.request);
         this.admin = new AdminService_1.AdminService(this.request);
-        this.adminPurchases = new AdminPurchasesService_1.AdminPurchasesService(this.request);
+        this.adminModeration = new AdminModerationService_1.AdminModerationService(this.request);
         this.adminUsers = new AdminUsersService_1.AdminUsersService(this.request);
         this.aiChat = new AiChatService_1.AiChatService(this.request);
+        this.bingo = new BingoService_1.BingoService(this.request);
+        this.bingoPacks = new BingoPacksService_1.BingoPacksService(this.request);
         this.challenges = new ChallengesService_1.ChallengesService(this.request);
-        this.communityChallenges = new CommunityChallengesService_1.CommunityChallengesService(this.request);
+        this.communities = new CommunitiesService_1.CommunitiesService(this.request);
+        this.communityFollow = new CommunityFollowService_1.CommunityFollowService(this.request);
         this.communityGameChat = new CommunityGameChatService_1.CommunityGameChatService(this.request);
         this.communityLineups = new CommunityLineupsService_1.CommunityLineupsService(this.request);
-        this.communitySharedGames = new CommunitySharedGamesService_1.CommunitySharedGamesService(this.request);
+        this.communityMatchComments = new CommunityMatchCommentsService_1.CommunityMatchCommentsService(this.request);
+        this.communityMatchRatings = new CommunityMatchRatingsService_1.CommunityMatchRatingsService(this.request);
+        this.communityPosts = new CommunityPostsService_1.CommunityPostsService(this.request);
+        this.communityReports = new CommunityReportsService_1.CommunityReportsService(this.request);
         this.communityTacticsBoards = new CommunityTacticsBoardsService_1.CommunityTacticsBoardsService(this.request);
         this.communityTransferPlans = new CommunityTransferPlansService_1.CommunityTransferPlansService(this.request);
+        this.config = new ConfigService_1.ConfigService(this.request);
         this.contentCountries = new ContentCountriesService_1.ContentCountriesService(this.request);
         this.contentFixtures = new ContentFixturesService_1.ContentFixturesService(this.request);
+        this.contentHeadToHead = new ContentHeadToHeadService_1.ContentHeadToHeadService(this.request);
         this.contentLeagues = new ContentLeaguesService_1.ContentLeaguesService(this.request);
         this.contentNews = new ContentNewsService_1.ContentNewsService(this.request);
         this.contentOdds = new ContentOddsService_1.ContentOddsService(this.request);
         this.contentPlayers = new ContentPlayersService_1.ContentPlayersService(this.request);
+        this.contentRounds = new ContentRoundsService_1.ContentRoundsService(this.request);
+        this.contentSeasons = new ContentSeasonsService_1.ContentSeasonsService(this.request);
         this.contentStandings = new ContentStandingsService_1.ContentStandingsService(this.request);
         this.contentStatistics = new ContentStatisticsService_1.ContentStatisticsService(this.request);
         this.contentTeams = new ContentTeamsService_1.ContentTeamsService(this.request);
         this.contentTransfers = new ContentTransfersService_1.ContentTransfersService(this.request);
         this.contentTrophies = new ContentTrophiesService_1.ContentTrophiesService(this.request);
-        this.dailyChallengeCompletionsDeprecated = new DailyChallengeCompletionsDeprecatedService_1.DailyChallengeCompletionsDeprecatedService(this.request);
-        this.dailyChallengesDeprecated = new DailyChallengesDeprecatedService_1.DailyChallengesDeprecatedService(this.request);
         this.dailyLogin = new DailyLoginService_1.DailyLoginService(this.request);
-        this.dailyStreaksDeprecated = new DailyStreaksDeprecatedService_1.DailyStreaksDeprecatedService(this.request);
         this.eventPools = new EventPoolsService_1.EventPoolsService(this.request);
+        this.flashPredictions = new FlashPredictionsService_1.FlashPredictionsService(this.request);
         this.leaderboard = new LeaderboardService_1.LeaderboardService(this.request);
+        this.miniGames = new MiniGamesService_1.MiniGamesService(this.request);
         this.notifications = new NotificationsService_1.NotificationsService(this.request);
         this.predictions = new PredictionsService_1.PredictionsService(this.request);
+        this.preferencesStarredItems = new PreferencesStarredItemsService_1.PreferencesStarredItemsService(this.request);
         this.progression = new ProgressionService_1.ProgressionService(this.request);
+        this.referral = new ReferralService_1.ReferralService(this.request);
+        this.rewards = new RewardsService_1.RewardsService(this.request);
+        this.share = new ShareService_1.ShareService(this.request);
         this.sponsors = new SponsorsService_1.SponsorsService(this.request);
-        this.store = new StoreService_1.StoreService(this.request);
-        this.userAchievementsDeprecated = new UserAchievementsDeprecatedService_1.UserAchievementsDeprecatedService(this.request);
+        this.stakes = new StakesService_1.StakesService(this.request);
+        this.subscriptions = new SubscriptionsService_1.SubscriptionsService(this.request);
         this.userActivities = new UserActivitiesService_1.UserActivitiesService(this.request);
         this.users = new UsersService_1.UsersService(this.request);
         this.wallet = new WalletService_1.WalletService(this.request);
+        this.webhooks = new WebhooksService_1.WebhooksService(this.request);
     }
 }
 exports.FootballBingoClient = FootballBingoClient;

package/dist/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from './types.gen';
+export declare const createClient: (config?: Config) => Client;

package/dist/client/client.gen.js

@@ -0,0 +1,235 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: 'follow',
+            ...opts,
+            body: getValidRequestBody(opts),
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request.fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response;
+        try {
+            response = await _fetch(request);
+        }
+        catch (error) {
+            // Handle fetch exceptions (AbortError, network errors, etc.)
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = (await fn(error, undefined, request, opts));
+                }
+            }
+            finalError = finalError || {};
+            if (opts.throwOnError) {
+                throw finalError;
+            }
+            // Return error response
+            return opts.responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response: undefined,
+                };
+        }
+        for (const fn of interceptors.response.fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            const parseAs = (opts.parseAs === 'auto'
+                ? getParseAs(response.headers.get('Content-Type'))
+                : opts.parseAs) ?? 'json';
+            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                let emptyData;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'text':
+                        emptyData = await response[parseAs]();
+                        break;
+                    case 'formData':
+                        emptyData = new FormData();
+                        break;
+                    case 'stream':
+                        emptyData = response.body;
+                        break;
+                    case 'json':
+                    default:
+                        emptyData = {};
+                        break;
+                }
+                return opts.responseStyle === 'data'
+                    ? emptyData
+                    : {
+                        data: emptyData,
+                        ...result,
+                    };
+            }
+            let data;
+            switch (parseAs) {
+                case 'arrayBuffer':
+                case 'blob':
+                case 'formData':
+                case 'text':
+                    data = await response[parseAs]();
+                    break;
+                case 'json': {
+                    // Some servers return 200 with no Content-Length and empty body.
+                    // response.json() would throw; read as text and parse if non-empty.
+                    const text = await response.text();
+                    data = text ? JSON.parse(text) : {};
+                    break;
+                }
+                case 'stream':
+                    return opts.responseStyle === 'data'
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === 'json') {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === 'data'
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error.fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === 'data'
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+    return {
+        buildUrl: _buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};

package/dist/client/index.d.ts

@@ -0,0 +1,8 @@
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/dist/client/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/dist/client/types.gen.d.ts

@@ -0,0 +1,117 @@
+import type { Auth } from '../core/auth.gen';
+import type { ServerSentEventsOptions, ServerSentEventsResult } from '../core/serverSentEvents.gen';
+import type { Client as CoreClient, Config as CoreConfig } from '../core/types.gen';
+import type { Middleware } from './utils.gen';
+export type ResponseStyle = 'data' | 'fields';
+export interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, CoreConfig {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+export interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+export interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+export interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+export {};

package/dist/client/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};