@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/CommunityLineupsService.js

@@ -7,7 +7,7 @@ class CommunityLineupsService {
     }
     /**
      * 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.
+     * Create a lineup with custom formation and players. Works for both authenticated and anonymous users.
      * @param requestBody
      * @returns any Lineup created successfully
      * @throws ApiError
@@ -19,18 +19,18 @@ class CommunityLineupsService {
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Validation error - missing required fields`,
-                500: `Server error while creating lineup`,
+                400: `Validation error`,
+                500: `Server error`,
             },
         });
     }
     /**
      * 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
+     * Retrieve all lineups created by the authenticated user with pagination and sorting
+     * @param limit
+     * @param offset
+     * @param sortBy
+     * @param sortOrder
      * @returns any User's lineups retrieved successfully
      * @throws ApiError
      */
@@ -45,86 +45,108 @@ class CommunityLineupsService {
                 'sortOrder': sortOrder,
             },
             errors: {
-                401: `Authentication required`,
-                500: `Server error while fetching lineups`,
+                401: `Unauthorized`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Browse public lineups
+     * Search and filter public lineups with pagination and sorting
+     * @param search
+     * @param formation
+     * @param mode
+     * @param sortBy
+     * @param sortOrder
+     * @param limit
+     * @param offset
+     * @returns any Public lineups retrieved successfully
      * @throws ApiError
      */
-    getApiV1CommunityLineups1(id) {
+    getApiV1CommunityLineupsBrowse(search, formation, mode, sortBy, sortOrder, limit = 20, offset) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/community/lineups/{id}',
-            path: {
-                'id': id,
+            url: '/api/v1/community/lineups/browse',
+            query: {
+                'search': search,
+                'formation': formation,
+                'mode': mode,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+                'limit': limit,
+                'offset': offset,
             },
             errors: {
-                400: `Lineup ID is required`,
-                403: `Permission denied - lineup is private`,
-                404: `Lineup not found`,
-                500: `Server error while fetching lineup`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * Update lineup
-     * Update an existing lineup. Only the owner can update their lineup.
-     * @param id Lineup ID
-     * @param requestBody
-     * @returns any Lineup updated successfully
+     * Get trending lineups
+     * Retrieve the most viewed lineups in the last 7 days
+     * @param search
+     * @param formation
+     * @param mode
+     * @param sortBy
+     * @param sortOrder
+     * @param limit
+     * @param offset
+     * @returns any Trending lineups retrieved successfully
      * @throws ApiError
      */
-    putApiV1CommunityLineups(id, requestBody) {
+    getApiV1CommunityLineupsTrending(search, formation, mode, sortBy, sortOrder, limit = 20, offset) {
         return this.httpRequest.request({
-            method: 'PUT',
-            url: '/api/v1/community/lineups/{id}',
-            path: {
-                'id': id,
+            method: 'GET',
+            url: '/api/v1/community/lineups/trending',
+            query: {
+                'search': search,
+                'formation': formation,
+                'mode': mode,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+                'limit': limit,
+                'offset': offset,
             },
-            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`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * Delete lineup
-     * Delete a lineup. Only the owner can delete their lineup.
-     * @param id Lineup ID
-     * @returns void
+     * Get popular lineups
+     * Retrieve the most viewed lineups of all time
+     * @param search
+     * @param formation
+     * @param mode
+     * @param sortBy
+     * @param sortOrder
+     * @param limit
+     * @param offset
+     * @returns any Popular lineups retrieved successfully
      * @throws ApiError
      */
-    deleteApiV1CommunityLineups(id) {
+    getApiV1CommunityLineupsPopular(search, formation, mode, sortBy, sortOrder, limit = 20, offset) {
         return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/community/lineups/{id}',
-            path: {
-                'id': id,
+            method: 'GET',
+            url: '/api/v1/community/lineups/popular',
+            query: {
+                'search': search,
+                'formation': formation,
+                'mode': mode,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+                'limit': limit,
+                'offset': offset,
             },
             errors: {
-                400: `Invalid lineup ID`,
-                401: `Authentication required`,
-                403: `Permission denied - not the owner`,
-                404: `Lineup not found`,
-                500: `Server error while deleting lineup`,
+                500: `Server error`,
             },
         });
     }
     /**
      * 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
+     * Retrieve a public lineup using its unique share token
+     * @param shareToken
      * @returns any Lineup retrieved successfully
      * @throws ApiError
      */
@@ -137,126 +159,124 @@ class CommunityLineupsService {
             },
             errors: {
                 400: `Share token is required`,
-                404: `Lineup not found or is private`,
-                500: `Server error while fetching lineup`,
+                404: `Lineup not found`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Get lineup by ID
+     * Retrieve a specific lineup by its ID. Returns public lineups or lineups owned by the authenticated user.
+     * @param id
+     * @returns any Lineup retrieved successfully
      * @throws ApiError
      */
-    postApiV1CommunityLineupsClaim(id) {
+    getApiV1CommunityLineups1(id) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/community/lineups/{id}/claim',
+            method: 'GET',
+            url: '/api/v1/community/lineups/{id}',
             path: {
                 'id': id,
             },
             errors: {
-                400: `Invalid lineup ID or validation error`,
-                401: `Authentication required`,
-                403: `Lineup already has an owner`,
+                403: `Permission denied`,
                 404: `Lineup not found`,
-                500: `Server error while claiming lineup`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Update lineup
+     * Update an existing lineup. Only the owner can update their lineup.
+     * @param id
+     * @param requestBody
+     * @returns any Lineup updated successfully
      * @throws ApiError
      */
-    getApiV1CommunityLineupsBrowse(search, formation, mode, sortBy = 'createdAt', sortOrder = 'desc', limit = 20, offset) {
+    putApiV1CommunityLineups(id, requestBody) {
         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,
+            method: 'PUT',
+            url: '/api/v1/community/lineups/{id}',
+            path: {
+                'id': id,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                500: `Server error while browsing lineups`,
+                401: `Unauthorized`,
+                403: `Permission denied`,
+                404: `Lineup not found`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Delete lineup
+     * Delete a lineup. Only the owner can delete their lineup.
+     * @param id
+     * @returns void
      * @throws ApiError
      */
-    getApiV1CommunityLineupsTrending(limit = 10) {
+    deleteApiV1CommunityLineups(id) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/community/lineups/trending',
-            query: {
-                'limit': limit,
+            method: 'DELETE',
+            url: '/api/v1/community/lineups/{id}',
+            path: {
+                'id': id,
             },
             errors: {
-                500: `Server error while fetching trending lineups`,
+                401: `Unauthorized`,
+                403: `Permission denied`,
+                404: `Lineup not found`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Export lineup as image
+     * Export a lineup as an SVG image or data URL
+     * @param id
+     * @param format
+     * @returns any Lineup exported successfully
      * @throws ApiError
      */
-    getApiV1CommunityLineupsPopular(limit = 10) {
+    getApiV1CommunityLineupsExport(id, format = 'svg') {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/community/lineups/popular',
+            url: '/api/v1/community/lineups/{id}/export',
+            path: {
+                'id': id,
+            },
             query: {
-                'limit': limit,
+                'format': format,
             },
             errors: {
-                500: `Server error while fetching popular lineups`,
+                400: `Invalid format`,
+                403: `Permission denied`,
+                404: `Lineup not found`,
+                500: `Server error`,
             },
         });
     }
     /**
-     * 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
+     * Claim anonymous lineup
+     * Claim ownership of an anonymous lineup.
+     * @param id
+     * @returns any Lineup claimed successfully
      * @throws ApiError
      */
-    getApiV1CommunityLineupsExport(id, format = 'svg') {
+    postApiV1CommunityLineupsClaim(id) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/community/lineups/{id}/export',
+            method: 'POST',
+            url: '/api/v1/community/lineups/{id}/claim',
             path: {
                 'id': id,
             },
-            query: {
-                'format': format,
-            },
             errors: {
-                400: `Invalid lineup ID or format`,
-                403: `Permission denied - lineup is private`,
+                401: `Unauthorized`,
+                403: `Lineup already has an owner`,
                 404: `Lineup not found`,
-                500: `Server error while exporting lineup`,
+                500: `Server error`,
             },
         });
     }

package/dist/services/CommunityMatchCommentsService.d.ts

@@ -0,0 +1,117 @@
+import type { CommentLikeResponse } from '../models/CommentLikeResponse';
+import type { MatchCommentResponse } from '../models/MatchCommentResponse';
+import type { UserCommentStatsResponse } from '../models/UserCommentStatsResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class CommunityMatchCommentsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Post a comment on a match
+     * Post a new comment or reply to an existing comment
+     * @param requestBody
+     * @returns any Comment posted successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityMatchComments(requestBody?: {
+        fixtureId: string;
+        content: string;
+        parentId?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: MatchCommentResponse;
+        message?: string;
+    }>;
+    /**
+     * Get user's comment statistics
+     * Retrieve statistics about the authenticated user's comment activity
+     * @returns any Statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchCommentsUserStats(): CancelablePromise<{
+        success: boolean;
+        data: UserCommentStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get comments for a match
+     * Retrieve top-level comments for a specific match with pagination
+     * @param fixtureId
+     * @param limit
+     * @param offset
+     * @returns any Comments retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchComments(fixtureId: string, limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: {
+            items: Array<MatchCommentResponse>;
+            pagination: {
+                total: number;
+                limit: number;
+                offset: number;
+                hasMore: boolean;
+            };
+        };
+    }>;
+    /**
+     * Get replies to a comment
+     * Retrieve all replies to a specific comment
+     * @param commentId
+     * @param limit
+     * @param offset
+     * @returns any Replies retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchCommentsReplies(commentId: string, limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: {
+            items: Array<MatchCommentResponse>;
+            pagination: {
+                total: number;
+                limit: number;
+                offset: number;
+                hasMore: boolean;
+            };
+        };
+    }>;
+    /**
+     * Like or unlike a comment
+     * Toggle like status on a comment
+     * @param commentId
+     * @returns any Like toggled successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityMatchCommentsLike(commentId: string): CancelablePromise<{
+        success: boolean;
+        data: CommentLikeResponse;
+        message?: string;
+    }>;
+    /**
+     * Edit a comment
+     * Edit your own comment
+     * @param commentId
+     * @param requestBody
+     * @returns any Comment updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunityMatchComments(commentId: string, requestBody?: {
+        content: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: MatchCommentResponse;
+        message?: string;
+    }>;
+    /**
+     * Delete a comment
+     * Soft delete your own comment
+     * @param commentId
+     * @returns any Comment deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1CommunityMatchComments(commentId: string): CancelablePromise<{
+        success: boolean;
+        data: any;
+        message?: string;
+    }>;
+}

package/dist/services/CommunityMatchCommentsService.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityMatchCommentsService = void 0;
+class CommunityMatchCommentsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Post a comment on a match
+     * Post a new comment or reply to an existing comment
+     * @param requestBody
+     * @returns any Comment posted successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityMatchComments(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/match-comments',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error`,
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get user's comment statistics
+     * Retrieve statistics about the authenticated user's comment activity
+     * @returns any Statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchCommentsUserStats() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/match-comments/user/stats',
+            errors: {
+                401: `Unauthorized`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get comments for a match
+     * Retrieve top-level comments for a specific match with pagination
+     * @param fixtureId
+     * @param limit
+     * @param offset
+     * @returns any Comments retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchComments(fixtureId, limit = 20, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/match-comments/{fixtureId}',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            query: {
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                400: `Fixture ID is required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get replies to a comment
+     * Retrieve all replies to a specific comment
+     * @param commentId
+     * @param limit
+     * @param offset
+     * @returns any Replies retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityMatchCommentsReplies(commentId, limit = 20, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/match-comments/{commentId}/replies',
+            path: {
+                'commentId': commentId,
+            },
+            query: {
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                400: `Comment ID is required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Like or unlike a comment
+     * Toggle like status on a comment
+     * @param commentId
+     * @returns any Like toggled successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityMatchCommentsLike(commentId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/match-comments/{commentId}/like',
+            path: {
+                'commentId': commentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Comment not found`,
+            },
+        });
+    }
+    /**
+     * Edit a comment
+     * Edit your own comment
+     * @param commentId
+     * @param requestBody
+     * @returns any Comment updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunityMatchComments(commentId, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/community/match-comments/{commentId}',
+            path: {
+                'commentId': commentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error`,
+                401: `Unauthorized`,
+                403: `Not your comment`,
+                404: `Comment not found`,
+            },
+        });
+    }
+    /**
+     * Delete a comment
+     * Soft delete your own comment
+     * @param commentId
+     * @returns any Comment deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1CommunityMatchComments(commentId) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/community/match-comments/{commentId}',
+            path: {
+                'commentId': commentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Not your comment`,
+                404: `Comment not found`,
+            },
+        });
+    }
+}
+exports.CommunityMatchCommentsService = CommunityMatchCommentsService;