@bondsports/types 2.3.53-a-1 → 2.3.53-a-3

package/dist/types/leagues-scheduler/dto/program-segments-integration.dto.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchCreateLeagueSegmentsResponseDto = exports.BatchCreateLeagueSegmentsRequestDto = exports.CreateLeagueSegmentResponseDto = exports.CreateLeagueSegmentRequestDto = void 0;
+/**
+ * Request DTO for creating a league segment via Program Segments API
+ * Used when publishing a schedule to create segments with all events
+ */
+class CreateLeagueSegmentRequestDto {
+}
+exports.CreateLeagueSegmentRequestDto = CreateLeagueSegmentRequestDto;
+/**
+ * Response DTO from Program Segments API after creating a league segment
+ * Contains created entities and any conflicts detected
+ */
+class CreateLeagueSegmentResponseDto {
+}
+exports.CreateLeagueSegmentResponseDto = CreateLeagueSegmentResponseDto;
+/**
+ * Batch request for creating multiple league segments at once
+ * Used when publishing schedules for multiple divisions
+ */
+class BatchCreateLeagueSegmentsRequestDto {
+}
+exports.BatchCreateLeagueSegmentsRequestDto = BatchCreateLeagueSegmentsRequestDto;
+/**
+ * Response DTO for batch segment creation
+ */
+class BatchCreateLeagueSegmentsResponseDto {
+}
+exports.BatchCreateLeagueSegmentsResponseDto = BatchCreateLeagueSegmentsResponseDto;
+//# sourceMappingURL=program-segments-integration.dto.js.map

package/dist/types/leagues-scheduler/dto/program-segments-integration.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"program-segments-integration.dto.js","sourceRoot":"","sources":["../../../../src/types/leagues-scheduler/dto/program-segments-integration.dto.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACH,MAAa,6BAA6B;CAczC;AAdD,sEAcC;AAED;;;GAGG;AACH,MAAa,8BAA8B;CAQ1C;AARD,wEAQC;AAED;;;GAGG;AACH,MAAa,mCAAmC;CAI/C;AAJD,kFAIC;AAED;;GAEG;AACH,MAAa,oCAAoC;CAWhD;AAXD,oFAWC"}

package/dist/types/leagues-scheduler/dto/quality-metrics.dto.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Query DTO for getting schedule quality
+ */
+export declare class GetScheduleQualityQueryDto {
+    seasonFolderId: number;
+    draftId?: number;
+}
+/**
+ * Constraint satisfaction details DTO
+ */
+export declare class ConstraintDetailsDto {
+    missingMatchups?: string[];
+    missingRegularSeasonMatchups?: string[];
+    missingPlayoffMatchups?: string[];
+    roundIssues?: string[];
+    venueIssues?: string[];
+}
+/**
+ * Constraint satisfaction metrics DTO
+ */
+export declare class ConstraintSatisfactionDto {
+    score: number;
+    roundRobinCompleteness: number;
+    regularSeasonCompleteness: number;
+    playoffCompleteness: number;
+    roundLengthAdherence: number;
+    venueUtilization: number;
+    details: ConstraintDetailsDto;
+}
+/**
+ * Fairness details DTO
+ */
+export declare class FairnessDetailsDto {
+    timeSlotImbalances?: Record<string, Record<string, number>>;
+    homeAwayImbalances?: Record<string, {
+        home: number;
+        away: number;
+        diff: number;
+    }>;
+    byeImbalances?: Record<string, {
+        total: number;
+        rounds: number[];
+    }>;
+    spacingIssues?: string[];
+}
+/**
+ * Fairness metrics DTO
+ */
+export declare class FairnessMetricsDto {
+    score: number;
+    timeSlotBalance: number;
+    homeAwayBalance: number;
+    opponentSpacing: number;
+    byeWeekRotation: number;
+    details: FairnessDetailsDto;
+}
+/**
+ * Validity details DTO
+ */
+export declare class ValidityDetailsDto {
+    timeConflicts?: string[];
+    breakViolations?: string[];
+    blackoutViolations?: string[];
+    outOfBoundsGames?: string[];
+}
+/**
+ * Validity checks DTO
+ */
+export declare class ValidityChecksDto {
+    score: number;
+    noTimeConflicts: boolean;
+    sufficientBreaks: boolean;
+    blackoutDatesRespected: boolean;
+    withinSeasonBounds: boolean;
+    details: ValidityDetailsDto;
+}
+/**
+ * Additional metrics DTO
+ */
+export declare class AdditionalMetricsDto {
+    score: number;
+    travelEfficiency?: number;
+    preferredDaysUtilization?: number;
+    specialRequestsSatisfied?: number;
+    details: Record<string, number | string | boolean>;
+}
+/**
+ * Main schedule quality score DTO
+ */
+export declare class ScheduleQualityScoreDto {
+    overallScore: number;
+    constraintSatisfaction: ConstraintSatisfactionDto;
+    fairness: FairnessMetricsDto;
+    validity: ValidityChecksDto;
+    additional: AdditionalMetricsDto;
+}

package/dist/types/leagues-scheduler/dto/quality-metrics.dto.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleQualityScoreDto = exports.AdditionalMetricsDto = exports.ValidityChecksDto = exports.ValidityDetailsDto = exports.FairnessMetricsDto = exports.FairnessDetailsDto = exports.ConstraintSatisfactionDto = exports.ConstraintDetailsDto = exports.GetScheduleQualityQueryDto = void 0;
+/**
+ * Query DTO for getting schedule quality
+ */
+class GetScheduleQualityQueryDto {
+}
+exports.GetScheduleQualityQueryDto = GetScheduleQualityQueryDto;
+/**
+ * Constraint satisfaction details DTO
+ */
+class ConstraintDetailsDto {
+}
+exports.ConstraintDetailsDto = ConstraintDetailsDto;
+/**
+ * Constraint satisfaction metrics DTO
+ */
+class ConstraintSatisfactionDto {
+}
+exports.ConstraintSatisfactionDto = ConstraintSatisfactionDto;
+/**
+ * Fairness details DTO
+ */
+class FairnessDetailsDto {
+}
+exports.FairnessDetailsDto = FairnessDetailsDto;
+/**
+ * Fairness metrics DTO
+ */
+class FairnessMetricsDto {
+}
+exports.FairnessMetricsDto = FairnessMetricsDto;
+/**
+ * Validity details DTO
+ */
+class ValidityDetailsDto {
+}
+exports.ValidityDetailsDto = ValidityDetailsDto;
+/**
+ * Validity checks DTO
+ */
+class ValidityChecksDto {
+}
+exports.ValidityChecksDto = ValidityChecksDto;
+/**
+ * Additional metrics DTO
+ */
+class AdditionalMetricsDto {
+}
+exports.AdditionalMetricsDto = AdditionalMetricsDto;
+/**
+ * Main schedule quality score DTO
+ */
+class ScheduleQualityScoreDto {
+}
+exports.ScheduleQualityScoreDto = ScheduleQualityScoreDto;
+//# sourceMappingURL=quality-metrics.dto.js.map

package/dist/types/leagues-scheduler/dto/quality-metrics.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-metrics.dto.js","sourceRoot":"","sources":["../../../../src/types/leagues-scheduler/dto/quality-metrics.dto.ts"],"names":[],"mappings":";;;AACA;;GAEG;AACH,MAAa,0BAA0B;CAItC;AAJD,gEAIC;AAED;;GAEG;AACH,MAAa,oBAAoB;CAUhC;AAVD,oDAUC;AAED;;GAEG;AACH,MAAa,yBAAyB;CAcrC;AAdD,8DAcC;AAED;;GAEG;AACH,MAAa,kBAAkB;CAQ9B;AARD,gDAQC;AAED;;GAEG;AACH,MAAa,kBAAkB;CAY9B;AAZD,gDAYC;AAED;;GAEG;AACH,MAAa,kBAAkB;CAQ9B;AARD,gDAQC;AAED;;GAEG;AACH,MAAa,iBAAiB;CAY7B;AAZD,8CAYC;AAED;;GAEG;AACH,MAAa,oBAAoB;CAUhC;AAVD,oDAUC;AAED;;GAEG;AACH,MAAa,uBAAuB;CAUnC;AAVD,0DAUC"}

package/dist/types/leagues-scheduler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dto';
+export * from './types';

package/dist/types/leagues-scheduler/index.js

@@ -0,0 +1,19 @@
+"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("./dto"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/leagues-scheduler/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/leagues-scheduler/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB;AACtB,0CAAwB"}

package/dist/types/leagues-scheduler/types/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './leagues-scheduler-enums';

package/dist/types/leagues-scheduler/types/enums/index.js

@@ -0,0 +1,18 @@
+"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("./leagues-scheduler-enums"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/leagues-scheduler/types/enums/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/leagues-scheduler/types/enums/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C"}

package/dist/types/leagues-scheduler/types/enums/leagues-scheduler-enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum ScheduleStatusEnum {
+    DRAFT = "draft",
+    PUBLISHED = "published"
+}

package/dist/types/leagues-scheduler/types/enums/leagues-scheduler-enums.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleStatusEnum = void 0;
+var ScheduleStatusEnum;
+(function (ScheduleStatusEnum) {
+    ScheduleStatusEnum["DRAFT"] = "draft";
+    ScheduleStatusEnum["PUBLISHED"] = "published";
+})(ScheduleStatusEnum = exports.ScheduleStatusEnum || (exports.ScheduleStatusEnum = {}));
+//# sourceMappingURL=leagues-scheduler-enums.js.map

package/dist/types/leagues-scheduler/types/enums/leagues-scheduler-enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leagues-scheduler-enums.js","sourceRoot":"","sources":["../../../../../src/types/leagues-scheduler/types/enums/leagues-scheduler-enums.ts"],"names":[],"mappings":";;;AAAA,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC7B,qCAAe,CAAA;IACf,6CAAuB,CAAA;AACxB,CAAC,EAHW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAG7B"}

package/dist/types/leagues-scheduler/types/enums.d.ts

@@ -0,0 +1,27 @@
+export declare enum ScheduleStatusEnum {
+    DRAFT = "draft",
+    PUBLISHED = "published"
+}
+export declare enum ByeWeekPolicyEnum {
+    SKIP = "skip",
+    REPEAT = "repeat",
+    RANDOM = "random"
+}
+export declare enum ScheduleConflictTypeEnum {
+    RESOURCE_UNAVAILABLE = "resource_unavailable",
+    TEAM_DOUBLE_BOOKING = "team_double_booking",
+    TIME_CONFLICT = "time_conflict",
+    BLACKOUT_DATE = "blackout_date",
+    TEAM_BLACKOUT = "team_blackout"
+}
+export declare enum ValidationSeverityEnum {
+    WARNING = "warning",
+    ERROR = "error"
+}
+export declare enum GameTypeEnum {
+    LEAGUE = "league",
+    PLAYOFF = "playoff",
+    TOURNAMENT = "tournament",
+    PRACTICE = "practice",
+    TRYOUT = "tryout"
+}

package/dist/types/leagues-scheduler/types/enums.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameTypeEnum = exports.ValidationSeverityEnum = exports.ScheduleConflictTypeEnum = exports.ByeWeekPolicyEnum = exports.ScheduleStatusEnum = void 0;
+var ScheduleStatusEnum;
+(function (ScheduleStatusEnum) {
+    ScheduleStatusEnum["DRAFT"] = "draft";
+    ScheduleStatusEnum["PUBLISHED"] = "published";
+})(ScheduleStatusEnum = exports.ScheduleStatusEnum || (exports.ScheduleStatusEnum = {}));
+var ByeWeekPolicyEnum;
+(function (ByeWeekPolicyEnum) {
+    ByeWeekPolicyEnum["SKIP"] = "skip";
+    ByeWeekPolicyEnum["REPEAT"] = "repeat";
+    ByeWeekPolicyEnum["RANDOM"] = "random";
+})(ByeWeekPolicyEnum = exports.ByeWeekPolicyEnum || (exports.ByeWeekPolicyEnum = {}));
+var ScheduleConflictTypeEnum;
+(function (ScheduleConflictTypeEnum) {
+    ScheduleConflictTypeEnum["RESOURCE_UNAVAILABLE"] = "resource_unavailable";
+    ScheduleConflictTypeEnum["TEAM_DOUBLE_BOOKING"] = "team_double_booking";
+    ScheduleConflictTypeEnum["TIME_CONFLICT"] = "time_conflict";
+    ScheduleConflictTypeEnum["BLACKOUT_DATE"] = "blackout_date";
+    ScheduleConflictTypeEnum["TEAM_BLACKOUT"] = "team_blackout";
+})(ScheduleConflictTypeEnum = exports.ScheduleConflictTypeEnum || (exports.ScheduleConflictTypeEnum = {}));
+var ValidationSeverityEnum;
+(function (ValidationSeverityEnum) {
+    ValidationSeverityEnum["WARNING"] = "warning";
+    ValidationSeverityEnum["ERROR"] = "error";
+})(ValidationSeverityEnum = exports.ValidationSeverityEnum || (exports.ValidationSeverityEnum = {}));
+var GameTypeEnum;
+(function (GameTypeEnum) {
+    GameTypeEnum["LEAGUE"] = "league";
+    GameTypeEnum["PLAYOFF"] = "playoff";
+    GameTypeEnum["TOURNAMENT"] = "tournament";
+    GameTypeEnum["PRACTICE"] = "practice";
+    GameTypeEnum["TRYOUT"] = "tryout";
+})(GameTypeEnum = exports.GameTypeEnum || (exports.GameTypeEnum = {}));
+//# sourceMappingURL=enums.js.map

package/dist/types/leagues-scheduler/types/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../src/types/leagues-scheduler/types/enums.ts"],"names":[],"mappings":";;;AAAA,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC7B,qCAAe,CAAA;IACf,6CAAuB,CAAA;AACxB,CAAC,EAHW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAG7B;AAED,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC5B,kCAAa,CAAA;IACb,sCAAiB,CAAA;IACjB,sCAAiB,CAAA;AAClB,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED,IAAY,wBAMX;AAND,WAAY,wBAAwB;IACnC,yEAA6C,CAAA;IAC7C,uEAA2C,CAAA;IAC3C,2DAA+B,CAAA;IAC/B,2DAA+B,CAAA;IAC/B,2DAA+B,CAAA;AAChC,CAAC,EANW,wBAAwB,GAAxB,gCAAwB,KAAxB,gCAAwB,QAMnC;AAED,IAAY,sBAGX;AAHD,WAAY,sBAAsB;IACjC,6CAAmB,CAAA;IACnB,yCAAe,CAAA;AAChB,CAAC,EAHW,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAGjC;AAED,IAAY,YAMX;AAND,WAAY,YAAY;IACvB,iCAAiB,CAAA;IACjB,mCAAmB,CAAA;IACnB,yCAAyB,CAAA;IACzB,qCAAqB,CAAA;IACrB,iCAAiB,CAAA;AAClB,CAAC,EANW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAMvB"}

package/dist/types/leagues-scheduler/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './enums';
+export * from './enums';
+export * from './interfaces';
+export * from './leagues-scheduler-consts';
+export * from './quality-types';

package/dist/types/leagues-scheduler/types/index.js

@@ -0,0 +1,22 @@
+"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("./enums"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./leagues-scheduler-consts"), exports);
+__exportStar(require("./quality-types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/leagues-scheduler/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/types/leagues-scheduler/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,0CAAwB;AACxB,+CAA6B;AAC7B,6DAA2C;AAC3C,kDAAgC"}

package/dist/types/leagues-scheduler/types/interfaces.d.ts

@@ -0,0 +1,271 @@
+import { EntityManager } from 'typeorm';
+import { FolderContent } from '../../folders/entities/folder-content.entity';
+import { ScheduleStatusEnum, ByeWeekPolicyEnum, ScheduleConflictTypeEnum, ValidationSeverityEnum, GameTypeEnum } from './enums';
+export { ScheduleStatusEnum, ByeWeekPolicyEnum, ScheduleConflictTypeEnum, ValidationSeverityEnum, GameTypeEnum, };
+export declare const EVENT_SUBTYPE_GAME = "game";
+export interface ILeagueScheduleTimeSlot {
+    id: string;
+    resourceId: number;
+    dayOfWeek: number;
+    endTime: string;
+    isRecurring: boolean;
+    startTime: string;
+}
+export interface IMaintenanceEvent {
+    duration: number;
+    name: string;
+}
+/**
+ * Represents a time window for scheduling games
+ * Allows different time ranges for different days (e.g., weekday vs weekend schedules)
+ * Can optionally be scoped to a specific resource/space
+ */
+export interface ITimeWindow {
+    /** Days of week this window applies to (0=Sunday, 1=Monday, ..., 6=Saturday) */
+    days: number[];
+    /** Start time of the window in HH:MM format (24-hour) */
+    startTime: string;
+    /** End time of the window in HH:MM format (24-hour) */
+    endTime: string;
+    /** Optional: Specific start times within the window for game scheduling */
+    slotStartTimes?: string[];
+    /** Optional: Resource/space ID this window is scoped to. If not specified, applies to all resources. */
+    resourceId?: number;
+}
+export interface IScheduleConfig {
+    blackoutDates?: string[];
+    breakBetweenGames?: number;
+    byeWeekPolicy: ByeWeekPolicyEnum;
+    gameDuration: number;
+    gamesPerTeam?: number;
+    gamesPerWeek: number;
+    isCreateSlots?: boolean;
+    maintenanceEvents?: IMaintenanceEvent[];
+    maxGamesPerDay?: number;
+    minimumRestTime?: number;
+    timeWindows?: ITimeWindow[];
+    preferredDays?: number[];
+    preferredTimes?: string[];
+    resourceIds?: number[];
+    resourcePriorities?: Record<number, number>;
+    rounds?: number;
+    seasonEndDate?: string;
+    seasonStartDate: string;
+    selectedFolderIds?: number[];
+    teamBlackoutDates?: Record<number, string[]>;
+}
+export interface IGameSchedule {
+    awayParentId?: number;
+    awayTeamId: number;
+    divisionId?: number;
+    gameId: string;
+    homeParentId?: number;
+    homeTeamId: number;
+    resourceId: number;
+    date: string;
+    endTime: string;
+    eventTitle: string;
+    gameNumber?: number;
+    gameType?: string;
+    isMaintenance?: boolean;
+    isPlayoff: boolean;
+    maintenanceName?: string;
+    participants: number[];
+    round: number;
+    startTime: string;
+    week: number;
+}
+export interface ITeamSchedule {
+    teamId: number;
+    awayGames: number;
+    byeWeeks: number[];
+    games: IGameSchedule[];
+    homeGames: number;
+    teamName: string;
+}
+export interface IDivisionSchedule {
+    divisionId: number;
+    divisionName: string;
+    games: IGameSchedule[];
+    teams: ITeamSchedule[];
+}
+export interface IScheduleConflict {
+    gameId: string;
+    description: string;
+    severity: ValidationSeverityEnum;
+    type: ScheduleConflictTypeEnum;
+}
+export interface IGenerateScheduleOptions {
+    isGenerateOptimized?: boolean;
+    isValidatedOnly?: boolean;
+    maxIterations?: number;
+}
+export interface IGeneratedSchedule {
+    id: number;
+    seasonId: number;
+    config: IScheduleConfig;
+    conflicts: IScheduleConflict[];
+    divisions: IDivisionSchedule[];
+    generatedAt: string;
+    maintenanceEvents?: IMaintenanceEvent[];
+    totalGames: number;
+}
+export interface ILeagueGameMetadata {
+    awayParentId: number;
+    awayTeamId: number;
+    homeParentId: number;
+    homeTeamId: number;
+    gameType: GameTypeEnum;
+    isMaintenance?: boolean;
+    maintenanceName?: string;
+    scheduledBy: string;
+}
+export interface IDraftSchedule {
+    draftId: number;
+    createdAt: string;
+    draftName: string;
+    schedule: IGeneratedSchedule;
+    status?: ScheduleStatusEnum;
+    publishedAt?: string;
+}
+export interface ILeagueScheduleData {
+    draftSchedules?: IDraftSchedule[];
+    events: number[];
+    lastUpdated?: string;
+    scheduleConfig?: IScheduleConfig;
+    version?: string;
+}
+export interface ISeasonFolderContentsResponse {
+    seasonFolderId: number;
+    data: FolderContent[];
+    status: string;
+    totalGames: number;
+}
+export interface ILeagueScheduleDataResponse {
+    draftSchedules: unknown[];
+    events: number[];
+    lastUpdated?: string;
+    message?: string;
+    scheduleConfig: IScheduleConfig | null;
+    version?: string;
+}
+export interface IPublishedScheduleMetadata {
+    eventIds?: number[];
+    publishedAt: string;
+    publishedBy: string;
+    segmentIds?: number[];
+    totalGames: number;
+    version: number;
+}
+export interface IGenerationHistoryEntry {
+    config: IScheduleConfig;
+    conflicts?: string[];
+    generatedAt: string;
+    generatedBy: string;
+    status: ScheduleStatusEnum;
+    totalGames?: number;
+    version: number;
+}
+export interface ISelectBestResourceParams {
+    organizationId: number;
+    checkResourceConflicts: (organizationId: number, resourceId: number, date: string, startTime: string, endTime: string) => Promise<IScheduleConflict[]>;
+    date: string;
+    endTime: string;
+    resourceCheckCache: Map<string, IScheduleConflict[]>;
+    resourceIds: number[];
+    resourcePriorities: Record<number, number> | undefined;
+    startTime: string;
+}
+export interface ITimeOverlapParams {
+    end1: string;
+    end2: string;
+    start1: string;
+    start2: string;
+}
+export interface IValidateScheduleParams {
+    organizationId: number;
+    config: IScheduleConfig;
+    manager: EntityManager;
+    schedule: IGeneratedSchedule;
+}
+export interface IValidateMinimumRestParams {
+    teamId: number;
+    allGames: IGameSchedule[];
+    gameDate: Date;
+    gameStartTime: string;
+    minimumRestMinutes: number;
+}
+export interface IValidateMaxGamesParams {
+    awayTeamId: number;
+    homeTeamId: number;
+    allGames: IGameSchedule[];
+    gameDate: Date;
+    maxGamesPerDay: number;
+}
+export interface ICheckTeamDoubleBookingParams {
+    allGames: IGameSchedule[];
+    gameDate: Date;
+    gameEndTime: string;
+    gameStartTime: string;
+    matchup: {
+        homeTeam: {
+            id: number;
+            name: string;
+        };
+        awayTeam: {
+            id: number;
+            name: string;
+        };
+        round: number;
+    };
+}
+export interface IValidateWithResourceParams {
+    organizationId: number;
+    config: IScheduleConfig;
+    manager: EntityManager;
+    schedule: IGeneratedSchedule;
+}
+export interface ICheckResourceConflictsParams {
+    organizationId: number;
+    gameId?: string;
+    resourceId: number;
+    date: string;
+    endTime: string;
+    manager: EntityManager;
+    startTime: string;
+}
+export interface IGenerateScheduleParams {
+    organizationId: number;
+    config: IScheduleConfig;
+    teams: Array<{
+        id: number;
+        name: string;
+    }>;
+}
+export interface IPublishScheduleParams {
+    organizationId: number;
+    draftId?: number;
+    seasonFolderId: number;
+    seasonId: number;
+    userId?: number;
+    schedule: IGeneratedSchedule;
+}
+export interface ICreateEventParams {
+    organizationId: number;
+    colorCodeId: number | null;
+    resourceId: number;
+    seasonId: number;
+    userId?: number;
+    game: IGameSchedule;
+    isCreateSlots: boolean;
+    timezone: string;
+}
+export interface ICreateEventsParams {
+    organizationId: number;
+    colorCodeId: number | null;
+    seasonId: number;
+    userId?: number;
+    games: IGameSchedule[];
+    isCreateSlots: boolean;
+    timezone: string;
+}

package/dist/types/leagues-scheduler/types/interfaces.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_SUBTYPE_GAME = exports.GameTypeEnum = exports.ValidationSeverityEnum = exports.ScheduleConflictTypeEnum = exports.ByeWeekPolicyEnum = exports.ScheduleStatusEnum = void 0;
+const enums_1 = require("./enums");
+Object.defineProperty(exports, "ScheduleStatusEnum", { enumerable: true, get: function () { return enums_1.ScheduleStatusEnum; } });
+Object.defineProperty(exports, "ByeWeekPolicyEnum", { enumerable: true, get: function () { return enums_1.ByeWeekPolicyEnum; } });
+Object.defineProperty(exports, "ScheduleConflictTypeEnum", { enumerable: true, get: function () { return enums_1.ScheduleConflictTypeEnum; } });
+Object.defineProperty(exports, "ValidationSeverityEnum", { enumerable: true, get: function () { return enums_1.ValidationSeverityEnum; } });
+Object.defineProperty(exports, "GameTypeEnum", { enumerable: true, get: function () { return enums_1.GameTypeEnum; } });
+// Event subtype constants for leagues scheduler
+exports.EVENT_SUBTYPE_GAME = 'game';
+//# sourceMappingURL=interfaces.js.map

package/dist/types/leagues-scheduler/types/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../src/types/leagues-scheduler/types/interfaces.ts"],"names":[],"mappings":";;;AAGA,mCAMiB;AAGhB,mGARA,0BAAkB,OAQA;AAClB,kGARA,yBAAiB,OAQA;AACjB,yGARA,gCAAwB,OAQA;AACxB,uGARA,8BAAsB,OAQA;AACtB,6FARA,oBAAY,OAQA;AAGb,gDAAgD;AACnC,QAAA,kBAAkB,GAAG,MAAM,CAAC"}

package/dist/types/leagues-scheduler/types/leagues-scheduler-consts.d.ts

@@ -0,0 +1,4 @@
+export declare const MINUTES_IN_HOUR = 60;
+export declare const HOURS_IN_DAY = 24;
+export declare const HOURS_IN_HALF_DAY = 12;
+export declare const DAYS_IN_WEEK = 7;

package/dist/types/leagues-scheduler/types/leagues-scheduler-consts.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAYS_IN_WEEK = exports.HOURS_IN_HALF_DAY = exports.HOURS_IN_DAY = exports.MINUTES_IN_HOUR = void 0;
+exports.MINUTES_IN_HOUR = 60;
+exports.HOURS_IN_DAY = 24;
+exports.HOURS_IN_HALF_DAY = 12;
+exports.DAYS_IN_WEEK = 7;
+//# sourceMappingURL=leagues-scheduler-consts.js.map