@footballbingo/client 1.0.0

package/README.md

@@ -0,0 +1,420 @@
+# @football-bingo/client
+
+> Auto-generated TypeScript client for the Football Bingo API
+
+[![Version](https://img.shields.io/npm/v/@football-bingo/client.svg)](https://www.npmjs.com/package/@football-bingo/client)
+[![License](https://img.shields.io/npm/l/@football-bingo/client.svg)](https://github.com/football-bingo/client/blob/main/LICENSE)
+
+## Features
+
+✅ **100% API Coverage** - Generated directly from OpenAPI specification
+✅ **Fully Typed** - Complete TypeScript support with IntelliSense
+✅ **Auto-Generated** - Stays in sync with API changes
+✅ **Promise-based** - Modern async/await support
+✅ **Tree-shakeable** - Import only what you need
+✅ **Zero Dependencies** - Uses native fetch API
+
+## Installation
+
+```bash
+npm install @football-bingo/client
+```
+
+## Quick Start
+
+```typescript
+import { createClient } from '@football-bingo/client';
+
+// Initialize the client
+const client = createClient({
+  BASE: 'https://api.footballbingo.com',
+  TOKEN: async () => {
+    // Return your auth token (from Clerk, Auth0, etc.)
+    return await getAuthToken();
+  },
+});
+
+// Use the client
+const user = await client.users.getUsersMe();
+const fixtures = await client.contentFixtures.getContentFixtures({
+  status: 'live',
+  limit: 20,
+});
+```
+
+## Configuration
+
+### Basic Configuration
+
+```typescript
+const client = createClient({
+  BASE: 'https://api.footballbingo.com',  // API base URL
+  VERSION: '1.0.0',                        // API version
+  TOKEN: async () => string,               // Auth token provider
+  USERNAME: 'user',                         // Basic auth username
+  PASSWORD: 'pass',                         // Basic auth password
+  HEADERS: {},                              // Additional headers
+  ENCODE_PATH: (path) => path,             // Custom path encoding
+});
+```
+
+### With Clerk Authentication
+
+```typescript
+import { useAuth } from '@clerk/clerk-react';
+import { createClient } from '@football-bingo/client';
+
+function useFootballBingoClient() {
+  const { getToken } = useAuth();
+
+  return createClient({
+    BASE: process.env.REACT_APP_API_URL!,
+    TOKEN: () => getToken(),
+  });
+}
+```
+
+### With Auth0
+
+```typescript
+import { useAuth0 } from '@auth0/auth0-react';
+import { createClient } from '@football-bingo/client';
+
+function useFootballBingoClient() {
+  const { getAccessTokenSilently } = useAuth0();
+
+  return createClient({
+    BASE: process.env.REACT_APP_API_URL!,
+    TOKEN: () => getAccessTokenSilently(),
+  });
+}
+```
+
+## API Services
+
+The client provides access to **40 service modules** covering all API endpoints:
+
+### Core Services
+
+- **users** - User management and profiles
+- **predictor** - Match predictions and stats
+- **contentFixtures** - Football match fixtures
+- **bingo** - Bingo game management
+- **wallet** - User wallet and transactions
+- **store** - In-app purchases and inventory
+- **leaderboards** - Global and category leaderboards
+
+### Content Services
+
+- **contentCountries** - Countries data
+- **contentLeagues** - League information
+- **contentTeams** - Team data and stats
+- **contentPlayers** - Player profiles and statistics
+- **contentNews** - Football news articles
+- **contentOdds** - Betting odds and markets
+- **contentStandings** - League standings
+- **contentStatistics** - Match and player stats
+- **contentTransfers** - Transfer news and history
+- **contentTrophies** - Trophy and honors data
+
+### Community Services
+
+- **communityLineups** - Share and browse lineups
+- **communityTacticsBoards** - Tactical analysis boards
+- **communityTransferPlans** - Transfer planning tool
+- **communitySharedGames** - Share bingo games
+- **communityChallenges** - Community challenges
+- **communityGameChat** - In-game chat
+
+### Game Services
+
+- **bingo** - Bingo game creation and management
+- **bingoGames** - Active games and sessions
+- **bingoBoards** - Player boards and tiles
+- **bingoParticipations** - Game participation
+- **eventPools** - Event pool management
+- **sponsors** - Sponsor management
+
+### Progression Services
+
+- **achievements** - Achievement system
+- **challenges** - Daily and weekly challenges
+- **progression** - User progression and XP
+- **activities** - User activity tracking
+
+### AI & Support Services
+
+- **aiChat** - AI pundit conversations
+- **notifications** - Push notifications
+- **admin** - Admin operations (requires admin role)
+
+## Usage Examples
+
+### Get Current User
+
+```typescript
+const user = await client.users.getUsersMe();
+console.log(`Welcome ${user.username}!`);
+console.log(`Level: ${user.level}, Coins: ${user.coins}`);
+```
+
+### Create a Prediction
+
+```typescript
+const prediction = await client.predictor.postPredictions({
+  requestBody: {
+    fixtureId: 'fixture-123',
+    homeScore: 2,
+    awayScore: 1,
+    result: 'home',
+    confidence: 4,
+  },
+});
+console.log('Prediction created:', prediction.id);
+```
+
+### Get Live Fixtures
+
+```typescript
+const liveFixtures = await client.contentFixtures.getContentFixtures({
+  status: 'live',
+  limit: 10,
+});
+
+liveFixtures.data.forEach(fixture => {
+  console.log(`${fixture.homeTeam.name} vs ${fixture.awayTeam.name}`);
+  console.log(`Score: ${fixture.goals.home}-${fixture.goals.away}`);
+});
+```
+
+### Join a Bingo Game
+
+```typescript
+const game = await client.bingo.postBingoGames({
+  requestBody: {
+    fixtureId: 'fixture-123',
+    isPublic: true,
+    entryFee: 100,
+  },
+});
+
+console.log(`Game created! Session code: ${game.sessionCode}`);
+```
+
+### Get Leaderboard
+
+```typescript
+const leaderboard = await client.leaderboards.getLeaderboards({
+  category: 'predictions',
+  period: 'week',
+});
+
+leaderboard.entries.forEach((entry, index) => {
+  console.log(`${index + 1}. ${entry.username} - ${entry.score} points`);
+});
+```
+
+### Purchase Store Item
+
+```typescript
+const purchase = await client.monetization.postStoreItemsItemIdPurchaseWithCoins({
+  itemId: 'item-uuid',
+  requestBody: { quantity: 1 },
+});
+
+console.log('Purchase successful!');
+console.log('New balance:', purchase.newBalance.coins);
+```
+
+### Get Wallet Balance
+
+```typescript
+const balance = await client.wallet.getWallet();
+console.log(`Coins: ${balance.coins}`);
+console.log(`XP: ${balance.xp}`);
+console.log(`Level: ${balance.level}`);
+```
+
+## Error Handling
+
+```typescript
+import { ApiError } from '@football-bingo/client';
+
+try {
+  await client.predictor.postPredictions({
+    requestBody: predictionData,
+  });
+} catch (error) {
+  if (error instanceof ApiError) {
+    console.error('API Error:', error.status, error.body);
+
+    // Handle specific error codes
+    if (error.status === 400) {
+      console.error('Validation error:', error.body.error.message);
+    } else if (error.status === 401) {
+      // Redirect to login
+      window.location.href = '/login';
+    }
+  } else {
+    console.error('Unknown error:', error);
+  }
+}
+```
+
+## React Integration
+
+### Custom Hook
+
+```typescript
+import { useMemo } from 'react';
+import { useAuth } from '@clerk/clerk-react';
+import { createClient } from '@football-bingo/client';
+
+export function useFootballBingoClient() {
+  const { getToken } = useAuth();
+
+  return useMemo(
+    () =>
+      createClient({
+        BASE: process.env.REACT_APP_API_URL!,
+        TOKEN: () => getToken(),
+      }),
+    [getToken]
+  );
+}
+```
+
+### With React Query
+
+```typescript
+import { useQuery } from '@tanstack/react-query';
+import { useFootballBingoClient } from './useFootballBingoClient';
+
+function useUser() {
+  const client = useFootballBingoClient();
+
+  return useQuery({
+    queryKey: ['user'],
+    queryFn: () => client.users.getUsersMe(),
+  });
+}
+
+function useLiveFixtures() {
+  const client = useFootballBingoClient();
+
+  return useQuery({
+    queryKey: ['fixtures', 'live'],
+    queryFn: () => client.contentFixtures.getContentFixtures({ status: 'live' }),
+    refetchInterval: 30000, // Refetch every 30s
+  });
+}
+```
+
+### Component Example
+
+```typescript
+function PredictionsPage() {
+  const client = useFootballBingoClient();
+  const [predictions, setPredictions] = useState([]);
+
+  useEffect(() => {
+    async function loadPredictions() {
+      const result = await client.predictor.getPredictions();
+      setPredictions(result.data);
+    }
+    loadPredictions();
+  }, [client]);
+
+  return (
+    <div>
+      {predictions.map(prediction => (
+        <PredictionCard key={prediction.id} prediction={prediction} />
+      ))}
+    </div>
+  );
+}
+```
+
+## Advanced Usage
+
+### Custom Request Configuration
+
+```typescript
+// Set global headers
+client.request.config.HEADERS = {
+  'X-Custom-Header': 'value',
+};
+
+// Update base URL at runtime
+client.request.config.BASE = 'https://api-staging.footballbingo.com';
+
+// Update auth token
+client.request.config.TOKEN = async () => newGetTokenFunction();
+```
+
+### Canceling Requests
+
+```typescript
+import { CancelablePromise } from '@football-bingo/client';
+
+const request: CancelablePromise<any> = client.contentFixtures.getContentFixtures();
+
+// Cancel the request
+request.cancel();
+```
+
+## TypeScript Support
+
+All types are automatically inferred:
+
+```typescript
+import type {
+  UserProfileDTO,
+  PredictionDTO,
+  FixtureDTO
+} from '@football-bingo/client';
+
+const user: UserProfileDTO = await client.users.getUsersMe();
+const predictions: PredictionDTO[] = (await client.predictor.getPredictions()).data;
+const fixture: FixtureDetailDTO = await client.contentFixtures.getContentFixturesId({ id: 123 });
+```
+
+## Regenerating the Client
+
+If the API changes, regenerate the client:
+
+```bash
+cd sdk
+npm run generate
+npm run build
+```
+
+This will:
+
+1. Export the latest OpenAPI spec from the backend
+2. Generate fresh TypeScript client code
+3. Compile to JavaScript
+
+## Best Practices
+
+1. **Create client instance once** - Initialize at app root
+2. **Use React Query** - Combine with React Query for caching and state management
+3. **Handle errors globally** - Set up global error handling
+4. **Type everything** - Leverage TypeScript for compile-time safety
+5. **Keep token fresh** - Ensure `TOKEN` function returns valid tokens
+
+## API Documentation
+
+Full API documentation is available at:
+
+- **Development**: <http://localhost:3004/docs>
+- **Production**: <https://api.footballbingo.com/docs>
+
+## Support
+
+- **Issues**: [GitHub Issues](https://github.com/football-bingo/api/issues)
+- **Docs**: [API Documentation](https://docs.footballbingo.com)
+
+## License
+
+ISC

package/dist/FootballBingoClient.d.ts

@@ -0,0 +1,88 @@
+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 { AdminUsersService } from './services/AdminUsersService';
+import { AiChatService } from './services/AiChatService';
+import { ChallengesService } from './services/ChallengesService';
+import { CommunityChallengesService } from './services/CommunityChallengesService';
+import { CommunityGameChatService } from './services/CommunityGameChatService';
+import { CommunityLineupsService } from './services/CommunityLineupsService';
+import { CommunitySharedGamesService } from './services/CommunitySharedGamesService';
+import { CommunityTacticsBoardsService } from './services/CommunityTacticsBoardsService';
+import { CommunityTransferPlansService } from './services/CommunityTransferPlansService';
+import { ContentCountriesService } from './services/ContentCountriesService';
+import { ContentFixturesService } from './services/ContentFixturesService';
+import { ContentLeaguesService } from './services/ContentLeaguesService';
+import { ContentNewsService } from './services/ContentNewsService';
+import { ContentOddsService } from './services/ContentOddsService';
+import { ContentPlayersService } from './services/ContentPlayersService';
+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 { LeaderboardService } from './services/LeaderboardService';
+import { NotificationsService } from './services/NotificationsService';
+import { PredictionsService } from './services/PredictionsService';
+import { ProgressionService } from './services/ProgressionService';
+import { SponsorsService } from './services/SponsorsService';
+import { StoreService } from './services/StoreService';
+import { UserAchievementsDeprecatedService } from './services/UserAchievementsDeprecatedService';
+import { UserActivitiesService } from './services/UserActivitiesService';
+import { UsersService } from './services/UsersService';
+import { WalletService } from './services/WalletService';
+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 adminUsers: AdminUsersService;
+    readonly aiChat: AiChatService;
+    readonly challenges: ChallengesService;
+    readonly communityChallenges: CommunityChallengesService;
+    readonly communityGameChat: CommunityGameChatService;
+    readonly communityLineups: CommunityLineupsService;
+    readonly communitySharedGames: CommunitySharedGamesService;
+    readonly communityTacticsBoards: CommunityTacticsBoardsService;
+    readonly communityTransferPlans: CommunityTransferPlansService;
+    readonly contentCountries: ContentCountriesService;
+    readonly contentFixtures: ContentFixturesService;
+    readonly contentLeagues: ContentLeaguesService;
+    readonly contentNews: ContentNewsService;
+    readonly contentOdds: ContentOddsService;
+    readonly contentPlayers: ContentPlayersService;
+    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 leaderboard: LeaderboardService;
+    readonly notifications: NotificationsService;
+    readonly predictions: PredictionsService;
+    readonly progression: ProgressionService;
+    readonly sponsors: SponsorsService;
+    readonly store: StoreService;
+    readonly userAchievementsDeprecated: UserAchievementsDeprecatedService;
+    readonly userActivities: UserActivitiesService;
+    readonly users: UsersService;
+    readonly wallet: WalletService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+}
+export {};

package/dist/FootballBingoClient.js

@@ -0,0 +1,100 @@
+"use strict";
+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 AdminUsersService_1 = require("./services/AdminUsersService");
+const AiChatService_1 = require("./services/AiChatService");
+const ChallengesService_1 = require("./services/ChallengesService");
+const CommunityChallengesService_1 = require("./services/CommunityChallengesService");
+const CommunityGameChatService_1 = require("./services/CommunityGameChatService");
+const CommunityLineupsService_1 = require("./services/CommunityLineupsService");
+const CommunitySharedGamesService_1 = require("./services/CommunitySharedGamesService");
+const CommunityTacticsBoardsService_1 = require("./services/CommunityTacticsBoardsService");
+const CommunityTransferPlansService_1 = require("./services/CommunityTransferPlansService");
+const ContentCountriesService_1 = require("./services/ContentCountriesService");
+const ContentFixturesService_1 = require("./services/ContentFixturesService");
+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 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 LeaderboardService_1 = require("./services/LeaderboardService");
+const NotificationsService_1 = require("./services/NotificationsService");
+const PredictionsService_1 = require("./services/PredictionsService");
+const ProgressionService_1 = require("./services/ProgressionService");
+const SponsorsService_1 = require("./services/SponsorsService");
+const StoreService_1 = require("./services/StoreService");
+const UserAchievementsDeprecatedService_1 = require("./services/UserAchievementsDeprecatedService");
+const UserActivitiesService_1 = require("./services/UserActivitiesService");
+const UsersService_1 = require("./services/UsersService");
+const WalletService_1 = require("./services/WalletService");
+class FootballBingoClient {
+    constructor(config, HttpRequest = FetchHttpRequest_1.FetchHttpRequest) {
+        this.request = new HttpRequest({
+            BASE: config?.BASE ?? 'http://localhost:3004',
+            VERSION: config?.VERSION ?? '1.0.0',
+            WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+            CREDENTIALS: config?.CREDENTIALS ?? 'include',
+            TOKEN: config?.TOKEN,
+            USERNAME: config?.USERNAME,
+            PASSWORD: config?.PASSWORD,
+            HEADERS: config?.HEADERS,
+            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.adminUsers = new AdminUsersService_1.AdminUsersService(this.request);
+        this.aiChat = new AiChatService_1.AiChatService(this.request);
+        this.challenges = new ChallengesService_1.ChallengesService(this.request);
+        this.communityChallenges = new CommunityChallengesService_1.CommunityChallengesService(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.communityTacticsBoards = new CommunityTacticsBoardsService_1.CommunityTacticsBoardsService(this.request);
+        this.communityTransferPlans = new CommunityTransferPlansService_1.CommunityTransferPlansService(this.request);
+        this.contentCountries = new ContentCountriesService_1.ContentCountriesService(this.request);
+        this.contentFixtures = new ContentFixturesService_1.ContentFixturesService(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.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.leaderboard = new LeaderboardService_1.LeaderboardService(this.request);
+        this.notifications = new NotificationsService_1.NotificationsService(this.request);
+        this.predictions = new PredictionsService_1.PredictionsService(this.request);
+        this.progression = new ProgressionService_1.ProgressionService(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.userActivities = new UserActivitiesService_1.UserActivitiesService(this.request);
+        this.users = new UsersService_1.UsersService(this.request);
+        this.wallet = new WalletService_1.WalletService(this.request);
+    }
+}
+exports.FootballBingoClient = FootballBingoClient;

package/dist/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/core/ApiError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/BaseHttpRequest.d.ts

@@ -0,0 +1,8 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

package/dist/core/BaseHttpRequest.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHttpRequest = void 0;
+class BaseHttpRequest {
+    constructor(config) {
+        this.config = config;
+    }
+}
+exports.BaseHttpRequest = BaseHttpRequest;