@bantr-sports/sdk 12.10.0 → 12.11.0

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

@@ -30,6 +30,14 @@ export declare const GetBroadcastByIdInputSchema: z.ZodObject<{
     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>;

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

@@ -1,9 +1,30 @@
+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, GetBroadcastsInput, SaveBroadcastInput, SendBroadcastInput } from './broadcast.schema';
+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;
@@ -14,10 +35,75 @@ export declare class BroadcastService {
     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;
@@ -27,6 +113,28 @@ export declare class BroadcastService {
     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;
@@ -69,6 +177,7 @@ export declare class BroadcastService {
             pushNotification: boolean;
             senderEmail: string;
             status: string;
+            failureReason: string | null;
             isArchived: boolean;
             sentAt: Date | null;
             createdAt: Date;
@@ -91,8 +200,20 @@ export declare class BroadcastService {
     } | 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;
@@ -107,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: {
@@ -21,7 +22,7 @@ export declare const CHAT_MESSAGE_TYPES: {
     readonly POLL: "poll";
     readonly INVITE: "invite";
 };
-export declare const chatTypeSchema: z.ZodEnum<["direct", "private_group", "team", "match", "pickup"]>;
+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>;

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

@@ -27,6 +27,25 @@ export declare class ChatService {
         items: any;
         nextCursor: any;
     }>;
+    getNextRsvpEvent(memberId: number, input: {
+        chatId: 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;
+    }>;
     createDirectChat(actorId: number, input: CreateDirectChatInput): Promise<any>;
     createPrivateGroup(actorId: number, input: CreatePrivateGroupInput): Promise<any>;
     listGroupMemberCandidates(memberId: number, input: ListGroupMemberCandidatesInput): Promise<any[]>;
@@ -34,6 +53,8 @@ export declare class ChatService {
     syncTeamChat(teamId: number, actorId?: number): Promise<any>;
     getOrCreateMatchChat(actorId: number, input: ContextChatInput): Promise<any>;
     getOrCreatePickupChat(actorId: number, input: ContextChatInput): Promise<any>;
+    getOrCreatePickupGroupChat(actorId: number, input: ContextChatInput): Promise<any>;
+    syncPickupGroupChat(pickupGroupId: number, actorId?: number): Promise<any>;
     syncPickupChat(pickupId: number, actorId?: number): Promise<any>;
     sendMessage(actorId: number, input: SendMessageInput): Promise<any>;
     sendScoutInviteMessage(actorId: number, input: SendScoutInviteMessageInput): Promise<any>;
@@ -82,7 +103,9 @@ export declare class ChatService {
     private requireSharedTeamMembers;
     private requireMessageInChat;
     private ensureTeamChatsForMember;
+    private ensurePickupGroupChatsForMember;
     private ensurePickupChatsForMember;
     private uniqueMemberIds;
+    private formatPickupChatTitle;
 }
 export {};

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

@@ -118,7 +118,7 @@ export declare const GetDiscountCodeSchema: z.ZodObject<Pick<{
     id: number;
 }>;
 export type GetDiscountCodeSchema = z.infer<typeof GetDiscountCodeSchema>;
-export declare const CreateDiscountCodeSchema: z.ZodObject<Pick<{
+export declare const CreateDiscountCodeFieldsSchema: z.ZodObject<Pick<{
     id: z.ZodNumber;
     code: z.ZodString;
     description: z.ZodString;
@@ -159,8 +159,115 @@ export declare const CreateDiscountCodeSchema: z.ZodObject<Pick<{
     validUntil: Date | null;
     orgWorkspaceId?: number | null | undefined;
 }>;
+export declare const validateDiscountCodeAmount: (value: Pick<DiscountCodeSchema, "amountType" | "amountValue">, ctx: z.RefinementCtx) => void;
+export declare const CreateDiscountCodeSchema: z.ZodEffects<z.ZodObject<Pick<{
+    id: z.ZodNumber;
+    code: z.ZodString;
+    description: z.ZodString;
+    appliesWhen: z.ZodEnum<["purchase"]>;
+    applicableOn: z.ZodNullable<z.ZodEnum<["league-registration", "pickup-registration", "free-agent-registration"]>>;
+    amountType: z.ZodEnum<["flat-rate", "percentage"]>;
+    amountValue: z.ZodNumber;
+    validFrom: z.ZodNullable<z.ZodDate>;
+    validUntil: z.ZodNullable<z.ZodEffects<z.ZodDate, Date, Date>>;
+    usageLimit: z.ZodNullable<z.ZodNumber>;
+    usageCount: z.ZodDefault<z.ZodNumber>;
+    stripePromotionCodeId: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    deletedAt: z.ZodNullable<z.ZodDate>;
+    organizationId: z.ZodNumber;
+    orgWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    leagueId: z.ZodNullable<z.ZodNumber>;
+    seasonId: z.ZodNullable<z.ZodNumber>;
+}, "description" | "orgWorkspaceId" | "code" | "appliesWhen" | "applicableOn" | "amountType" | "amountValue" | "validFrom" | "validUntil">, "strip", z.ZodTypeAny, {
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    orgWorkspaceId?: number | null | undefined;
+}>, {
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    orgWorkspaceId?: number | null | undefined;
+}>;
 export type CreateDiscountCodeSchema = z.infer<typeof CreateDiscountCodeSchema>;
-export declare const UpdateDiscountCodeSchema: z.ZodObject<Pick<{
+export declare const UpdateDiscountCodeFieldsSchema: z.ZodObject<Pick<{
+    id: z.ZodNumber;
+    code: z.ZodString;
+    description: z.ZodString;
+    appliesWhen: z.ZodEnum<["purchase"]>;
+    applicableOn: z.ZodNullable<z.ZodEnum<["league-registration", "pickup-registration", "free-agent-registration"]>>;
+    amountType: z.ZodEnum<["flat-rate", "percentage"]>;
+    amountValue: z.ZodNumber;
+    validFrom: z.ZodNullable<z.ZodDate>;
+    validUntil: z.ZodNullable<z.ZodEffects<z.ZodDate, Date, Date>>;
+    usageLimit: z.ZodNullable<z.ZodNumber>;
+    usageCount: z.ZodDefault<z.ZodNumber>;
+    stripePromotionCodeId: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    deletedAt: z.ZodNullable<z.ZodDate>;
+    organizationId: z.ZodNumber;
+    orgWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    leagueId: z.ZodNullable<z.ZodNumber>;
+    seasonId: z.ZodNullable<z.ZodNumber>;
+}, "id" | "description" | "orgWorkspaceId" | "code" | "appliesWhen" | "applicableOn" | "amountType" | "amountValue" | "validFrom" | "validUntil" | "usageLimit">, "strip", z.ZodTypeAny, {
+    id: number;
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    usageLimit: number | null;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    id: number;
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    usageLimit: number | null;
+    orgWorkspaceId?: number | null | undefined;
+}>;
+export declare const UpdateDiscountCodeSchema: z.ZodEffects<z.ZodObject<Pick<{
     id: z.ZodNumber;
     code: z.ZodString;
     description: z.ZodString;
@@ -204,6 +311,30 @@ export declare const UpdateDiscountCodeSchema: z.ZodObject<Pick<{
     validUntil: Date | null;
     usageLimit: number | null;
     orgWorkspaceId?: number | null | undefined;
+}>, {
+    id: number;
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    usageLimit: number | null;
+    orgWorkspaceId?: number | null | undefined;
+}, {
+    id: number;
+    description: string;
+    code: string;
+    appliesWhen: "purchase";
+    applicableOn: "league-registration" | "pickup-registration" | "free-agent-registration" | null;
+    amountType: "flat-rate" | "percentage";
+    amountValue: number;
+    validFrom: Date | null;
+    validUntil: Date | null;
+    usageLimit: number | null;
+    orgWorkspaceId?: number | null | undefined;
 }>;
 export type UpdateDiscountCodeSchema = z.infer<typeof UpdateDiscountCodeSchema>;
 export declare const DeleteDiscountCodeSchema: z.ZodObject<Pick<{

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

@@ -20,8 +20,7 @@ export declare enum Sports {
     Soccer = "soccer",
     Softball = "softball",
     Volleyball = "volleyball",
-    Basketball = "basketball",
-    FlagBall = "flag_ball"
+    Basketball = "basketball"
 }
 export declare enum Gender {
     Male = "male",

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

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

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

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const GetWorkspaceRulesInputSchema: z.ZodObject<{
+    organizationId: z.ZodNumber;
+    workspaceId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    organizationId: number;
+    workspaceId: number;
+}, {
+    organizationId: number;
+    workspaceId: number;
+}>;
+export declare const PublishWorkspaceRulesInputSchema: z.ZodObject<{
+    organizationId: z.ZodNumber;
+    workspaceId: z.ZodNumber;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    organizationId: number;
+    workspaceId: number;
+}, {
+    content: string;
+    organizationId: number;
+    workspaceId: number;
+}>;
+export declare const DeleteWorkspaceRulesInputSchema: z.ZodObject<{
+    organizationId: z.ZodNumber;
+    workspaceId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    organizationId: number;
+    workspaceId: number;
+}, {
+    organizationId: number;
+    workspaceId: number;
+}>;
+/** Same shape as the organizer read - the marketplace just reaches it without a session. */
+export declare const GetPublicWorkspaceRulesInputSchema: z.ZodObject<{
+    organizationId: z.ZodNumber;
+    workspaceId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    organizationId: number;
+    workspaceId: number;
+}, {
+    organizationId: number;
+    workspaceId: number;
+}>;
+export type GetWorkspaceRulesInput = z.infer<typeof GetWorkspaceRulesInputSchema>;
+export type PublishWorkspaceRulesInput = z.infer<typeof PublishWorkspaceRulesInputSchema>;
+export type DeleteWorkspaceRulesInput = z.infer<typeof DeleteWorkspaceRulesInputSchema>;
+export type GetPublicWorkspaceRulesInput = z.infer<typeof GetPublicWorkspaceRulesInputSchema>;
+export type WorkspaceRules = {
+    organizationId: number;
+    workspaceId: number;
+    content: string;
+    version: number;
+    publishedAt: Date;
+    updatedAt: Date;
+    publishedBy: {
+        id: number;
+        firstName: string;
+        lastName: string;
+    } | null;
+};
+/**
+ * The player-facing read. Deliberately drops `publishedBy` - the marketplace product page
+ * is reachable without a session, and which organizer pressed publish is not public info.
+ */
+export type PublicWorkspaceRules = Omit<WorkspaceRules, 'publishedBy'>;

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

@@ -0,0 +1,38 @@
+import { type DeleteWorkspaceRulesInput, type GetPublicWorkspaceRulesInput, type GetWorkspaceRulesInput, type PublicWorkspaceRules, type PublishWorkspaceRulesInput, type WorkspaceRules } from './rules.schema';
+export declare class RulesService {
+    /**
+     * Reads carry `organizationId` from the caller, so it has to be checked against the
+     * workspace - otherwise passing someone else's `workspaceId` alongside your own
+     * `organizationId` would read their rules.
+     */
+    private assertWorkspaceInOrganization;
+    private assertOrganizerInOrganization;
+    /** Only `publishedBy` needs mapping - the rest of the row is already camelCase. */
+    private toWorkspaceRules;
+    /**
+     * Returns `null` rather than throwing when a workspace has no rules yet - that is the
+     * empty state the settings page renders, not an error.
+     *
+     * This read exposes `publishedBy`, which the public read deliberately withholds, so the
+     * caller has to be an organizer of the organization and not merely signed in.
+     */
+    getWorkspaceRules(userId: number, input: GetWorkspaceRulesInput): Promise<WorkspaceRules | null>;
+    /**
+     * Unauthenticated read for the marketplace product page. Published rules are already
+     * public by intent, so the only guard is the same workspace/organization pairing check;
+     * `publishedBy` is not selected so no organizer identity leaks to anonymous visitors.
+     *
+     * `null` means "this workspace has not published rules", which the modal renders as its
+     * empty state rather than as a failure.
+     */
+    getPublicWorkspaceRules(input: GetPublicWorkspaceRulesInput): Promise<PublicWorkspaceRules | null>;
+    /**
+     * Create-or-replace: the workspace keeps a single live document and every publish
+     * bumps `version`, so "add rules" and "edit rules" are the same write.
+     */
+    publishWorkspaceRules(userId: number, input: PublishWorkspaceRulesInput): Promise<WorkspaceRules>;
+    /** Takes the workspace back to the empty state. */
+    deleteWorkspaceRules(userId: number, input: DeleteWorkspaceRulesInput): Promise<{
+        deleted: boolean;
+    }>;
+}

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

@@ -57,6 +57,8 @@ export declare class ScoutFeedService {
             distanceFromEventInMiles?: number;
             age?: number;
             currentCity?: string;
+            longitude?: number | null;
+            latitude?: number | null;
             QueryBuilderType: import("objection-js-soft-delete").SoftDeleteQueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]> & import("objection").QueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]>;
             $modelClass: import("objection").ModelClass<ScoutSoccerProfile>;
         })[];
@@ -96,6 +98,8 @@ export declare class ScoutFeedService {
             distanceFromEventInMiles?: number;
             age?: number;
             currentCity?: string;
+            longitude?: number | null;
+            latitude?: number | null;
             QueryBuilderType: import("objection-js-soft-delete").SoftDeleteQueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]> & import("objection").QueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]>;
             $modelClass: import("objection").ModelClass<ScoutSoccerProfile>;
         })[];
@@ -143,6 +147,8 @@ export declare class ScoutFeedService {
             distanceFromEventInMiles?: number;
             age?: number;
             currentCity?: string;
+            longitude?: number | null;
+            latitude?: number | null;
             QueryBuilderType: import("objection-js-soft-delete").SoftDeleteQueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]> & import("objection").QueryBuilder<ScoutSoccerProfile, ScoutSoccerProfile[]>;
             $modelClass: import("objection").ModelClass<ScoutSoccerProfile>;
         }[];

package/api-type/src/modules/scout_feed/scout_feed_location.d.ts

@@ -0,0 +1,27 @@
+type TCoordinatesRow = {
+    longitude?: number | null;
+    latitude?: number | null;
+} | undefined;
+/**
+ * BAN-1924: the member's own scout profile location (set when they created/edited their
+ * scout profile) is a more reliable "where do I want to be scouted" signal than their
+ * general account address, so it takes priority when no venue has been explicitly chosen.
+ */
+export declare function resolveScoutFeedDefaultCoordinates(scoutProfileCoordinates: TCoordinatesRow, memberCoordinates: TCoordinatesRow): {
+    lng?: number;
+    lat?: number;
+};
+/**
+ * Throws when the requesting member has no usable location anywhere (no explicit
+ * venue, no scout profile location, no account address). PRECONDITION_FAILED lets
+ * clients distinguish this expected "no location set" state from a malformed request
+ * so they can degrade gracefully (eg. prompt for a location) instead of erroring out.
+ */
+export declare function assertHasScoutFeedLocation(coordinates?: {
+    lat?: number | null;
+    lng?: number | null;
+} | null): asserts coordinates is {
+    lat: number;
+    lng: number;
+};
+export {};

package/api-type/src/modules/scout_profile/scout_soccer_profile.model.d.ts

@@ -35,6 +35,8 @@ export declare class ScoutSoccerProfile extends ScoutSoccerProfile_base {
     distanceFromEventInMiles?: number;
     age?: number;
     currentCity?: string;
+    longitude?: number | null;
+    latitude?: number | null;
     static get tableName(): string;
     static get idColumn(): string;
     static get relationMappings(): RelationMappings;