@battle-racing/br-common-lib 3.4.0 → 3.8.0

package/dist/types/powerUp/PowerUpName.d.ts

@@ -1 +1 @@
-export type PowerUpName = 'Battle God' | 'Battle Star' | 'Battle Shot' | 'Battle Nitro' | 'Battle Pulse' | 'Battle Trap' | 'Battle Shield' | 'Battle Turbo';
+export type PowerUpName = 'Battle God' | 'Battle Star' | 'Battle Shot' | 'Battle Nitro' | 'Battle Pulse' | 'Battle Trap' | 'Battle Shield' | 'Battle Turbo' | 'Battle Blue Shot';

package/dist/types/racingTeam/RacingTeam.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { createRacingTeamSchema, paginatedRacingTeamSchema, racingTeamSchema, updateRacingTeamSchema } from './RacingTeam.schema';
+export type RacingTeam = z.infer<typeof racingTeamSchema>;
+export type CreateRacingTeamDto = z.infer<typeof createRacingTeamSchema>;
+export type UpdateRacingTeamDto = z.infer<typeof updateRacingTeamSchema>;
+export type PaginatedRacingTeam = z.infer<typeof paginatedRacingTeamSchema>;

package/dist/types/racingTeam/RacingTeam.schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const racingTeamSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    imageUrl: z.ZodOptional<z.ZodString>;
+    adminUserId: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const createRacingTeamSchema: z.ZodObject<{
+    name: z.ZodString;
+    imageUrl: z.ZodOptional<z.ZodString>;
+    adminUserId: z.ZodString;
+}, z.core.$strip>;
+export declare const updateRacingTeamSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    adminUserId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export declare const filterRacingTeamSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    adminUserId: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paginatedRacingTeamSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        imageUrl: z.ZodOptional<z.ZodString>;
+        adminUserId: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        nextCursor: z.ZodOptional<z.ZodString>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/types/racingTeam/RacingTeam.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginatedRacingTeamSchema = exports.filterRacingTeamSchema = exports.updateRacingTeamSchema = exports.createRacingTeamSchema = exports.racingTeamSchema = void 0;
+const zod_1 = require("zod");
+const pagination_1 = require("../pagination");
+exports.racingTeamSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string().min(3).max(50),
+    imageUrl: zod_1.z.string().url().optional(),
+    adminUserId: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.createRacingTeamSchema = exports.racingTeamSchema.omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+});
+exports.updateRacingTeamSchema = exports.racingTeamSchema.partial();
+exports.filterRacingTeamSchema = zod_1.z.object({
+    name: zod_1.z.string().optional(),
+    adminUserId: zod_1.z.string().optional(),
+    page: zod_1.z.number().min(1).default(1),
+    limit: zod_1.z.number().min(1).max(100).default(10),
+    cursor: zod_1.z.string().optional(),
+});
+exports.paginatedRacingTeamSchema = (0, pagination_1.paginatedResponseSchema)(exports.racingTeamSchema);

package/dist/types/racingTeam/RacingTeamMembership.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { joinRequestSchema, teamMemberSchema, createJoinRequestSchema, answerJoinRequestSchema } from './RacingTeamMembership.schema';
+export type JoinRequest = z.infer<typeof joinRequestSchema>;
+export type TeamMember = z.infer<typeof teamMemberSchema>;
+export type CreateJoinRequest = z.infer<typeof createJoinRequestSchema>;
+export type AnswerJoinRequest = z.infer<typeof answerJoinRequestSchema>;

package/dist/types/racingTeam/RacingTeamMembership.schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const joinRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    racingTeamId: z.ZodString;
+    userId: z.ZodString;
+    status: z.ZodEnum<{
+        PENDING: "PENDING";
+        ACCEPTED: "ACCEPTED";
+        REJECTED: "REJECTED";
+    }>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const teamMemberSchema: z.ZodObject<{
+    racingTeamId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        PILOT: "PILOT";
+        TECHNICIAN: "TECHNICIAN";
+        COACH: "COACH";
+    }>;
+    joinedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const createJoinRequestSchema: z.ZodObject<{
+    racingTeamId: z.ZodString;
+}, z.core.$strip>;
+export declare const answerJoinRequestSchema: z.ZodObject<{
+    racingTeamId: z.ZodString;
+    targetUserId: z.ZodString;
+    accepted: z.ZodBoolean;
+}, z.core.$strip>;

package/dist/types/racingTeam/RacingTeamMembership.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+// libs/common/src/schemas/racing-team-membership.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.answerJoinRequestSchema = exports.createJoinRequestSchema = exports.teamMemberSchema = exports.joinRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.joinRequestSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    racingTeamId: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    status: zod_1.z.enum(['PENDING', 'ACCEPTED', 'REJECTED']),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.teamMemberSchema = zod_1.z.object({
+    racingTeamId: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    role: zod_1.z.enum(['PILOT', 'TECHNICIAN', 'COACH']),
+    joinedAt: zod_1.z.date(),
+});
+exports.createJoinRequestSchema = zod_1.z.object({
+    racingTeamId: zod_1.z.string(),
+});
+exports.answerJoinRequestSchema = zod_1.z.object({
+    racingTeamId: zod_1.z.string(),
+    targetUserId: zod_1.z.string(),
+    accepted: zod_1.z.boolean(),
+});

package/dist/types/racingTeam/index.d.ts

@@ -0,0 +1,4 @@
+export * from './RacingTeam';
+export * from './RacingTeam.schema';
+export * from './RacingTeamMembership';
+export * from './RacingTeamMembership.schema';

package/dist/types/racingTeam/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RacingTeam"), exports);
+__exportStar(require("./RacingTeam.schema"), exports);
+__exportStar(require("./RacingTeamMembership"), exports);
+__exportStar(require("./RacingTeamMembership.schema"), exports);

package/dist/types/socket/serverToClient/SocketKartServerToClientEventsParams.d.ts

@@ -1,5 +1,5 @@
 import type { Game, GameType } from '../../game';
-import type { GameTrack } from '../../gameTrack';
+import type { GameTrack, GameTrackKartConfig } from '../../gameTrack';
 import type { Kart, KartStatus } from '../../kart';
 import type { Response } from '../../response';
 import type { SocketPowerUpEventsParams } from '../SocketPowerUpEventsParams';
@@ -11,16 +11,14 @@ export type SocketKartPowerUpEventsParams = {
     [Key in keyof SocketPowerUpEventsParams as `kart:${Key}`]: SocketPowerUpEventsParams[Key];
 };
 export interface SocketKartEventsParams {
-    'kart:updated': {
-        kart: Kart;
-    };
     'kart:init:response': Response<{
         kart: Kart;
         gameTrack: GameTrack;
     }>;
-    /** Whenever the Game Track config changed */
+    /** Whenever the Game Track config changed, the config might change as well*/
     'kart:gameTrack:updated': {
         gameTrack: GameTrack;
+        config: GameTrackKartConfig;
     };
     /** When the physical button of the game track is pressed */
     'kart:gameTrack:emergency:started': undefined;

package/dist/types/ticketing/GameTicket.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { GameTicketSchema } from './ticketing.schemas';
+export type GameTicket = z.infer<typeof GameTicketSchema>;

package/dist/types/ticketing/GameTicket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/GameTurn.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { GameTurnQueueItemSchema, GameTurnSchema } from './GameTurn.schema';
+export type GameTurn = z.infer<typeof GameTurnSchema>;
+export type GameTurnQueueItem = z.infer<typeof GameTurnQueueItemSchema>;

package/dist/types/ticketing/GameTurn.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/GameTurn.schema.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare const GAME_TURN_STATUS: {
+    readonly CREATED: "created";
+    readonly IN_QUEUE: "in_queue";
+    readonly READY: "ready";
+    readonly PLAYING: "playing";
+    readonly COMPLETED: "completed";
+};
+export declare const GAME_TURN_CHECK: {
+    readonly TUTORIAL: "tutorial";
+    readonly AGE_VERIFICATION: "age_verification";
+    readonly TERMS_ACCEPTANCE: "terms_acceptance";
+};
+export declare const GameTurnStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    created: "created";
+    in_queue: "in_queue";
+    ready: "ready";
+    playing: "playing";
+}>;
+export declare const GameTurnCheckSchema: z.ZodEnum<{
+    tutorial: "tutorial";
+    age_verification: "age_verification";
+    terms_acceptance: "terms_acceptance";
+}>;
+export declare const GameTurnSchema: z.ZodObject<{
+    id: z.ZodString;
+    purchaseId: z.ZodString;
+    leaderUsername: z.ZodString;
+    gameTickets: z.ZodArray<z.ZodString>;
+    usernames: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        created: "created";
+        in_queue: "in_queue";
+        ready: "ready";
+        playing: "playing";
+    }>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            qr_scan: "qr_scan";
+            manual_check: "manual_check";
+            link_accept: "link_accept";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+        }>;
+        label: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        completedAt: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    completedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export declare const GameTurnQueueItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    purchaseId: z.ZodString;
+    leaderUsername: z.ZodString;
+    gameTickets: z.ZodArray<z.ZodString>;
+    usernames: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        created: "created";
+        in_queue: "in_queue";
+        ready: "ready";
+        playing: "playing";
+    }>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            qr_scan: "qr_scan";
+            manual_check: "manual_check";
+            link_accept: "link_accept";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+        }>;
+        label: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        completedAt: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    position: z.ZodNumber;
+}, z.core.$strip>;

package/dist/types/ticketing/GameTurn.schema.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameTurnQueueItemSchema = exports.GameTurnSchema = exports.GameTurnCheckSchema = exports.GameTurnStatusSchema = exports.GAME_TURN_CHECK = exports.GAME_TURN_STATUS = void 0;
+const zod_1 = require("zod");
+const GameTurnTask_schema_1 = require("./GameTurnTask.schema");
+exports.GAME_TURN_STATUS = {
+    CREATED: 'created',
+    IN_QUEUE: 'in_queue',
+    READY: 'ready',
+    PLAYING: 'playing',
+    COMPLETED: 'completed',
+};
+exports.GAME_TURN_CHECK = {
+    TUTORIAL: 'tutorial',
+    AGE_VERIFICATION: 'age_verification',
+    TERMS_ACCEPTANCE: 'terms_acceptance',
+};
+exports.GameTurnStatusSchema = zod_1.z.enum([
+    exports.GAME_TURN_STATUS.CREATED,
+    exports.GAME_TURN_STATUS.IN_QUEUE,
+    exports.GAME_TURN_STATUS.READY,
+    exports.GAME_TURN_STATUS.PLAYING,
+    exports.GAME_TURN_STATUS.COMPLETED,
+]);
+exports.GameTurnCheckSchema = zod_1.z.enum([
+    exports.GAME_TURN_CHECK.TUTORIAL,
+    exports.GAME_TURN_CHECK.AGE_VERIFICATION,
+    exports.GAME_TURN_CHECK.TERMS_ACCEPTANCE,
+]);
+exports.GameTurnSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    purchaseId: zod_1.z.string(),
+    leaderUsername: zod_1.z.string(),
+    gameTickets: zod_1.z.array(zod_1.z.string()),
+    usernames: zod_1.z.array(zod_1.z.string()),
+    status: exports.GameTurnStatusSchema,
+    tasks: zod_1.z.array(GameTurnTask_schema_1.GameTurnTaskSchema),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    startedAt: zod_1.z.date().optional(),
+    completedAt: zod_1.z.date().optional(),
+});
+// The Game turn queue item requires a position to sort it.
+exports.GameTurnQueueItemSchema = exports.GameTurnSchema.extend({
+    position: zod_1.z.number(),
+});

package/dist/types/ticketing/GameTurnTask.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { GameTurnTaskSchema } from './GameTurnTask.schema';
+export type GameTurnTask = z.infer<typeof GameTurnTaskSchema>;

package/dist/types/ticketing/GameTurnTask.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/GameTurnTask.schema.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const GAME_TURN_TASK_TYPE: {
+    readonly QR_SCAN: "qr_scan";
+    readonly MANUAL_CHECK: "manual_check";
+    readonly LINK_ACCEPT: "link_accept";
+};
+export declare const GAME_TURN_TASK_STATUS: {
+    readonly PENDING: "pending";
+    readonly COMPLETED: "completed";
+};
+export declare const GameTurnTaskTypeSchema: z.ZodEnum<{
+    qr_scan: "qr_scan";
+    manual_check: "manual_check";
+    link_accept: "link_accept";
+}>;
+export declare const GameTurnTaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+}>;
+export declare const GameTurnTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        qr_scan: "qr_scan";
+        manual_check: "manual_check";
+        link_accept: "link_accept";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+    }>;
+    label: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    completedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;

package/dist/types/ticketing/GameTurnTask.schema.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameTurnTaskSchema = exports.GameTurnTaskStatusSchema = exports.GameTurnTaskTypeSchema = exports.GAME_TURN_TASK_STATUS = exports.GAME_TURN_TASK_TYPE = void 0;
+const zod_1 = require("zod");
+exports.GAME_TURN_TASK_TYPE = {
+    QR_SCAN: 'qr_scan',
+    MANUAL_CHECK: 'manual_check',
+    LINK_ACCEPT: 'link_accept',
+};
+exports.GAME_TURN_TASK_STATUS = {
+    PENDING: 'pending',
+    COMPLETED: 'completed',
+};
+exports.GameTurnTaskTypeSchema = zod_1.z.enum([
+    exports.GAME_TURN_TASK_TYPE.QR_SCAN,
+    exports.GAME_TURN_TASK_TYPE.MANUAL_CHECK,
+    exports.GAME_TURN_TASK_TYPE.LINK_ACCEPT,
+]);
+exports.GameTurnTaskStatusSchema = zod_1.z.enum([
+    exports.GAME_TURN_TASK_STATUS.PENDING,
+    exports.GAME_TURN_TASK_STATUS.COMPLETED,
+]);
+exports.GameTurnTaskSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    type: exports.GameTurnTaskTypeSchema,
+    status: exports.GameTurnTaskStatusSchema,
+    label: zod_1.z.string(),
+    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    completedAt: zod_1.z.date().optional(),
+});

package/dist/types/ticketing/PaymentProvider.d.ts

@@ -0,0 +1,34 @@
+import { PAYMENT_PROVIDERS, PAYMENT_STATUSES } from '../../constants';
+export type PaymentProviderName = (typeof PAYMENT_PROVIDERS)[keyof typeof PAYMENT_PROVIDERS];
+export type PaymentStatus = (typeof PAYMENT_STATUSES)[keyof typeof PAYMENT_STATUSES];
+/**
+ * Generic payment provider data that can be reused across different providers
+ * This allows easy switching between Stripe, PayPal, etc.
+ */
+export interface PaymentProviderData {
+    provider: PaymentProviderName;
+    paymentIntentId?: string;
+    transactionId: string;
+    amountPaid: number;
+    currency: string;
+    paymentStatus: PaymentStatus;
+    paymentMethod?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Strategy interface for payment providers
+ */
+export interface PaymentProvider {
+    /**
+     * Confirm and validate a purchase from webhook payload
+     */
+    confirmPurchase(payload: any, signature?: string): Promise<PaymentProviderData>;
+    /**
+     * Validate webhook signature if provided
+     */
+    validateWebhookSignature?(payload: any, signature: string): boolean;
+    /**
+     * Get provider name
+     */
+    getProviderName(): string;
+}

package/dist/types/ticketing/PaymentProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/PlayerTurn.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { GameTurnSchema } from './ticketing.schemas';
+export type GameTurn = z.infer<typeof GameTurnSchema>;

package/dist/types/ticketing/PlayerTurn.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/Purchase.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { PurchaseSchema } from './ticketing.schemas';
+export type Purchase = z.infer<typeof PurchaseSchema>;

package/dist/types/ticketing/Purchase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ticketing/index.d.ts

@@ -0,0 +1,9 @@
+export * from './GameTicket';
+export * from './PaymentProvider';
+export * from './GameTurn';
+export * from './Purchase';
+export * from './ticketing.schemas';
+export * from './ticketing.schemas';
+export * from './GameTurnTask';
+export * from './GameTurnTask.schema';
+export * from './GameTurn.schema';

package/dist/types/ticketing/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GameTicket"), exports);
+__exportStar(require("./PaymentProvider"), exports);
+__exportStar(require("./GameTurn"), exports);
+__exportStar(require("./Purchase"), exports);
+__exportStar(require("./ticketing.schemas"), exports);
+__exportStar(require("./ticketing.schemas"), exports);
+__exportStar(require("./GameTurnTask"), exports);
+__exportStar(require("./GameTurnTask.schema"), exports);
+__exportStar(require("./GameTurn.schema"), exports);

package/dist/types/ticketing/ticketing.schemas.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export declare const GAME_TICKET_STATUS: {
+    readonly CREATED: "created";
+    readonly ASSIGNED: "assigned";
+    readonly ACTIVE: "active";
+    readonly COMPLETED: "completed";
+};
+export declare const TICKET_USER_TYPE: {
+    readonly LEADER: "leader";
+    readonly SUB_USER: "sub-user";
+    readonly EXISTING: "existing";
+    readonly GUEST: "guest";
+};
+export declare const GameTicketStatusSchema: z.ZodEnum<{
+    readonly CREATED: "created";
+    readonly ASSIGNED: "assigned";
+    readonly ACTIVE: "active";
+    readonly COMPLETED: "completed";
+}>;
+export declare const TicketUserTypeSchema: z.ZodEnum<{
+    readonly LEADER: "leader";
+    readonly SUB_USER: "sub-user";
+    readonly EXISTING: "existing";
+    readonly GUEST: "guest";
+}>;
+export declare const GameTicketSchema: z.ZodObject<{
+    id: z.ZodString;
+    purchaseId: z.ZodString;
+    gameTurnId: z.ZodString;
+    ownerUsername: z.ZodString;
+    userType: z.ZodEnum<{
+        readonly LEADER: "leader";
+        readonly SUB_USER: "sub-user";
+        readonly EXISTING: "existing";
+        readonly GUEST: "guest";
+    }>;
+    status: z.ZodEnum<{
+        readonly CREATED: "created";
+        readonly ASSIGNED: "assigned";
+        readonly ACTIVE: "active";
+        readonly COMPLETED: "completed";
+    }>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export declare const PurchaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    purchaseNumber: z.ZodNumber;
+    buyerUserId: z.ZodString;
+    totalTickets: z.ZodNumber;
+    availableTickets: z.ZodNumber;
+    usedTickets: z.ZodNumber;
+    purchaseDate: z.ZodDate;
+    paymentData: z.ZodOptional<z.ZodAny>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;

package/dist/types/ticketing/ticketing.schemas.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PurchaseSchema = exports.GameTicketSchema = exports.TicketUserTypeSchema = exports.GameTicketStatusSchema = exports.TICKET_USER_TYPE = exports.GAME_TICKET_STATUS = void 0;
+const zod_1 = require("zod");
+exports.GAME_TICKET_STATUS = {
+    CREATED: 'created',
+    ASSIGNED: 'assigned',
+    ACTIVE: 'active',
+    COMPLETED: 'completed',
+};
+exports.TICKET_USER_TYPE = {
+    LEADER: 'leader',
+    SUB_USER: 'sub-user',
+    EXISTING: 'existing',
+    GUEST: 'guest',
+};
+exports.GameTicketStatusSchema = zod_1.z.enum(exports.GAME_TICKET_STATUS);
+exports.TicketUserTypeSchema = zod_1.z.enum(exports.TICKET_USER_TYPE);
+exports.GameTicketSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    purchaseId: zod_1.z.string(),
+    gameTurnId: zod_1.z.string(),
+    ownerUsername: zod_1.z.string(),
+    userType: exports.TicketUserTypeSchema,
+    status: exports.GameTicketStatusSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    completedAt: zod_1.z.date().optional(),
+});
+exports.PurchaseSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    purchaseNumber: zod_1.z.number(),
+    buyerUserId: zod_1.z.string(),
+    totalTickets: zod_1.z.number(),
+    availableTickets: zod_1.z.number(),
+    usedTickets: zod_1.z.number(),
+    purchaseDate: zod_1.z.date(),
+    paymentData: zod_1.z.any().optional(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/dist/types/user/User.d.ts

@@ -1,9 +1,4 @@
-import type { UserRole } from '../role/UserRole';
-import type { UserOrigin } from './UserOrigin';
-export interface User {
-    id: string;
-    username: string;
-    name: string;
-    origin: UserOrigin;
-    role: UserRole;
-}
+import { z } from 'zod';
+import { UserSchema, UserWithPasswordSchema } from './user.schema';
+export type User = z.infer<typeof UserSchema>;
+export type UserWithPassword = z.infer<typeof UserWithPasswordSchema>;

package/dist/types/user/index.d.ts

@@ -1,2 +1,4 @@
 export * from './User';
-export * from './UserOrigin';
+export * from './user-type.schema';
+export * from './user.schema';
+export { USER_TYPE } from './user-type.schema';