@footballbingo/client 1.0.0

package/dist/services/CommunityLineupsService.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityLineupsService = void 0;
+class CommunityLineupsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Create a new lineup
+     * Create a lineup with custom formation and players. Works for both authenticated and anonymous users. Anonymous lineups can later be claimed by authenticated users.
+     * @param requestBody
+     * @returns any Lineup created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityLineups(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/lineups',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error - missing required fields`,
+                500: `Server error while creating lineup`,
+            },
+        });
+    }
+    /**
+     * Get user's lineups
+     * Retrieve all lineups created by the authenticated user with pagination and sorting options
+     * @param limit Number of lineups to return
+     * @param offset Number of lineups to skip
+     * @param sortBy Field to sort by
+     * @param sortOrder Sort order
+     * @returns any User's lineups retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineups(limit = 20, offset, sortBy = 'createdAt', sortOrder = 'desc') {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups',
+            query: {
+                'limit': limit,
+                'offset': offset,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+            },
+            errors: {
+                401: `Authentication required`,
+                500: `Server error while fetching lineups`,
+            },
+        });
+    }
+    /**
+     * Get lineup by ID
+     * Retrieve a specific lineup by its ID. Returns public lineups or lineups owned by the authenticated user.
+     * @param id Lineup ID
+     * @returns any Lineup retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineups1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Lineup ID is required`,
+                403: `Permission denied - lineup is private`,
+                404: `Lineup not found`,
+                500: `Server error while fetching lineup`,
+            },
+        });
+    }
+    /**
+     * Update lineup
+     * Update an existing lineup. Only the owner can update their lineup.
+     * @param id Lineup ID
+     * @param requestBody
+     * @returns any Lineup updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunityLineups(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/community/lineups/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid lineup ID`,
+                401: `Authentication required`,
+                403: `Permission denied - not the owner`,
+                404: `Lineup not found`,
+                500: `Server error while updating lineup`,
+            },
+        });
+    }
+    /**
+     * Delete lineup
+     * Delete a lineup. Only the owner can delete their lineup.
+     * @param id Lineup ID
+     * @returns void
+     * @throws ApiError
+     */
+    deleteApiV1CommunityLineups(id) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/community/lineups/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Invalid lineup ID`,
+                401: `Authentication required`,
+                403: `Permission denied - not the owner`,
+                404: `Lineup not found`,
+                500: `Server error while deleting lineup`,
+            },
+        });
+    }
+    /**
+     * Get lineup by share token
+     * Retrieve a public lineup using its unique share token. This endpoint is accessible without authentication for public lineups.
+     * @param shareToken Unique share token for the lineup
+     * @returns any Lineup retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineupsShare(shareToken) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/share/{shareToken}',
+            path: {
+                'shareToken': shareToken,
+            },
+            errors: {
+                400: `Share token is required`,
+                404: `Lineup not found or is private`,
+                500: `Server error while fetching lineup`,
+            },
+        });
+    }
+    /**
+     * Claim anonymous lineup
+     * Claim ownership of an anonymous lineup. Allows authenticated users to take ownership of lineups they created while not logged in.
+     * @param id Lineup ID
+     * @returns any Lineup claimed successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityLineupsClaim(id) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/lineups/{id}/claim',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Invalid lineup ID or validation error`,
+                401: `Authentication required`,
+                403: `Lineup already has an owner`,
+                404: `Lineup not found`,
+                500: `Server error while claiming lineup`,
+            },
+        });
+    }
+    /**
+     * Browse public lineups
+     * Search and filter public lineups with pagination and sorting. Supports filtering by formation, mode, and search text.
+     * @param search Search text for lineup title or description
+     * @param formation Filter by formation ID
+     * @param mode Filter by lineup mode
+     * @param sortBy Field to sort by
+     * @param sortOrder Sort order
+     * @param limit Number of lineups per page
+     * @param offset Number of lineups to skip
+     * @returns any Lineups retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineupsBrowse(search, formation, mode, sortBy = 'createdAt', sortOrder = 'desc', limit = 20, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/browse',
+            query: {
+                'search': search,
+                'formation': formation,
+                'mode': mode,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                500: `Server error while browsing lineups`,
+            },
+        });
+    }
+    /**
+     * Get trending lineups
+     * Retrieve the most viewed lineups in the last 7 days
+     * @param limit Number of trending lineups to return
+     * @returns any Trending lineups retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineupsTrending(limit = 10) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/trending',
+            query: {
+                'limit': limit,
+            },
+            errors: {
+                500: `Server error while fetching trending lineups`,
+            },
+        });
+    }
+    /**
+     * Get popular lineups
+     * Retrieve the most viewed lineups of all time
+     * @param limit Number of popular lineups to return
+     * @returns any Popular lineups retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineupsPopular(limit = 10) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/popular',
+            query: {
+                'limit': limit,
+            },
+            errors: {
+                500: `Server error while fetching popular lineups`,
+            },
+        });
+    }
+    /**
+     * Export lineup as image
+     * Export a lineup as an SVG image or data URL. Optional authentication to access private lineups.
+     * @param id Lineup ID
+     * @param format Export format
+     * @returns any Lineup exported successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityLineupsExport(id, format = 'svg') {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/lineups/{id}/export',
+            path: {
+                'id': id,
+            },
+            query: {
+                'format': format,
+            },
+            errors: {
+                400: `Invalid lineup ID or format`,
+                403: `Permission denied - lineup is private`,
+                404: `Lineup not found`,
+                500: `Server error while exporting lineup`,
+            },
+        });
+    }
+}
+exports.CommunityLineupsService = CommunityLineupsService;

package/dist/services/CommunitySharedGamesService.d.ts

@@ -0,0 +1,124 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { SharedGameDTO } from '../models/SharedGameDTO';
+import type { ShareGameRequestDTO } from '../models/ShareGameRequestDTO';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class CommunitySharedGamesService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create a shared game entry
+     * Creates a new shared game record (admin/internal use)
+     * @param requestBody
+     * @returns any Shared game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunitySharedGames(requestBody: ShareGameRequestDTO): CancelablePromise<(ApiResponseDTO & {
+        data?: SharedGameDTO;
+    })>;
+    /**
+     * List all shared games
+     * Retrieves a list of all shared games
+     * @returns any Shared games retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunitySharedGames(): CancelablePromise<{
+        success?: boolean;
+        data?: Array<SharedGameDTO>;
+    }>;
+    /**
+     * Get shared game by ID
+     * Retrieves a specific shared game by ID
+     * @param id Shared game ID
+     * @returns any Shared game retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunitySharedGames1(id: string): CancelablePromise<(ApiResponseDTO & {
+        data?: SharedGameDTO;
+    })>;
+    /**
+     * Update a shared game
+     * Updates an existing shared game
+     * @param id Shared game ID
+     * @param requestBody
+     * @returns any Shared game updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunitySharedGames(id: string, requestBody: ShareGameRequestDTO): CancelablePromise<(ApiResponseDTO & {
+        data?: SharedGameDTO;
+    })>;
+    /**
+     * Delete a shared game
+     * Deletes a shared game
+     * @param id Shared game ID
+     * @returns any Shared game deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1CommunitySharedGames(id: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+        };
+    }>;
+    /**
+     * Share a game
+     * Creates a shareable public link for a game
+     * @param gameId Game ID to share
+     * @param requestBody
+     * @returns any Game shared successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityGamesShare(gameId: string, requestBody?: {
+        /**
+         * Optional message to include with the share
+         */
+        message?: string;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            publicUrl?: string;
+        };
+    }>;
+    /**
+     * Get shared game by public ID
+     * Retrieves a shared game using its public ID and increments visit count
+     * @param publicId Public ID of the shared game
+     * @returns any Shared game retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityShared(publicId: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            /**
+             * Public ID
+             */
+            id?: string;
+            gameId?: string;
+            /**
+             * Username of the user who shared
+             */
+            sharedBy?: string;
+            boardSize?: number;
+            markedTiles?: Array<number>;
+            tiles?: Array<Record<string, any>>;
+            message?: string | null;
+            eventPool?: string | null;
+            createdAt?: string;
+            expiresAt?: string | null;
+        };
+    }>;
+    /**
+     * Create challenge game from shared game
+     * Creates a new game from a shared game to compete against the original player
+     * @param publicId Public ID of the shared game
+     * @returns any Challenge game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunitySharedChallenge(publicId: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+            gameId?: string;
+        };
+    }>;
+}

package/dist/services/CommunitySharedGamesService.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunitySharedGamesService = void 0;
+class CommunitySharedGamesService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Create a shared game entry
+     * Creates a new shared game record (admin/internal use)
+     * @param requestBody
+     * @returns any Shared game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunitySharedGames(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/shared-games',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all shared games
+     * Retrieves a list of all shared games
+     * @returns any Shared games retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunitySharedGames() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/shared-games',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get shared game by ID
+     * Retrieves a specific shared game by ID
+     * @param id Shared game ID
+     * @returns any Shared game retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunitySharedGames1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/shared-games/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Shared game not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Update a shared game
+     * Updates an existing shared game
+     * @param id Shared game ID
+     * @param requestBody
+     * @returns any Shared game updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunitySharedGames(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/community/shared-games/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Shared game not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Delete a shared game
+     * Deletes a shared game
+     * @param id Shared game ID
+     * @returns any Shared game deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1CommunitySharedGames(id) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/community/shared-games/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Shared game not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Share a game
+     * Creates a shareable public link for a game
+     * @param gameId Game ID to share
+     * @param requestBody
+     * @returns any Game shared successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityGamesShare(gameId, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/games/{gameId}/share',
+            path: {
+                'gameId': gameId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - invalid game ID`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get shared game by public ID
+     * Retrieves a shared game using its public ID and increments visit count
+     * @param publicId Public ID of the shared game
+     * @returns any Shared game retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityShared(publicId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/shared/{publicId}',
+            path: {
+                'publicId': publicId,
+            },
+            errors: {
+                400: `Bad request - public ID required`,
+                404: `Shared game not found or expired`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create challenge game from shared game
+     * Creates a new game from a shared game to compete against the original player
+     * @param publicId Public ID of the shared game
+     * @returns any Challenge game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunitySharedChallenge(publicId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/shared/{publicId}/challenge',
+            path: {
+                'publicId': publicId,
+            },
+            errors: {
+                400: `Bad request - invalid public ID`,
+                401: `Unauthorized - authentication required`,
+                404: `Shared game not found or expired`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.CommunitySharedGamesService = CommunitySharedGamesService;