@bantr-sports/sdk 12.11.0 → 13.0.0

package/api-type/src/modules/chat/chat.repository.d.ts

@@ -1,5 +1,7 @@
+import type { JoinRequest } from '@prisma/client';
 import prisma from '../../database/prisma';
 import { CHAT_TYPES, type CreatePrivateGroupInput, type ListChatsInput, type GetMessagesInput } from './chat.schema';
+import type { JoinRequestNotificationMetadata, JoinRequestTargetType } from '../join_request/join_request.schema';
 type PrismaClientLike = typeof prisma;
 type DbClient = any;
 type CreateContextChatInput = {
@@ -39,6 +41,25 @@ type CreateScoutInviteMessageInput = {
         metaData: Record<string, unknown>;
     };
 };
+type CreateJoinRequestMessageInput = {
+    chatId: number;
+    senderId: number;
+    requesterId: number;
+    content: string;
+    targetType: JoinRequestTargetType;
+    targetId: number;
+    adminMemberId: number;
+    notification: {
+        text: string;
+        textMeta: string;
+        metaData: JoinRequestNotificationMetadata;
+    };
+};
+type CreateJoinRequestMessageResult = {
+    joinRequest: JoinRequest;
+    chatMessage: Awaited<ReturnType<ChatRepository['getChatMessageWithDetails']>>;
+    notificationMemberIds: number[];
+};
 type ReactionInput = {
     chatId: number;
     messageId: string;
@@ -74,6 +95,11 @@ export declare class ChatRepository {
     getScoutInviteByMessageId(messageId: string): Promise<any>;
     listScoutInvites(memberId: number, status?: string): Promise<any>;
     updateScoutInviteStatus(inviteId: number, status: string): Promise<any>;
+    createJoinRequestMessage(input: CreateJoinRequestMessageInput): Promise<CreateJoinRequestMessageResult>;
+    getJoinRequestById(joinRequestId: number): Promise<JoinRequest | null>;
+    getPendingJoinRequest(requesterId: number, targetType: JoinRequestTargetType, targetId: number): Promise<JoinRequest | null>;
+    listJoinRequestsForMember(memberId: number, status?: string): Promise<JoinRequest[]>;
+    updateJoinRequestStatus(joinRequestId: number, status: string, respondedById: number | null): Promise<JoinRequest>;
     votePoll(chatId: number, pollId: number, memberId: number, optionIds: number[]): Promise<any>;
     sendReaction(input: ReactionInput): Promise<any>;
     removeReaction(chatId: number, messageId: string, memberId: number): Promise<{

package/api-type/src/modules/chat/chat.schema.d.ts

@@ -21,6 +21,7 @@ export declare const CHAT_MESSAGE_TYPES: {
     readonly TEXT: "text";
     readonly POLL: "poll";
     readonly INVITE: "invite";
+    readonly JOIN_REQUEST: "join_request";
 };
 export declare const chatTypeSchema: z.ZodEnum<["direct", "private_group", "team", "match", "pickup_group", "pickup"]>;
 export declare const chatMemberRoleSchema: z.ZodEnum<["owner", "admin", "member"]>;

package/api-type/src/modules/chat/chat.service.d.ts

@@ -1,5 +1,6 @@
 import { ChatRepository } from './chat.repository';
 import { type AddMembersInput, type BlockPlayerInput, type ContextChatInput, type CreateDirectChatInput, type CreatePollInput, type CreatePrivateGroupInput, type GetMessagesInput, type ListGroupMemberCandidatesInput, type ListChatsInput, type MessageActionInput, type MemberChatModerationInput, type MemberChatStateInput, type MessageReactionInput, type RemoveMessageReactionInput, type RemoveMemberInput, type SearchMessagesInput, type SendMessageInput, type SetMessageHighlightedInput, type TransferOwnershipInput, type UpdateChatInput, type VotePollInput } from './chat.schema';
+import type { JoinRequestNotificationMetadata, JoinRequestTargetType } from '../join_request/join_request.schema';
 type SendScoutInviteMessageInput = {
     chatId: number;
     content: string;
@@ -15,6 +16,19 @@ type SendScoutInviteMessageInput = {
         metaData: Record<string, unknown>;
     };
 };
+type SendJoinRequestMessageInput = {
+    chatId: number;
+    content: string;
+    requesterId: number;
+    targetType: JoinRequestTargetType;
+    targetId: number;
+    adminMemberId: number;
+    notification: {
+        text: string;
+        textMeta: string;
+        metaData: JoinRequestNotificationMetadata;
+    };
+};
 export declare class ChatService {
     private readonly repository;
     constructor(repository?: ChatRepository);
@@ -58,6 +72,11 @@ export declare class ChatService {
     syncPickupChat(pickupId: number, actorId?: number): Promise<any>;
     sendMessage(actorId: number, input: SendMessageInput): Promise<any>;
     sendScoutInviteMessage(actorId: number, input: SendScoutInviteMessageInput): Promise<any>;
+    sendJoinRequestMessage(actorId: number, input: SendJoinRequestMessageInput): Promise<{
+        joinRequest: JoinRequest;
+        chatMessage: Awaited<ReturnType<ChatRepository["getChatMessageWithDetails"]>>;
+        notificationMemberIds: number[];
+    }>;
     createPoll(actorId: number, input: CreatePollInput): Promise<any>;
     votePoll(actorId: number, input: VotePollInput): Promise<any>;
     sendReaction(actorId: number, input: MessageReactionInput): Promise<any>;

package/api-type/src/modules/free_agent_payments/free_agent_payments.schema.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 export declare const FreeAgentPaymentSchema: z.ZodObject<{
     freeAgentId: z.ZodNumber;
     leagueId: z.ZodOptional<z.ZodNumber>;
-    description: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
     updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
     createdAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
     deletedAt: z.ZodNullable<z.ZodDate>;
@@ -10,14 +10,14 @@ export declare const FreeAgentPaymentSchema: z.ZodObject<{
     deletedAt: Date | null;
     createdAt: string | Date;
     updatedAt: string | Date;
-    description: string;
+    description: string | null;
     freeAgentId: number;
     leagueId?: number | undefined;
 }, {
     deletedAt: Date | null;
     createdAt: string | Date;
     updatedAt: string | Date;
-    description: string;
+    description: string | null;
     freeAgentId: number;
     leagueId?: number | undefined;
 }>;
@@ -25,28 +25,32 @@ export type FreeAgentPaymentSchema = z.infer<typeof FreeAgentPaymentSchema>;
 export declare const RegistrationCheckoutSchema: z.ZodObject<Pick<{
     freeAgentId: z.ZodNumber;
     leagueId: z.ZodOptional<z.ZodNumber>;
-    description: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
     updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
     createdAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
     deletedAt: z.ZodNullable<z.ZodDate>;
-}, "description" | "leagueId" | "freeAgentId"> & {
+}, "leagueId" | "freeAgentId"> & {
+    description: z.ZodEffects<z.ZodNullable<z.ZodString>, string | null, string | null>;
     code: z.ZodOptional<z.ZodString>;
     paymentMode: z.ZodDefault<z.ZodEnum<["session", "intent"]>>;
     cancelPath: z.ZodOptional<z.ZodString>;
+    inviteToken: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    description: string;
+    description: string | null;
     paymentMode: "session" | "intent";
     freeAgentId: number;
     leagueId?: number | undefined;
     code?: string | undefined;
     cancelPath?: string | undefined;
+    inviteToken?: string | undefined;
 }, {
-    description: string;
+    description: string | null;
     freeAgentId: number;
     leagueId?: number | undefined;
     code?: string | undefined;
     paymentMode?: "session" | "intent" | undefined;
     cancelPath?: string | undefined;
+    inviteToken?: string | undefined;
 }>;
 export type RegistrationCheckoutSchema = z.infer<typeof RegistrationCheckoutSchema>;
 export declare const ToggleArchiveSchema: z.ZodObject<{

package/api-type/src/modules/free_agent_payments/free_agent_payments.service.d.ts

@@ -20,7 +20,7 @@ export declare class FreeAgentPaymentsService {
     registerFreeAgentWithoutPayment(options: {
         memberId: number;
         orgFreeAgentId: number;
-        description: string;
+        description: string | null;
         amount: number;
         idempotencyKey: string;
         orgFreeAgentPrice: OrgFreeAgentPrice;

package/api-type/src/modules/join_request/join_request.factory.d.ts

@@ -0,0 +1,4 @@
+import { JoinRequestService } from './join_request.service';
+export declare class JoinRequestFactory {
+    static createInstance(): JoinRequestService;
+}

package/api-type/src/modules/join_request/join_request.schema.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const JOIN_REQUEST_TARGET_TYPES: {
+    readonly PICKUP_GROUP: "PICKUP_GROUP";
+    readonly LEAGUE: "LEAGUE";
+    readonly TEAM: "TEAM";
+};
+export declare const JOIN_REQUEST_STATUSES: {
+    readonly PENDING: "PENDING";
+    readonly ACCEPTED: "ACCEPTED";
+    readonly DECLINED: "DECLINED";
+    readonly CANCELED: "CANCELED";
+    readonly EXPIRED: "EXPIRED";
+};
+export type JoinRequestTargetType = (typeof JOIN_REQUEST_TARGET_TYPES)[keyof typeof JOIN_REQUEST_TARGET_TYPES];
+export type JoinRequestStatus = (typeof JOIN_REQUEST_STATUSES)[keyof typeof JOIN_REQUEST_STATUSES];
+export type JoinRequestNotificationMetadata = {
+    chatId: number;
+    requesterId: number;
+    targetType: JoinRequestTargetType;
+    targetId: number;
+    targetName: string;
+    joinRequestId?: number;
+};
+export declare const createJoinRequestInputSchema: z.ZodObject<{
+    targetType: z.ZodEnum<["PICKUP_GROUP", "LEAGUE", "TEAM"]>;
+    targetId: z.ZodNumber;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    targetId: number;
+    targetType: "LEAGUE" | "PICKUP_GROUP" | "TEAM";
+}, {
+    message: string;
+    targetId: number;
+    targetType: "LEAGUE" | "PICKUP_GROUP" | "TEAM";
+}>;
+export declare const joinRequestIdInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export declare const listJoinRequestsInputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["PENDING", "ACCEPTED", "DECLINED", "CANCELED", "EXPIRED"]>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "PENDING" | "EXPIRED" | "CANCELED" | "ACCEPTED" | "DECLINED" | undefined;
+}, {
+    status?: "PENDING" | "EXPIRED" | "CANCELED" | "ACCEPTED" | "DECLINED" | undefined;
+}>;
+export type CreateJoinRequestInput = z.infer<typeof createJoinRequestInputSchema>;
+export type JoinRequestIdInput = z.infer<typeof joinRequestIdInputSchema>;
+export type ListJoinRequestsInput = z.infer<typeof listJoinRequestsInputSchema>;

package/api-type/src/modules/join_request/join_request.service.d.ts

@@ -0,0 +1,105 @@
+import { ChatRepository } from '../chat/chat.repository';
+import { ChatService } from '../chat/chat.service';
+import { type CreateJoinRequestInput, type JoinRequestIdInput, type ListJoinRequestsInput } from './join_request.schema';
+/**
+ * Player-initiated request-to-join flow. Mirror of `ScoutInviteService` in
+ * reverse: requester (player) → admin (member). v1 only supports PICKUP_GROUP;
+ * LEAGUE / TEAM throw NOT_IMPLEMENTED on create + accept until the target
+ * membership tables are wired in.
+ */
+export declare class JoinRequestService {
+    private readonly chatService;
+    private readonly chatRepository;
+    constructor(chatService: ChatService, chatRepository: ChatRepository);
+    create(actorId: number, input: CreateJoinRequestInput): Promise<{
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyPending: boolean;
+    } | {
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyResponded: boolean;
+    } | {
+        alreadyPending: false;
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: "PENDING";
+        chat: any;
+        chatMessage: any;
+        notificationMemberIds: number[];
+    }>;
+    accept(actorId: number, input: JoinRequestIdInput): Promise<{
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyPending: boolean;
+    } | {
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyResponded: boolean;
+    }>;
+    decline(actorId: number, input: JoinRequestIdInput): Promise<{
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyPending: boolean;
+    } | {
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyResponded: boolean;
+    }>;
+    cancel(actorId: number, input: JoinRequestIdInput): Promise<{
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyPending: boolean;
+    } | {
+        joinRequestId: any;
+        chatId: any;
+        messageId: any;
+        status: any;
+        joinRequest: JoinRequest;
+        alreadyResponded: boolean;
+    }>;
+    get(actorId: number, input: JoinRequestIdInput): Promise<JoinRequest>;
+    list(actorId: number, input: ListJoinRequestsInput): Promise<JoinRequest[]>;
+    private buildResult;
+    private requireJoinRequest;
+    /**
+     * Validates target is pickup group in invite-only mode, requester isn't
+     * already a member, and picks the primary admin (member) to route the card
+     * to. Throws with a specific message per failure mode so the frontend can
+     * surface something meaningful.
+     */
+    private resolvePickupGroupTarget;
+    /**
+     * Primary admin = creator if they're still an active (non-blocked) member,
+     * otherwise the oldest active admin. Chat is member-only, so organizer
+     * creators of org-managed groups can't receive the card — a member-admin
+     * must exist for the flow to work.
+     */
+    private pickPickupGroupPrimaryAdminMemberId;
+    private requireCurrentAdmin;
+    private sendPushNotification;
+    private backfillJoinRequestIdOnNotifications;
+    private getMember;
+}

package/api-type/src/modules/league_invite/league_invite.factory.d.ts

@@ -0,0 +1,4 @@
+import { LeagueInviteService } from './league_invite.service';
+export declare class LeagueInviteFactory {
+    static createInstance(): LeagueInviteService;
+}

package/api-type/src/modules/league_invite/league_invite.schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const GetOrCreateLeagueInviteInputSchema: z.ZodObject<{
+    leagueId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    leagueId: number;
+}, {
+    leagueId: number;
+}>;
+export type GetOrCreateLeagueInviteInput = z.infer<typeof GetOrCreateLeagueInviteInputSchema>;
+export declare const ValidateLeagueInviteInputSchema: z.ZodObject<{
+    leagueId: z.ZodNumber;
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    leagueId: number;
+    token: string;
+}, {
+    leagueId: number;
+    token: string;
+}>;
+export type ValidateLeagueInviteInput = z.infer<typeof ValidateLeagueInviteInputSchema>;
+export type LeagueInviteLinkResp = {
+    url: string;
+    token: string;
+    expiresAt: string;
+};
+export type LeagueInviteValidationResp = {
+    valid: boolean;
+    expiresAt?: string;
+    reason?: 'not_found' | 'expired' | 'inactive' | 'wrong_league';
+};

package/api-type/src/modules/league_invite/league_invite.service.d.ts

@@ -0,0 +1,29 @@
+import type { TransactionOrKnex } from 'objection';
+import { Invite } from '../../models/invite';
+import { League } from '../../models/league';
+import { Organizer } from '../../models/organizer';
+import type { GetOrCreateLeagueInviteInput, LeagueInviteLinkResp, LeagueInviteValidationResp, ValidateLeagueInviteInput } from './league_invite.schema';
+export declare class LeagueInviteService {
+    private readonly InviteModel;
+    private readonly LeagueModel;
+    constructor(InviteModel: typeof Invite, LeagueModel: typeof League);
+    getOrCreate(input: GetOrCreateLeagueInviteInput, organizer: Organizer): Promise<LeagueInviteLinkResp>;
+    /**
+     * Deactivates every active `league_registration` invite for the league.
+     * Called when a league transitions to PUBLIC — prior tokens should not carry
+     * over into a future INVITE_ONLY phase.
+     * Returns the number of rows updated.
+     */
+    invalidateAllActive(leagueId: number, trx?: TransactionOrKnex): Promise<number>;
+    /**
+     * Recomputes the expiration of active (non-expired) invites using the current
+     * league state. Called when `startDate` changes so the boundary stays aligned
+     * with the new schedule — treats the update moment as the generation moment.
+     * Returns the number of rows updated.
+     */
+    refreshExpirationForActive(league: League, trx?: TransactionOrKnex): Promise<number>;
+    validate(input: ValidateLeagueInviteInput): Promise<LeagueInviteValidationResp>;
+    private resolveExpiration;
+    private generateToken;
+    private buildInviteUrl;
+}

package/api-type/src/modules/league_payments/league_payments.schema.d.ts

@@ -312,6 +312,7 @@ export declare const RegistrationCheckoutSchema: z.ZodObject<Pick<{
     paymentMode: z.ZodDefault<z.ZodEnum<["session", "intent"]>>;
     paymentAmount: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, number>>;
     cancelPath: z.ZodOptional<z.ZodString>;
+    inviteToken: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     teamId: number;
     leagueId: number;
@@ -320,6 +321,7 @@ export declare const RegistrationCheckoutSchema: z.ZodObject<Pick<{
     code?: string | undefined;
     paymentAmount?: number | undefined;
     cancelPath?: string | undefined;
+    inviteToken?: string | undefined;
 }, {
     teamId: number;
     leagueId: number;
@@ -328,5 +330,6 @@ export declare const RegistrationCheckoutSchema: z.ZodObject<Pick<{
     paymentMode?: "session" | "intent" | undefined;
     paymentAmount?: number | undefined;
     cancelPath?: string | undefined;
+    inviteToken?: string | undefined;
 }>;
 export type RegistrationCheckoutSchema = z.infer<typeof RegistrationCheckoutSchema>;

package/api-type/src/modules/league_payments/league_payments.service.d.ts

@@ -26,7 +26,7 @@ export declare class LeaguePaymentsService {
     insertOfflinePayment(organizerId: number, { teamRosterId, leagueId, price, offlineMethod }: InsertOfflinePaymentInputSchema): Promise<void>;
     updateOfflinePayment(organizerId: number, { id: paymentId, offlineMethod, price }: UpdateOfflinePaymentInputSchema): Promise<void>;
     deleteOfflinePayment(organizerId: number, { id: paymentId }: DeleteOfflinePaymentInputSchema): Promise<void>;
-    registrationCheckout(memberId: number, { leagueId, teamId, paymentType, code, paymentMode, paymentAmount, cancelPath }: RegistrationCheckoutSchema): Promise<{
+    registrationCheckout(memberId: number, { leagueId, teamId, paymentType, code, paymentMode, paymentAmount, cancelPath, inviteToken }: RegistrationCheckoutSchema): Promise<{
         customerId: string;
         ephemeralKey?: string;
         orgPublishableKey?: string;

package/api-type/src/modules/marketplace/marketplace.schema.d.ts

@@ -50,6 +50,10 @@ export declare enum LeagueFormat {
     Ten_V_Ten = "10v10",
     Eleven_V_Eleven = "11v11"
 }
+export declare enum RegistrationPolicy {
+    PUBLIC = "PUBLIC",
+    INVITE_ONLY = "INVITE_ONLY"
+}
 type TCoordinator = {
     id: number;
     firstName: string;
@@ -109,6 +113,7 @@ export type TLeagueExtraProductInfo = {
     locations?: string[];
     addresses?: Pick<TAddress, 'id' | 'location' | 'formattedAddress'>[];
     startTimes?: string[];
+    registrationPolicy?: RegistrationPolicy | null;
 };
 export type TPickupExtraProductInfo = {
     date: string;
@@ -126,6 +131,7 @@ export type TPickupExtraProductInfo = {
     } | null;
     isFull?: boolean;
     gender?: Gender;
+    registrationPolicy?: 'PUBLIC' | 'INVITE_ONLY';
 };
 export type TFreeAgentExtraProductInfo = {
     isPublished: boolean;

package/api-type/src/modules/pickup_group_invite/pickup_group_invite.factory.d.ts

@@ -0,0 +1,4 @@
+import { PickupGroupInviteService } from './pickup_group_invite.service';
+export declare class PickupGroupInviteFactory {
+    static createInstance(): PickupGroupInviteService;
+}

package/api-type/src/modules/pickup_group_invite/pickup_group_invite.schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const CreatePickupGroupInviteSchema: z.ZodObject<{
+    pickupGroupId: z.ZodNumber;
+    invites: z.ZodArray<z.ZodObject<{
+        email: z.ZodString;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        firstName: string;
+        lastName: string;
+        email: string;
+    }, {
+        firstName: string;
+        lastName: string;
+        email: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    pickupGroupId: number;
+    invites: {
+        firstName: string;
+        lastName: string;
+        email: string;
+    }[];
+}, {
+    pickupGroupId: number;
+    invites: {
+        firstName: string;
+        lastName: string;
+        email: string;
+    }[];
+}>;
+export type CreatePickupGroupInviteSchema = z.infer<typeof CreatePickupGroupInviteSchema>;
+export type CreatePickupGroupInviteResp = {
+    invites: Array<{
+        id: number;
+        email: string;
+        firstName: string | null;
+        lastName: string | null;
+        isActive: boolean;
+    }>;
+};

package/api-type/src/modules/pickup_group_invite/pickup_group_invite.service.d.ts

@@ -0,0 +1,17 @@
+import { Invite } from '../../models/invite';
+import { PickupGroup } from '../../models/pickup_group';
+import { PickupGrpMember } from '../../models/pickup_group_members';
+import { Member } from '../../models/member';
+import { AuthService } from '../auth/auth.service';
+import type { CreatePickupGroupInviteResp, CreatePickupGroupInviteSchema } from './pickup_group_invite.schema';
+export declare class PickupGroupInviteService {
+    private readonly InviteModel;
+    private readonly PickupGroupModel;
+    private readonly PickupGrpMemberModel;
+    private readonly MemberModel;
+    private readonly authService;
+    constructor(InviteModel: typeof Invite, PickupGroupModel: typeof PickupGroup, PickupGrpMemberModel: typeof PickupGrpMember, MemberModel: typeof Member, authService: AuthService);
+    createByMember(memberId: number, payload: CreatePickupGroupInviteSchema): Promise<CreatePickupGroupInviteResp>;
+    private buildRegistrationLink;
+    private ensureInvitedMemberAndInvite;
+}

package/api-type/src/modules/scout_feed/handlers/scout_feed.handler.d.ts

@@ -0,0 +1,29 @@
+import { MULTI_SPORT_ENUM } from '../../scout_profile/scout_profile.schema';
+import { GetFeedFiltersInputSchema, GetFeedOutputSchema } from '../scout_feed.schema';
+export interface ScoutFeedHandler {
+    sport: MULTI_SPORT_ENUM;
+    getFeed(memberId: number, input: GetFeedFiltersInputSchema): Promise<GetFeedOutputSchema>;
+    getProfilesForFeed(filters: {
+        genders?: string[];
+        positions?: number[];
+        minAge?: number;
+        roles?: string[];
+        availableSlots?: number[];
+        filterMaxTDistWithMargin?: number;
+        inputCoordinates?: {
+            lat: number;
+            lng: number;
+        };
+        profileIds?: number[];
+        skillLevels?: number[];
+        excludeReqMemberId?: number;
+    }): Promise<FeedProfile[]>;
+}
+type FeedProfile = {
+    id?: number;
+    memberId?: number;
+    pinned?: boolean;
+    weightedTotalScore?: number;
+    toJSON?: () => Record<string, unknown>;
+};
+export {};