@bantr-sports/sdk 12.9.0 → 12.11.0

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

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

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

@@ -0,0 +1,302 @@
+import { z } from 'zod';
+export declare const GetBroadcastsInputSchema: z.ZodObject<{
+    organizationId: z.ZodNumber;
+    orgWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+    isArchived: z.ZodOptional<z.ZodEnum<["active", "archived"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    organizationId: number;
+    search?: string | undefined;
+    orgWorkspaceId?: number | null | undefined;
+    isArchived?: "active" | "archived" | undefined;
+}, {
+    organizationId: number;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    search?: string | undefined;
+    orgWorkspaceId?: number | null | undefined;
+    isArchived?: "active" | "archived" | undefined;
+}>;
+export type GetBroadcastsInput = z.infer<typeof GetBroadcastsInputSchema>;
+export declare const GetBroadcastByIdInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export type GetBroadcastByIdInput = z.infer<typeof GetBroadcastByIdInputSchema>;
+export declare const GetBroadcastDeliveryStatusesInputSchema: z.ZodObject<{
+    broadcastId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    broadcastId: number;
+}, {
+    broadcastId: number;
+}>;
+export type GetBroadcastDeliveryStatusesInput = z.infer<typeof GetBroadcastDeliveryStatusesInputSchema>;
+export declare const GetAudienceInputSchema: z.ZodObject<{
+    seasonId: z.ZodOptional<z.ZodNumber>;
+    leagueId: z.ZodOptional<z.ZodNumber>;
+    teamId: z.ZodOptional<z.ZodNumber>;
+    pickupGroupId: z.ZodOptional<z.ZodNumber>;
+    pickupEventId: z.ZodOptional<z.ZodNumber>;
+    playerRole: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    teamId?: number | undefined;
+    pickupGroupId?: number | undefined;
+    leagueId?: number | undefined;
+    seasonId?: number | undefined;
+    pickupEventId?: number | undefined;
+    playerRole?: string | null | undefined;
+}, {
+    teamId?: number | undefined;
+    pickupGroupId?: number | undefined;
+    leagueId?: number | undefined;
+    seasonId?: number | undefined;
+    pickupEventId?: number | undefined;
+    playerRole?: string | null | undefined;
+}>;
+export type GetAudienceInput = z.infer<typeof GetAudienceInputSchema>;
+export declare const SaveBroadcastInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    organizationId: z.ZodNumber;
+    orgWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    subject: z.ZodString;
+    message: z.ZodString;
+    delivery: z.ZodObject<{
+        email: z.ZodBoolean;
+        push: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        email: boolean;
+        push: boolean;
+    }, {
+        email: boolean;
+        push: boolean;
+    }>;
+    senderEmail: z.ZodString;
+    audienceGroups: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        seasonId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        leagueId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        teamId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        pickupGroupId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        pickupEventId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        playerRole: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        memberIds: z.ZodArray<z.ZodNumber, "many">;
+        totalMembers: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }>, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    organizationId: number;
+    subject: string;
+    senderEmail: string;
+    audienceGroups: {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }[];
+    delivery: {
+        email: boolean;
+        push: boolean;
+    };
+    id?: number | undefined;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    message: string;
+    organizationId: number;
+    subject: string;
+    senderEmail: string;
+    audienceGroups: {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }[];
+    delivery: {
+        email: boolean;
+        push: boolean;
+    };
+    id?: number | undefined;
+    orgWorkspaceId?: number | null | undefined;
+}>;
+export type SaveBroadcastInput = z.infer<typeof SaveBroadcastInputSchema>;
+export declare const SendBroadcastInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    organizationId: z.ZodNumber;
+    orgWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    subject: z.ZodString;
+    message: z.ZodString;
+    delivery: z.ZodObject<{
+        email: z.ZodBoolean;
+        push: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        email: boolean;
+        push: boolean;
+    }, {
+        email: boolean;
+        push: boolean;
+    }>;
+    senderEmail: z.ZodString;
+} & {
+    audienceGroups: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        seasonId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        leagueId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        teamId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        pickupGroupId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        pickupEventId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        playerRole: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        memberIds: z.ZodArray<z.ZodNumber, "many">;
+        totalMembers: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }>, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }, {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    organizationId: number;
+    subject: string;
+    senderEmail: string;
+    audienceGroups: {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }[];
+    delivery: {
+        email: boolean;
+        push: boolean;
+    };
+    id?: number | undefined;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    message: string;
+    organizationId: number;
+    subject: string;
+    senderEmail: string;
+    audienceGroups: {
+        memberIds: number[];
+        teamId?: number | null | undefined;
+        pickupGroupId?: number | null | undefined;
+        leagueId?: number | null | undefined;
+        seasonId?: number | null | undefined;
+        pickupEventId?: number | null | undefined;
+        playerRole?: string | null | undefined;
+        totalMembers?: number | undefined;
+    }[];
+    delivery: {
+        email: boolean;
+        push: boolean;
+    };
+    id?: number | undefined;
+    orgWorkspaceId?: number | null | undefined;
+}>;
+export type SendBroadcastInput = z.infer<typeof SendBroadcastInputSchema>;
+export declare const ArchiveBroadcastInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export type ArchiveBroadcastInput = z.infer<typeof ArchiveBroadcastInputSchema>;
+export declare const DeleteBroadcastInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export type DeleteBroadcastInput = z.infer<typeof DeleteBroadcastInputSchema>;
+export declare const DownloadBroadcastAudienceCsvInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export type DownloadBroadcastAudienceCsvInput = z.infer<typeof DownloadBroadcastAudienceCsvInputSchema>;

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

@@ -0,0 +1,219 @@
+import type { Queue } from 'bullmq';
+import { Member } from '../../models/member';
+import { Broadcast } from '../../models/broadcast';
+import { BroadcastAudienceGroup } from '../../models/broadcast_audience_group';
+import { BroadcastAudienceMember } from '../../models/broadcast_audience_member';
+import { ArchiveBroadcastInput, DeleteBroadcastInput, DownloadBroadcastAudienceCsvInput, GetAudienceInput, GetBroadcastByIdInput, GetBroadcastDeliveryStatusesInput, GetBroadcastsInput, SaveBroadcastInput, SendBroadcastInput } from './broadcast.schema';
+import { Organizer } from '../../models/organizer';
+import type { BroadcastDeliveryStatus } from '../../models/broadcast_delivery';
+/**
+ * `earlier_version` means a delivery exists, but of a message that has since been
+ * edited — so a resend correctly targets them again. `sending` distinguishes "no
+ * ledger row yet" on a broadcast still in flight from one that has finished.
+ */
+export type BroadcastDeliverySummary = 'sent' | 'partial' | 'unknown' | 'failed' | 'earlier_version' | 'sending' | 'not_sent';
+export type BroadcastMemberDeliveryStatus = {
+    memberId: number;
+    /** Outcome per channel for the content currently saved on the broadcast. */
+    email: BroadcastDeliveryStatus | null;
+    push: BroadcastDeliveryStatus | null;
+    notification: BroadcastDeliveryStatus | null;
+    summary: BroadcastDeliverySummary;
+    lastError: string | null;
+    deliveredAt: Date | null;
+    /** Highest attempt count across this member's channels — i.e. was this retried. */
+    attemptCount: number;
+    receivedEarlierVersion: boolean;
+};
+export declare class BroadcastService {
+    private readonly MemberModel;
+    private readonly BroadcastModel;
+    private readonly BroadcastAudienceGroupModel;
+    private readonly BroadcastAudienceMemberModel;
+    private readonly OrganizerModel;
+    constructor(MemberModel: typeof Member, BroadcastModel: typeof Broadcast, BroadcastAudienceGroupModel: typeof BroadcastAudienceGroup, BroadcastAudienceMemberModel: typeof BroadcastAudienceMember, OrganizerModel: typeof Organizer);
+    private assertOrganizationAccess;
+    private getBroadcastForOrganization;
+    private markBroadcastAsSending;
+    private normalizeFailureReason;
+    /**
+     * `note` is appended AFTER `normalizeFailureReason` truncates, so a long provider
+     * error cannot push it out of the message. The column is TEXT, so the combined
+     * length is not a concern. Used to warn that a resend may duplicate.
+     */
+    private markBroadcastAsFailed;
+    /**
+     * Public safety net for the queue worker's `failed` handler. If a job dies or
+     * stalls before `processQueuedBroadcast` runs its own catch block (crash, OOM,
+     * lost lock), the broadcast would otherwise be stranded in SENDING forever.
+     * This resets it to FAILED so it can be resent. Idempotent: the underlying
+     * patch only matches rows still in SENDING, so a reason set by
+     * `processQueuedBroadcast`'s own catch is preserved.
+     */
+    failQueuedBroadcast(organizationId: number, broadcastId: number, reason?: string | null): Promise<void>;
+    private assertOrganizationExists;
+    private insertInChunks;
+    /**
+     * Retries a ledger write a few times before giving up.
+     *
+     * A dropped ledger row is not a cosmetic problem: `getDeliveredMemberIdsByChannel`
+     * treats "no row" as "not delivered", so a lost row means a resend mails that
+     * person again. A transient connection blip is worth a second attempt.
+     */
+    private withLedgerWriteRetry;
+    /**
+     * Members who already received `contentHash` on each channel.
+     *
+     * Scoped to `status = 'sent'`, so `unknown` (timed-out, possibly delivered) and
+     * `failed` recipients are re-targeted by construction: for game-day comms a
+     * missed notice is worse than a duplicate, and the ambiguous count is reported
+     * back to the organizer instead of being silently resolved either way.
+     */
+    private getDeliveredMemberIdsByChannel;
+    /**
+     * Records what was handed to a delivery channel, one autocommit statement per
+     * chunk, immediately after that batch is acknowledged.
+     *
+     * DELIBERATELY NOT IN A TRANSACTION (the `notification` channel excepted, which
+     * passes its `trx`). This is the entire point of the ledger: if checkpoints were
+     * written inside a transaction spanning the send, a crash mid-delivery would roll
+     * them all back, and the resend would duplicate everything — which is the bug
+     * this exists to fix. Order is send-then-record, so a crash in that gap re-sends
+     * one batch (at-least-once). Recording intent first would be at-most-once, i.e.
+     * silent drops.
+     */
+    private recordDeliveries;
+    /**
+     * Recipients whose delivery outcome is genuinely unknown — a provider request
+     * timed out without being aborted, so it may or may not have been delivered.
+     * Surfaced in `failure_reason` so the organizer knows a resend can duplicate.
+     */
+    private countAmbiguousDeliveries;
+    private enqueueBroadcastSend;
+    /**
+     * Boot-time recovery for broadcasts stranded in SENDING. The worker's `failed`
+     * handler only fires for jobs that actually fail, so a row whose job never ran
+     * (Redis flushed, job ID collision, add rejected) or whose process died before
+     * that handler executed stays SENDING forever — it cannot be edited, resent, or
+     * completed. Rows younger than `staleAfterMs` are left alone so a legitimately
+     * slow send is never interrupted, and every patch is scoped to `status =
+     * 'SENDING'`, so concurrent API replicas running this cannot clobber a send that
+     * completed in the meantime.
+     */
+    reconcileStuckBroadcasts(queue: Pick<Queue, 'getJob'>, staleAfterMs?: number): Promise<{
+        checked: number;
+        reset: number;
+    }>;
+    private assertWorkspaceAccess;
+    private normalizeAudienceGroups;
+    private applyBroadcastFilters;
+    private validateAudienceGroups;
+    private escapeCsvValue;
+    private buildCsvRow;
+    private stripHtmlForPushNotification;
+    downloadBroadcastAudienceCsv(organizationId: number, { id }: DownloadBroadcastAudienceCsvInput): Promise<string | null>;
+    getBroadcastById(organizationId: number, { id }: GetBroadcastByIdInput): Promise<Broadcast | null>;
+    /**
+     * Per-recipient delivery state for the Recipients table, read straight off the
+     * ledger. Answers the question a `FAILED` broadcast otherwise leaves open: who
+     * actually received this, and who would a resend re-target?
+     *
+     * Rows are grouped per member rather than per channel because that is how the
+     * table displays them; the per-channel statuses stay on the payload so the UI can
+     * show the breakdown without a second request.
+     */
+    getBroadcastDeliveryStatuses(organizationId: number, { broadcastId }: GetBroadcastDeliveryStatusesInput): Promise<{
+        contentHash: string;
+        members: BroadcastMemberDeliveryStatus[];
+    } | null>;
+    /**
+     * Collapses a member's per-channel statuses into the single label the table shows.
+     *
+     * Derived from the rows that exist, deliberately not from the broadcast's channel
+     * toggles: a member with push enabled but no registered device, or who muted
+     * broadcasts, is never handed to FCM and has no `push` row. Treating that as an
+     * incomplete delivery would label ordinary opt-outs as a problem.
+     */
+    private summarizeMemberDelivery;
+    deleteBroadcast(organizationId: number, { id }: DeleteBroadcastInput): Promise<{
+        success: boolean;
+        id: number;
+    } | null>;
+    getAudience(organizationId: number, payload: GetAudienceInput): Promise<Member[]>;
+    saveBroadcast(creatorId: number, organizationId: number, input: SaveBroadcastInput): Promise<any>;
+    getBroadcasts(organizationId: number, payload: GetBroadcastsInput): Promise<{
+        items: {
+            audienceGroups: {
+                season: any;
+                league: any;
+                team: any;
+                pickupGroup: any;
+                pickupEvent: any;
+                id: number;
+                broadcastId: number;
+                seasonId: number;
+                leagueId: number | null;
+                teamId: number | null;
+                pickupGroupId: number | null;
+                pickupEventId: number | null;
+                playerRole: string | null;
+                totalMembers: number;
+                members?: Partial<Member>[];
+                audienceMembers?: BroadcastAudienceMember[];
+                createdAt: Date;
+                updatedAt: Date;
+                $modelClass: import("objection").ModelClass<BroadcastAudienceGroup>;
+                QueryBuilderType: import("objection").QueryBuilder<BroadcastAudienceGroup, BroadcastAudienceGroup[]>;
+            }[];
+            id: number;
+            organizationId: number;
+            orgWorkspaceId: number | null;
+            seasonId: number;
+            leagueId: number | null;
+            creatorId: number;
+            subject: string;
+            message: string;
+            emailNotification: boolean;
+            pushNotification: boolean;
+            senderEmail: string;
+            status: string;
+            failureReason: string | null;
+            isArchived: boolean;
+            sentAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            $modelClass: import("objection").ModelClass<Broadcast>;
+            QueryBuilderType: import("objection").QueryBuilder<Broadcast, Broadcast[]>;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    toggleArchiveBroadcast(organizationId: number, { id }: ArchiveBroadcastInput): Promise<Broadcast | null>;
+    sendBroadcast(creatorId: number, organizationId: number, input: SendBroadcastInput): Promise<{
+        broadcast: Broadcast;
+        queued: boolean;
+        sentEmails: number;
+        sentPushNotifications: number;
+        createdNotifications: number;
+    } | null>;
+    processQueuedBroadcast(creatorId: number, organizationId: number, broadcastId: number): Promise<{
+        broadcast: Broadcast;
+        /** Addresses handed to Mailgun — see `recordedEmailDeliveries` for delivered. */
+        sentEmails: number;
+        /** Tokens handed to FCM — see `recordedPushDeliveries` for delivered. */
+        sentPushNotifications: number;
+        createdNotifications: number;
+        recordedEmailDeliveries: number;
+        ambiguousEmailDeliveries: number;
+        recordedPushDeliveries: number;
+        ambiguousPushDeliveries: number;
+        skippedAlreadyDelivered: number;
+        /**
+         * Reached, but missing from the ledger, so a resend cannot skip them.
+         * Non-zero means the ledger under-reports what was delivered.
+         */
+        unrecordedDeliveries: number;
+    } | null>;
+}

package/api-type/src/modules/broadcast/broadcast_content_hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fingerprints the content a recipient actually received, so the delivery ledger
+ * can tell "already got this message" apart from "already got an earlier draft".
+ *
+ * A FAILED broadcast is fully editable: the organizer can reword the subject or
+ * body before hitting Resend. Skipping every previously-delivered recipient would
+ * mean the reworded version silently never reaches them. Keying the ledger on
+ * this hash instead makes an edited resend re-target the whole audience, while an
+ * unchanged resend targets only the recipients who were never reached.
+ *
+ * The tuple is JSON-encoded before hashing so that a subject/message split cannot
+ * be shifted without changing the digest — ('ab', 'c') and ('a', 'bc') hash
+ * differently. Channel toggles, sender, and audience are deliberately excluded:
+ * enabling push after an email-only send then finds no `push` rows and correctly
+ * targets everyone.
+ */
+export declare const buildBroadcastContentHash: (subject?: string | null, message?: string | null) => string;

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

@@ -4,7 +4,7 @@ type PrismaClientLike = typeof prisma;
 type DbClient = any;
 type CreateContextChatInput = {
     actorId: number;
-    chatType: typeof CHAT_TYPES.TEAM | typeof CHAT_TYPES.MATCH | typeof CHAT_TYPES.PICKUP;
+    chatType: typeof CHAT_TYPES.TEAM | typeof CHAT_TYPES.MATCH | typeof CHAT_TYPES.PICKUP_GROUP | typeof CHAT_TYPES.PICKUP;
     contextId: number;
     ownerId?: number | null;
     name?: string | null;
@@ -23,6 +23,22 @@ type CreatePollInput = {
     allowMultiple: boolean;
     options: string[];
 };
+type CreateScoutInviteMessageInput = {
+    chatId: number;
+    senderId: number;
+    content: string;
+    inviteId: number;
+    targetType: 'team' | 'pickup';
+    targetId: number;
+    targetName: string;
+    targetImage?: string | null;
+    inviteeMemberId: number;
+    notification: {
+        text: string;
+        textMeta: string;
+        metaData: Record<string, unknown>;
+    };
+};
 type ReactionInput = {
     chatId: number;
     messageId: string;
@@ -50,8 +66,14 @@ export declare class ChatRepository {
     createMessage(input: CreateMessageInput): Promise<any>;
     getChatMessageWithDetails(chatId: number, messageId: string, db?: DbClient): Promise<any>;
     createPoll(input: CreatePollInput): Promise<any>;
+    createScoutInviteMessage(input: CreateScoutInviteMessageInput): Promise<any>;
     getPollInChat(chatId: number, pollId: number): Promise<any>;
     getPollChatMessage(chatId: number, pollId: number, db?: DbClient): Promise<any>;
+    getPendingScoutInviteForParticipants(targetType: 'team' | 'pickup', targetId: number, inviterMemberId: number, inviteeMemberId: number): Promise<any>;
+    getScoutInviteByInviteId(inviteId: number): Promise<any>;
+    getScoutInviteByMessageId(messageId: string): Promise<any>;
+    listScoutInvites(memberId: number, status?: string): Promise<any>;
+    updateScoutInviteStatus(inviteId: number, status: string): Promise<any>;
     votePoll(chatId: number, pollId: number, memberId: number, optionIds: number[]): Promise<any>;
     sendReaction(input: ReactionInput): Promise<any>;
     removeReaction(chatId: number, messageId: string, memberId: number): Promise<{
@@ -85,12 +107,54 @@ export declare class ChatRepository {
     getSharedTeamMemberIds(memberId: number, targetMemberIds: number[]): Promise<unknown[]>;
     getTeamContext(teamId: number): Promise<any>;
     getMatchContext(eventId: number): Promise<any>;
+    getNextTeamRsvpEvent(teamId: number, memberId: number): Promise<{
+        nextEvent: null;
+        hasRsvp: boolean;
+        rsvpStatus: string;
+    } | {
+        nextEvent: {
+            id: any;
+            title: any;
+            dateAndTime: any;
+            addressName: any;
+            location: any;
+            teamId: any;
+            timezone: any;
+        };
+        hasRsvp: boolean;
+        rsvpStatus: any;
+    }>;
+    getRsvpEvent(eventId: number, memberId: number): Promise<{
+        nextEvent: null;
+        hasRsvp: boolean;
+        rsvpStatus: string;
+    } | {
+        nextEvent: {
+            id: any;
+            title: any;
+            dateAndTime: any;
+            addressName: any;
+            location: any;
+            teamId: any;
+            timezone: any;
+        };
+        hasRsvp: boolean;
+        rsvpStatus: any;
+    }>;
     getPickupContext(pickupId: number): Promise<any>;
+    getPickupGroupContext(pickupGroupId: number): Promise<any>;
     getPickupMemberIds(pickupId: number): Promise<any>;
+    getPickupGroupMemberIds(pickupGroupId: number): Promise<any>;
     getActivePickupsForMember(memberId: number): Promise<any>;
+    getActivePickupGroupsForMember(memberId: number): Promise<any>;
+    private addContextMetadata;
     private chatMemberInclude;
     private messageInclude;
     private legacyChatType;
+    private emptyRsvpEventResponse;
+    private rsvpEventResponse;
+    private mapRsvpEvent;
+    private rsvpEventSelect;
     private sortMemberPair;
     private uniqueMemberIds;
 }

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

@@ -4,6 +4,7 @@ export declare const CHAT_TYPES: {
     readonly PRIVATE_GROUP: "private_group";
     readonly TEAM: "team";
     readonly MATCH: "match";
+    readonly PICKUP_GROUP: "pickup_group";
     readonly PICKUP: "pickup";
 };
 export declare const CHAT_MEMBER_ROLES: {
@@ -16,7 +17,12 @@ export declare const CHAT_MEMBER_STATUSES: {
     readonly REMOVED: "removed";
     readonly LEFT: "left";
 };
-export declare const chatTypeSchema: z.ZodEnum<["direct", "private_group", "team", "match", "pickup"]>;
+export declare const CHAT_MESSAGE_TYPES: {
+    readonly TEXT: "text";
+    readonly POLL: "poll";
+    readonly INVITE: "invite";
+};
+export declare const chatTypeSchema: z.ZodEnum<["direct", "private_group", "team", "match", "pickup_group", "pickup"]>;
 export declare const chatMemberRoleSchema: z.ZodEnum<["owner", "admin", "member"]>;
 export declare const listChatsInputSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;