tods-competition-factory 2.0.0-alpha.0 → 2.0.0-beta.0

package/dist/tods-competition-factory.d.ts

@@ -2137,6 +2137,12 @@ type FactoryEngine = {
 type TournamentRecords = {
     [key: string]: Tournament;
 };
+type Directives = {
+    params?: {
+        [key: string]: any;
+    };
+    method: string;
+}[];
 type CheckInOutParticipantArgs = {
     tournamentRecord: Tournament;
     drawDefinition: DrawDefinition;
@@ -2148,6 +2154,10 @@ type CheckInOutParticipantArgs = {
 type ScheduleTimesResult = {
     scheduleTime: string;
 };
+type SeedBlock = {
+    drawPositions: number[];
+    seedNumbers: number[];
+};
 type SeedingProfile = {
     groupSeedingThreshold?: number;
     positioning?: string;
@@ -2428,6 +2438,9 @@ type GroupsMatchUpsResult = {
     success?: boolean;
     error?: ErrorType;
 };
+type ExitProfiles = {
+    [key: string]: string[];
+};
 type MinutesMapping = {
     categoryNames: string[];
     minutes: any;
@@ -2448,6 +2461,11 @@ type ScheduleTiming = {
         };
     }[];
 };
+type Substitution = {
+    previousParticipantId: string;
+    substitutionOrder: number;
+    participantId: string;
+};
 type PlayoffAttributes = {
     [key: string | number]: {
         name: string;
@@ -2455,6 +2473,21 @@ type PlayoffAttributes = {
     };
 };
 type LineUp = TeamCompetitor[];
+type StructureProfile = {
+    distanceFromMain?: number;
+    drawSources: string[];
+    drawTargets: string[];
+    progeny?: string[];
+    sources: string[];
+    targets: string[];
+    rootStage?: string;
+    stage?: string;
+};
+type IdCollections = {
+    groupParticipants: string[];
+    pairParticipants: string[];
+    teamParticipants: string[];
+};
 type Request$1 = {
     requestType: string;
     requestId: string;
@@ -2474,6 +2507,50 @@ type AddScheduleAttributeArgs = {
     event?: Event$1;
 };
 
+type factoryTypes_AddScheduleAttributeArgs = AddScheduleAttributeArgs;
+type factoryTypes_AddressProps = AddressProps;
+type factoryTypes_CheckInOutParticipantArgs = CheckInOutParticipantArgs;
+type factoryTypes_ContextContent = ContextContent;
+type factoryTypes_ContextProfile = ContextProfile;
+type factoryTypes_Directives = Directives;
+type factoryTypes_ExitProfiles = ExitProfiles;
+type factoryTypes_FactoryEngine = FactoryEngine;
+type factoryTypes_Flight = Flight;
+type factoryTypes_FlightProfile = FlightProfile;
+type factoryTypes_GetMatchUpsArgs = GetMatchUpsArgs;
+type factoryTypes_GroupInfo = GroupInfo;
+type factoryTypes_GroupsMatchUpsResult = GroupsMatchUpsResult;
+type factoryTypes_IdCollections = IdCollections;
+type factoryTypes_LineUp = LineUp;
+type factoryTypes_MappedParticipant = MappedParticipant;
+type factoryTypes_ParticipantFilters = ParticipantFilters;
+type factoryTypes_ParticipantMap = ParticipantMap;
+type factoryTypes_ParticipantsProfile = ParticipantsProfile;
+type factoryTypes_PersonData = PersonData;
+type factoryTypes_PersonRequests = PersonRequests;
+type factoryTypes_PlayoffAttributes = PlayoffAttributes;
+type factoryTypes_PolicyDefinitions = PolicyDefinitions;
+type factoryTypes_QueueMethod = QueueMethod;
+type factoryTypes_RoundProfile = RoundProfile;
+type factoryTypes_ScaleAttributes = ScaleAttributes;
+type factoryTypes_ScaleItem = ScaleItem;
+type factoryTypes_ScheduleAnalysis = ScheduleAnalysis;
+type factoryTypes_ScheduleConflict = ScheduleConflict;
+type factoryTypes_ScheduleTimesResult = ScheduleTimesResult;
+type factoryTypes_ScheduleTiming = ScheduleTiming;
+type factoryTypes_ScheduleVisibilityFilters = ScheduleVisibilityFilters;
+type factoryTypes_SeedBlock = SeedBlock;
+type factoryTypes_SeedingProfile = SeedingProfile;
+type factoryTypes_StructureParticipation = StructureParticipation;
+type factoryTypes_StructureProfile = StructureProfile;
+type factoryTypes_StructureSortConfig = StructureSortConfig;
+type factoryTypes_Substitution = Substitution;
+type factoryTypes_TeamKey = TeamKey;
+type factoryTypes_TournamentRecords = TournamentRecords;
+declare namespace factoryTypes {
+  export type { factoryTypes_AddScheduleAttributeArgs as AddScheduleAttributeArgs, factoryTypes_AddressProps as AddressProps, factoryTypes_CheckInOutParticipantArgs as CheckInOutParticipantArgs, factoryTypes_ContextContent as ContextContent, factoryTypes_ContextProfile as ContextProfile, factoryTypes_Directives as Directives, factoryTypes_ExitProfiles as ExitProfiles, factoryTypes_FactoryEngine as FactoryEngine, factoryTypes_Flight as Flight, factoryTypes_FlightProfile as FlightProfile, factoryTypes_GetMatchUpsArgs as GetMatchUpsArgs, factoryTypes_GroupInfo as GroupInfo, factoryTypes_GroupsMatchUpsResult as GroupsMatchUpsResult, factoryTypes_IdCollections as IdCollections, factoryTypes_LineUp as LineUp, factoryTypes_MappedParticipant as MappedParticipant, factoryTypes_ParticipantFilters as ParticipantFilters, factoryTypes_ParticipantMap as ParticipantMap, factoryTypes_ParticipantsProfile as ParticipantsProfile, factoryTypes_PersonData as PersonData, factoryTypes_PersonRequests as PersonRequests, factoryTypes_PlayoffAttributes as PlayoffAttributes, factoryTypes_PolicyDefinitions as PolicyDefinitions, factoryTypes_QueueMethod as QueueMethod, factoryTypes_RoundProfile as RoundProfile, factoryTypes_ScaleAttributes as ScaleAttributes, factoryTypes_ScaleItem as ScaleItem, factoryTypes_ScheduleAnalysis as ScheduleAnalysis, factoryTypes_ScheduleConflict as ScheduleConflict, factoryTypes_ScheduleTimesResult as ScheduleTimesResult, factoryTypes_ScheduleTiming as ScheduleTiming, factoryTypes_ScheduleVisibilityFilters as ScheduleVisibilityFilters, factoryTypes_SeedBlock as SeedBlock, factoryTypes_SeedingProfile as SeedingProfile, factoryTypes_StructureParticipation as StructureParticipation, factoryTypes_StructureProfile as StructureProfile, factoryTypes_StructureSortConfig as StructureSortConfig, factoryTypes_Substitution as Substitution, factoryTypes_TeamKey as TeamKey, factoryTypes_TournamentRecords as TournamentRecords };
+}
+
 type ModifyVenueArgs = {
     tournamentRecords?: TournamentRecords;
     tournamentRecord?: Tournament;
@@ -3741,9 +3818,7 @@ declare function removeMatchUpCourtAssignment(params: any): {
 };
 
 type RemoveEventMatchUpFormatTimingArgs = {
-    tournamentRecords?: {
-        [key: string]: Tournament;
-    };
+    tournamentRecords?: TournamentRecords;
     tournamentRecord?: Tournament;
     eventId: string;
     event?: Event$1;
@@ -4760,6 +4835,13 @@ declare function getTournamentPenalties({ tournamentRecord, }: GetTournamentPena
     penalties?: Penalty[];
 };
 
+declare function getTournamentInfo({ tournamentRecord }: {
+    tournamentRecord: any;
+}): {
+    tournamentInfo?: any;
+    error?: ErrorType;
+};
+
 declare function getTournamentIds({ tournamentRecords }: {
     tournamentRecords: any;
 }): {
@@ -5557,6 +5639,13 @@ winsLimit, event, }: GetEligibleVoluntaryConsolationParticipantsArgs): {
     error?: ErrorType;
 };
 
+type getDrawTypeCoercionArgs = {
+    policyDefinitions?: PolicyDefinitions;
+    appliedPolicies?: PolicyDefinitions;
+    drawType?: string;
+};
+declare function getDrawTypeCoercion({ policyDefinitions, appliedPolicies, drawType, }: getDrawTypeCoercionArgs): any;
+
 declare function getDrawParticipantRepresentativeIds({ drawDefinition }: {
     drawDefinition: any;
 }): (ResultType & {
@@ -5978,7 +6067,6 @@ declare function categoryCanContain({ childCategory, withDetails, category, }: C
 
 /**
  *
- * @param {object} tournamentRecord - passed in automatically by tournamentEngine
  * @param {object[]} outcomes - array of outcomes to be applied to matchUps, relevent attributes: { eventId: string; drawId: string; }
  *
  */
@@ -6083,16 +6171,6 @@ declare function allCompetitionMatchUps({ scheduleVisibilityFilters, afterRecove
     error?: ErrorType;
 };
 
-declare function publishOrderOfPlay(params: any): {
-    error: {
-        message: string;
-        code: string;
-    };
-} | {
-    success: boolean;
-    error?: undefined;
-};
-
 declare function unPublishOrderOfPlay(params: any): {
     error: {
         message: string;
@@ -6103,49 +6181,6 @@ declare function unPublishOrderOfPlay(params: any): {
     error?: undefined;
 };
 
-type PublishingDetail = {
-    roundLimit?: number;
-    published?: boolean;
-    embargo?: string;
-};
-type DrawPublishingDetails = {
-    structureDetails?: {
-        [key: string]: PublishingDetail;
-    };
-    stageDetails?: {
-        [key: string]: PublishingDetail;
-    };
-    publishingDetail: PublishingDetail;
-    structureIdsToRemove?: string[];
-    structureIdsToAdd?: string[];
-    stagesToRemove?: string[];
-    stagesToAdd?: string[];
-};
-type PublishEventType = {
-    includePositionAssignments?: boolean;
-    policyDefinitions?: PolicyDefinitions;
-    removePriorValues?: boolean;
-    tournamentRecord: Tournament;
-    drawIds?: string[];
-    status?: string;
-    event?: Event$1;
-    drawDetails?: {
-        [key: string]: DrawPublishingDetails;
-    };
-    drawIdsToRemove?: string[];
-    drawIdsToAdd?: string[];
-};
-declare function publishEvent(params: PublishEventType): ResultType | {
-    error: {
-        message: string;
-        code: string;
-    };
-} | {
-    eventData: any;
-    success: boolean;
-    error?: undefined;
-};
-
 declare function unPublishEvent({ removePriorValues, tournamentRecord, status, event, }: {
     removePriorValues?: boolean | undefined;
     tournamentRecord: any;
@@ -6193,6 +6228,16 @@ type SetEventDisplaySettings = {
 };
 declare function setEventDisplay({ removePriorValues, tournamentRecord, displaySettings, status, event, }: SetEventDisplaySettings): ResultType;
 
+declare function publishOrderOfPlay(params: any): {
+    error: {
+        message: string;
+        code: string;
+    };
+} | {
+    success: boolean;
+    error?: undefined;
+};
+
 declare function publishEventSeeding({ removePriorValues, stageSeedingScaleNames, seedingScaleNames, tournamentRecord, status, drawIds, event, }: {
     removePriorValues?: boolean | undefined;
     stageSeedingScaleNames: any;
@@ -6228,11 +6273,68 @@ declare function unPublishEventSeeding({ removePriorValues, seedingScaleNames, t
     error?: undefined;
 };
 
-declare function getDrawData(params: any): {
-    structures?: any[];
+type PublishingDetail = {
+    roundLimit?: number;
+    published?: boolean;
+    embargo?: string;
+};
+type DrawPublishingDetails = {
+    structureDetails?: {
+        [key: string]: PublishingDetail;
+    };
+    stageDetails?: {
+        [key: string]: PublishingDetail;
+    };
+    publishingDetail: PublishingDetail;
+    structureIdsToRemove?: string[];
+    structureIdsToAdd?: string[];
+    stagesToRemove?: string[];
+    stagesToAdd?: string[];
+};
+type PublishEventType = {
+    includePositionAssignments?: boolean;
+    policyDefinitions?: PolicyDefinitions;
+    removePriorValues?: boolean;
+    tournamentRecord: Tournament;
+    drawIds?: string[];
+    status?: string;
+    event?: Event$1;
+    drawDetails?: {
+        [key: string]: DrawPublishingDetails;
+    };
+    drawIdsToRemove?: string[];
+    drawIdsToAdd?: string[];
+};
+declare function publishEvent(params: PublishEventType): ResultType | {
+    error: {
+        message: string;
+        code: string;
+    };
+} | {
+    eventData: any;
+    success: boolean;
+    error?: undefined;
+};
+
+type GetVenueDataArgs = {
+    tournamentRecord: Tournament;
+    venueId: string;
+};
+declare function getVenueData({ tournamentRecord, venueId }: GetVenueDataArgs): {
     success?: boolean;
     error?: ErrorType;
-    drawInfo?: any;
+    venueData?: any;
+};
+
+type GetPublishStateArgs = {
+    tournamentRecord?: Tournament;
+    eventIds?: string[];
+    drawIds?: string[];
+    drawId?: string;
+    event: Event$1;
+};
+declare function getPublishState({ tournamentRecord, eventIds, drawIds, drawId, event, }: GetPublishStateArgs): ResultType & {
+    publishState?: any;
 };
 
 type GetEventDataArgs = {
@@ -6251,6 +6353,24 @@ declare function getEventData(params: GetEventDataArgs): {
     eventData?: any;
 };
 
+declare function getDrawData(params: any): {
+    structures?: any[];
+    success?: boolean;
+    error?: ErrorType;
+    drawInfo?: any;
+};
+
+type GetCourtInfoArgs = {
+    tournamentRecord: Tournament;
+    internalUse?: boolean;
+    courtId: string;
+};
+declare function getCourtInfo({ tournamentRecord, internalUse, courtId, }: GetCourtInfoArgs): {
+    error?: ErrorType;
+    success?: boolean;
+    courtInfo?: any;
+};
+
 declare function getAllEventData({ tournamentRecord, policyDefinitions }: {
     tournamentRecord: any;
     policyDefinitions: any;
@@ -6269,34 +6389,6 @@ declare function getAllEventData({ tournamentRecord, policyDefinitions }: {
     error?: undefined;
 };
 
-type GetCourtInfoArgs = {
-    tournamentRecord: Tournament;
-    internalUse?: boolean;
-    courtId: string;
-};
-declare function getCourtInfo({ tournamentRecord, internalUse, courtId, }: GetCourtInfoArgs): {
-    error?: ErrorType;
-    success?: boolean;
-    courtInfo?: any;
-};
-
-type GetVenueDataArgs = {
-    tournamentRecord: Tournament;
-    venueId: string;
-};
-declare function getVenueData({ tournamentRecord, venueId }: GetVenueDataArgs): {
-    success?: boolean;
-    error?: ErrorType;
-    venueData?: any;
-};
-
-declare function getTournamentInfo({ tournamentRecord }: {
-    tournamentRecord: any;
-}): {
-    tournamentInfo?: any;
-    error?: ErrorType;
-};
-
 type RemovePolicyArgs = {
     tournamentRecords?: TournamentRecords;
     tournamentRecord?: Tournament;
@@ -7074,6 +7166,7 @@ type GenerateDrawMaticRoundArgs = {
     restrictEntryStatus?: boolean;
     drawDefinition: DrawDefinition;
     generateMatchUps?: boolean;
+    eventType?: EventTypeUnion;
     salted?: number | boolean;
     participantIds?: string[];
     encounterValue?: number;
@@ -7082,9 +7175,10 @@ type GenerateDrawMaticRoundArgs = {
     matchUpIds?: string[];
     structure?: Structure;
     structureId?: string;
-    eventType?: EventTypeUnion;
     scaleName?: string;
+    isMock?: boolean;
     drawId?: string;
+    event: Event$1;
 };
 type DrawMaticRoundResult = {
     participantIdPairings?: string[][];
@@ -7095,10 +7189,9 @@ type DrawMaticRoundResult = {
     maxDelta?: number;
     maxDiff?: number;
 };
-declare function generateDrawMaticRound({ encounterValue, sameTeamValue, maxIterations, generateMatchUps, tournamentParticipants, participantIds, drawDefinition, adHocRatings, structureId, salted, matchUpIds, eventType, structure, scaleName, }: GenerateDrawMaticRoundArgs): ResultType & DrawMaticRoundResult;
+declare function generateDrawMaticRound({ encounterValue, sameTeamValue, maxIterations, generateMatchUps, tournamentParticipants, participantIds, drawDefinition, adHocRatings, structureId, salted, matchUpIds, eventType, structure, scaleName, isMock, event, }: GenerateDrawMaticRoundArgs): ResultType & DrawMaticRoundResult;
 
 type DrawMaticArgs = {
-    tournamentParticipants?: HydratedParticipant[];
     adHocRatings?: {
         [key: string]: number;
     };
@@ -7106,6 +7199,7 @@ type DrawMaticArgs = {
     drawDefinition?: DrawDefinition;
     tournamentRecord: Tournament;
     generateMatchUps?: boolean;
+    eventType?: EventTypeUnion;
     salted?: number | boolean;
     participantIds?: string[];
     encounterValue?: number;
@@ -7114,11 +7208,13 @@ type DrawMaticArgs = {
     structure?: Structure;
     matchUpIds?: string[];
     structureId?: string;
-    eventType?: EventTypeUnion;
-    event?: Event$1;
+    isMock?: boolean;
+    event: Event$1;
     scaleAccessor?: string;
     scaleName?: string;
 };
+declare function drawMatic({ restrictEntryStatus, adHocRatings, generateMatchUps, tournamentRecord, participantIds, encounterValue, sameTeamValue, drawDefinition, scaleAccessor, maxIterations, structureId, matchUpIds, scaleName, // custom rating name to seed dynamic ratings
+eventType, isMock, salted, event, }: DrawMaticArgs): ResultType & DrawMaticRoundResult;
 
 type GenerateDrawDefinitionArgs = {
     automated?: boolean | {
@@ -7218,8 +7314,10 @@ type GenerateAdHocMatchUpsArgs = {
     roundNumber?: number;
     structureId?: string;
     newRound?: boolean;
+    isMock?: boolean;
+    event: Event$1;
 };
-declare function generateAdHocMatchUps({ participantIdPairings, matchUpIds, drawDefinition, matchUpsCount, roundNumber, structureId, newRound, }: GenerateAdHocMatchUpsArgs): {
+declare function generateAdHocMatchUps({ participantIdPairings, matchUpIds, drawDefinition, matchUpsCount, roundNumber, structureId, newRound, isMock, event, }: GenerateAdHocMatchUpsArgs): {
     matchUpsCount?: number;
     matchUps?: MatchUp[];
     error?: ErrorType;
@@ -8264,8 +8362,6 @@ declare function enableTieAutoCalc({ tournamentRecord, drawDefinition, matchUpId
     event: any;
 }): any;
 
-declare function drawMatic(params: any): any;
-
 declare function disableTieAutoCalc({ drawDefinition, matchUpId, event }: {
     drawDefinition: any;
     matchUpId: any;
@@ -9071,19 +9167,19 @@ declare const governors: {
         removePolicy: typeof removePolicy;
     };
     publishingGovernor: {
-        getTournamentInfo: typeof getTournamentInfo;
-        getVenueData: typeof getVenueData;
-        getCourtInfo: typeof getCourtInfo;
         getAllEventData: typeof getAllEventData;
-        getEventData: typeof getEventData;
+        getCourtInfo: typeof getCourtInfo;
         getDrawData: typeof getDrawData;
-        unPublishEventSeeding: typeof unPublishEventSeeding;
+        getEventData: typeof getEventData;
+        getPublishState: typeof getPublishState;
+        getVenueData: typeof getVenueData;
+        publishEvent: typeof publishEvent;
         publishEventSeeding: typeof publishEventSeeding;
+        publishOrderOfPlay: typeof publishOrderOfPlay;
         setEventDisplay: typeof setEventDisplay;
         unPublishEvent: typeof unPublishEvent;
-        publishEvent: typeof publishEvent;
+        unPublishEventSeeding: typeof unPublishEventSeeding;
         unPublishOrderOfPlay: typeof unPublishOrderOfPlay;
-        publishOrderOfPlay: typeof publishOrderOfPlay;
     };
     queryGovernor: {
         allCompetitionMatchUps: typeof allCompetitionMatchUps;
@@ -9131,6 +9227,7 @@ declare const governors: {
         getCourts: typeof getCourts;
         getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
         getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
+        getDrawTypeCoercion: typeof getDrawTypeCoercion;
         getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
         getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
         getEvent: typeof getEvent;
@@ -9176,6 +9273,7 @@ declare const governors: {
         getTeamLineUp: typeof getTeamLineUp;
         getTieFormat: typeof getTieFormat;
         getTournamentIds: typeof getTournamentIds;
+        getTournamentInfo: typeof getTournamentInfo;
         getTournamentPenalties: typeof getTournamentPenalties;
         getTournamentPersons: typeof getTournamentPersons;
         getTournamentStructures: typeof getTournamentStructures;
@@ -9569,6 +9667,154 @@ declare const scoreGovernor: {
     };
 };
 
+type Notice = {
+    topic: string;
+    payload: any;
+    key?: string;
+};
+type DevContextType = {
+    errors?: boolean | string[];
+    params?: boolean | string[];
+    result?: boolean | string[];
+    exclude?: string[];
+    [key: string]: any;
+} | boolean;
+type ImplemtationGlobalStateTypes = {
+    tournamentRecords: TournamentRecords;
+    tournamentId?: string | undefined;
+    methods: {
+        [key: string]: any;
+    };
+    disableNotifications: boolean;
+    subscriptions: any;
+    notices: Notice[];
+    modified: boolean;
+};
+declare function setStateProvider(globalStateProvider?: {
+    [key: string]: any;
+}): {
+    success: boolean;
+};
+declare function createInstanceState(): {
+    error: unknown;
+    success?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+};
+/**
+ * if contextCriteria, check whether all contextCriteria keys values are equivalent with globalState.devContext object
+ */
+declare function getDevContext(contextCriteria?: {
+    [key: string]: any;
+}): DevContextType;
+declare function timeKeeper(action?: string, timer?: string): any;
+declare function setGlobalLog(loggingFx?: any): void;
+declare function setDevContext(value?: DevContextType): void;
+declare function disableNotifications(): void;
+declare function enableNotifications(): void;
+type DeepCopyAttributes = {
+    threshold?: number;
+    stringify?: string[];
+    ignore?: string[];
+    toJSON?: string[];
+};
+declare function setDeepCopy(value: boolean, attributes: DeepCopyAttributes): void;
+declare function deepCopyEnabled(): {
+    threshold?: number | undefined;
+    modulate?: any;
+    stringify: string[];
+    ignore: any;
+    toJSON: string[];
+    enabled: boolean;
+};
+declare function setSubscriptions(params: any): any;
+declare function setMethods(params?: {
+    [key: string]: any;
+}): any;
+declare function cycleMutationStatus(): any;
+declare function addNotice(notice: Notice): any;
+type GetNoticesArgs = {
+    topic: string;
+};
+declare function getMethods(): {
+    [key: string]: any;
+};
+declare function getNotices(params: GetNoticesArgs): string[];
+type DeleteNoticeArgs = {
+    topic?: string;
+    key: string;
+};
+declare function deleteNotice({ key, topic }: DeleteNoticeArgs): any;
+declare function deleteNotices(): any;
+declare function getTopics(): any;
+type CallListenerArgs = {
+    notices: Notice[];
+    topic: string;
+};
+declare function callListener(payload: any): Promise<any>;
+declare function getTournamentId(): any;
+declare function getTournamentRecord(tournamentId: string): any;
+declare function getTournamentRecords(): any;
+declare function setTournamentRecord(tournamentRecord: ResultType): any;
+declare function setTournamentRecords(tournamentRecords: any): any;
+declare function setTournamentId(tournamentId?: string): {
+    success?: boolean;
+    error?: ErrorType;
+};
+declare function removeTournamentRecord(tournamentId: string): any;
+declare function getProvider(): any;
+type HandleCaughtErrorArgs = {
+    engineName?: string;
+    methodName: string;
+    params: any;
+    err: any;
+};
+declare function handleCaughtError({ engineName, methodName, params, err, }: HandleCaughtErrorArgs): any;
+declare function globalLog(engine: string, log: any): void;
+
+type globalState_CallListenerArgs = CallListenerArgs;
+type globalState_DeepCopyAttributes = DeepCopyAttributes;
+type globalState_DeleteNoticeArgs = DeleteNoticeArgs;
+type globalState_DevContextType = DevContextType;
+type globalState_GetNoticesArgs = GetNoticesArgs;
+type globalState_HandleCaughtErrorArgs = HandleCaughtErrorArgs;
+type globalState_ImplemtationGlobalStateTypes = ImplemtationGlobalStateTypes;
+type globalState_Notice = Notice;
+declare const globalState_addNotice: typeof addNotice;
+declare const globalState_callListener: typeof callListener;
+declare const globalState_createInstanceState: typeof createInstanceState;
+declare const globalState_cycleMutationStatus: typeof cycleMutationStatus;
+declare const globalState_deepCopyEnabled: typeof deepCopyEnabled;
+declare const globalState_deleteNotice: typeof deleteNotice;
+declare const globalState_deleteNotices: typeof deleteNotices;
+declare const globalState_disableNotifications: typeof disableNotifications;
+declare const globalState_enableNotifications: typeof enableNotifications;
+declare const globalState_getDevContext: typeof getDevContext;
+declare const globalState_getMethods: typeof getMethods;
+declare const globalState_getNotices: typeof getNotices;
+declare const globalState_getProvider: typeof getProvider;
+declare const globalState_getTopics: typeof getTopics;
+declare const globalState_getTournamentId: typeof getTournamentId;
+declare const globalState_getTournamentRecord: typeof getTournamentRecord;
+declare const globalState_getTournamentRecords: typeof getTournamentRecords;
+declare const globalState_globalLog: typeof globalLog;
+declare const globalState_handleCaughtError: typeof handleCaughtError;
+declare const globalState_removeTournamentRecord: typeof removeTournamentRecord;
+declare const globalState_setDeepCopy: typeof setDeepCopy;
+declare const globalState_setDevContext: typeof setDevContext;
+declare const globalState_setGlobalLog: typeof setGlobalLog;
+declare const globalState_setMethods: typeof setMethods;
+declare const globalState_setStateProvider: typeof setStateProvider;
+declare const globalState_setSubscriptions: typeof setSubscriptions;
+declare const globalState_setTournamentId: typeof setTournamentId;
+declare const globalState_setTournamentRecord: typeof setTournamentRecord;
+declare const globalState_setTournamentRecords: typeof setTournamentRecords;
+declare const globalState_timeKeeper: typeof timeKeeper;
+declare namespace globalState {
+  export { type globalState_CallListenerArgs as CallListenerArgs, type globalState_DeepCopyAttributes as DeepCopyAttributes, type globalState_DeleteNoticeArgs as DeleteNoticeArgs, type globalState_DevContextType as DevContextType, type globalState_GetNoticesArgs as GetNoticesArgs, type globalState_HandleCaughtErrorArgs as HandleCaughtErrorArgs, type globalState_ImplemtationGlobalStateTypes as ImplemtationGlobalStateTypes, type globalState_Notice as Notice, globalState_addNotice as addNotice, globalState_callListener as callListener, globalState_createInstanceState as createInstanceState, globalState_cycleMutationStatus as cycleMutationStatus, globalState_deepCopyEnabled as deepCopyEnabled, globalState_deleteNotice as deleteNotice, globalState_deleteNotices as deleteNotices, globalState_disableNotifications as disableNotifications, globalState_enableNotifications as enableNotifications, globalState_getDevContext as getDevContext, globalState_getMethods as getMethods, globalState_getNotices as getNotices, globalState_getProvider as getProvider, globalState_getTopics as getTopics, globalState_getTournamentId as getTournamentId, globalState_getTournamentRecord as getTournamentRecord, globalState_getTournamentRecords as getTournamentRecords, globalState_globalLog as globalLog, globalState_handleCaughtError as handleCaughtError, globalState_removeTournamentRecord as removeTournamentRecord, globalState_setDeepCopy as setDeepCopy, globalState_setDevContext as setDevContext, globalState_setGlobalLog as setGlobalLog, globalState_setMethods as setMethods, globalState_setStateProvider as setStateProvider, globalState_setSubscriptions as setSubscriptions, globalState_setTournamentId as setTournamentId, globalState_setTournamentRecord as setTournamentRecord, globalState_setTournamentRecords as setTournamentRecords, globalState_timeKeeper as timeKeeper };
+}
+
 declare const forge: {};
 
 declare function asyncEngine(test?: boolean): FactoryEngine & {
@@ -11498,27 +11744,6 @@ declare const factoryConstants: {
     };
 };
 
-declare const participantRoles: {
-    ADMINISTRATION: any;
-    CAPTAIN: any;
-    COACH: any;
-    COMPETITOR: any;
-    MEDIA: any;
-    MEDICAL: any;
-    OFFICIAL: any;
-    OTHER: any;
-    SECURITY: any;
-};
-
-declare const matchUpTypes: {
-    SINGLES_MATCHUP: string;
-    SINGLES: string;
-    DOUBLES_MATCHUP: string;
-    DOUBLES: string;
-    TEAM_MATCHUP: string;
-    TEAM: string;
-};
-
 declare const drawDefinitionConstants: {
     MAIN: string;
     QUALIFYING: string;
@@ -11699,6 +11924,27 @@ declare const matchUpStatusConstants: {
     WALKOVER: any;
 };
 
+declare const matchUpTypes: {
+    SINGLES_MATCHUP: string;
+    SINGLES: string;
+    DOUBLES_MATCHUP: string;
+    DOUBLES: string;
+    TEAM_MATCHUP: string;
+    TEAM: string;
+};
+
+declare const participantRoles: {
+    ADMINISTRATION: any;
+    CAPTAIN: any;
+    COACH: any;
+    COMPETITOR: any;
+    MEDIA: any;
+    MEDICAL: any;
+    OFFICIAL: any;
+    OTHER: any;
+    SECURITY: any;
+};
+
 declare const penaltyConstants: {
     COACHING: string;
     BALL_ABUSE: string;
@@ -11803,32 +12049,4 @@ declare const venueConstants: {
     OUTDOOR: string;
 };
 
-type DevContextType = {
-    errors?: boolean | string[];
-    params?: boolean | string[];
-    result?: boolean | string[];
-    exclude?: string[];
-    [key: string]: any;
-} | boolean;
-declare function setStateProvider(globalStateProvider?: {
-    [key: string]: any;
-}): {
-    success: boolean;
-};
-declare function setGlobalLog(loggingFx?: any): void;
-declare function setDevContext(value?: DevContextType): void;
-type DeepCopyAttributes = {
-    threshold?: number;
-    stringify?: string[];
-    ignore?: string[];
-    toJSON?: string[];
-};
-declare function setDeepCopy(value: boolean, attributes: DeepCopyAttributes): void;
-declare function setSubscriptions(params: any): any;
-type GetNoticesArgs = {
-    topic: string;
-};
-declare function getNotices(params: GetNoticesArgs): string[];
-declare function deleteNotices(): any;
-
-export { askEngine, asyncEngine, competitionEngine, deleteNotices, drawDefinitionConstants, entryStatusConstants, errorConditionConstants, eventConstants, factoryConstants, fixtures, flightConstants, forge, genderConstants, getNotices, governors, keyValueConstants, matchUpActionConstants, matchUpEngine, matchUpFormatCode, matchUpStatusConstants, matchUpTypes, mocksEngine, participantConstants, participantRoles, participantTypes, penaltyConstants, policyConstants, positionActionConstants, resultConstants, scaleConstants, scaleEngine, scoreGovernor, setDeepCopy, setDevContext, setGlobalLog, setStateProvider, setSubscriptions, surfaceConstants, engine as syncEngine, timeItemConstants, tournamentEngine, utilities, venueConstants, factoryVersion as version };
+export { askEngine, asyncEngine, competitionEngine, drawDefinitionConstants, entryStatusConstants, errorConditionConstants, eventConstants, factoryConstants, factoryTypes, fixtures, flightConstants, forge, genderConstants, globalState, governors, keyValueConstants, matchUpActionConstants, matchUpEngine, matchUpFormatCode, matchUpStatusConstants, matchUpTypes, mocksEngine, participantConstants, participantRoles, participantTypes, penaltyConstants, policyConstants, positionActionConstants, resultConstants, scaleConstants, scaleEngine, scoreGovernor, surfaceConstants, engine as syncEngine, timeItemConstants, tournamentEngine, utilities, venueConstants, factoryVersion as version };