client_plugin_logic_deb 1.8.410 → 1.8.413

package/Kotlin-DateTime-library-kotlinx-datetime.js

@@ -380,7 +380,7 @@
   function addFormatStructureForTime(structure) {
     this.s60(structure);
   }
-  initMetadataForInterface(AbstractWithDateTimeBuilder, 'AbstractWithDateTimeBuilder', VOID, VOID, [AbstractWithDateBuilder, AbstractWithTimeBuilder, WithTime, WithDate]);
+  initMetadataForInterface(AbstractWithDateTimeBuilder, 'AbstractWithDateTimeBuilder', VOID, VOID, [AbstractWithDateBuilder, AbstractWithTimeBuilder, WithDate, WithTime]);
   initMetadataForClass(Builder_0, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithDateTimeBuilder]);
   initMetadataForClass(LocalDateTimeFormat, 'LocalDateTimeFormat', VOID, AbstractDateTimeFormat);
   function set_fractionOfSecond(value) {

package/Logic_Debertz-client_plugin.d.ts

@@ -568,6 +568,23 @@ export declare namespace com.logic.data.models.player {
         }
     }
 }
+export declare namespace com.logic.data.models.player {
+    class Team {
+        constructor(playerIds: kotlin.collections.KtList<string>);
+        get playerIds(): kotlin.collections.KtList<string>;
+        containsPlayer(playerId: string): boolean;
+        get first(): string;
+        get second(): string;
+        copy(playerIds?: kotlin.collections.KtList<string>): com.logic.data.models.player.Team;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Team.$metadata$ {
+        const constructor: abstract new () => Team;
+    }
+}
 export declare namespace com.logic.redux.actions {
     interface BufferedAction extends com.logic.redux.store.definitions.Action {
         readonly __doNotUseOrImplementIt: {
@@ -1312,6 +1329,17 @@ export declare namespace games.jass.logic.data.models.player.points {
         const constructor: abstract new () => PointsDistributeMode;
     }
 }
+export declare namespace games.jass.logic.data.models.player.state {
+    class PlayerLeftResult {
+        constructor(playerAchievements: Nullable<games.jass.logic.data.models.player.achievements.PlayerAchievements>, playerGameAnalytics: Nullable<games.jass.logic.data.models.player.analytics.PlayerAnalytics>);
+        get playerAchievements(): Nullable<games.jass.logic.data.models.player.achievements.PlayerAchievements>;
+        get playerGameAnalytics(): Nullable<games.jass.logic.data.models.player.analytics.PlayerAnalytics>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerLeftResult.$metadata$ {
+        const constructor: abstract new () => PlayerLeftResult;
+    }
+}
 export declare namespace games.jass.logic.data.models.player.state {
     abstract class RoundContractState {
         private constructor();
@@ -2709,6 +2737,24 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
             readonly "games.jass.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
+    class TeamsDataMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements com.logic.redux.store.definitions.Action, com.logic.redux.actions.BufferedAction, games.jass.logic.redux.actions.mechanic.PlayerOrderChangeMechanicAction/*, games.jass.logic.redux.actions.mechanic.InSceneAction, games.jass.logic.redux.actions.mechanic.PlayerTurnAnswerAction, com.logic.redux.actions.InterceptableAction */ {
+        constructor(team1: com.logic.data.models.player.Team, team2: com.logic.data.models.player.Team, aid?: Nullable<string>);
+        get team1(): com.logic.data.models.player.Team;
+        get team2(): com.logic.data.models.player.Team;
+        get aid(): Nullable<string>;
+        get usersOrder(): kotlin.collections.KtList<string>;
+        getSelectedPlayerId(gameCreatorPlayerId: string): string;
+        copy(team1?: com.logic.data.models.player.Team, team2?: com.logic.data.models.player.Team, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.TeamsDataMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.PlayerOrderChangeMechanicAction["__doNotUseOrImplementIt"];
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TeamsDataMechanicAction.$metadata$ {
+        const constructor: abstract new () => TeamsDataMechanicAction;
+    }
     class PlayerConnectionChangedMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements com.logic.redux.actions.validation.NotValidateIfGameFinished {
         constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>);
         get playerId(): string;
@@ -2791,6 +2837,7 @@ export declare interface RatingHelper {
     isValidRatingForLeague(league: games.jass.logic.data.models.leagues.League, rating: number): boolean;
     mapRatingToLeague(rating: number): games.jass.logic.data.models.leagues.League;
     getLeaguesConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
+    getLeaguesConfigJson(): string;
     readonly __doNotUseOrImplementIt: {
         readonly RatingHelper: unique symbol;
     };
@@ -3135,7 +3182,7 @@ export declare namespace games.jass.logic.server.domain {
         roomOnDelete(newRid?: Nullable<string>): void;
         playerLostConnection(playerId: string): void;
         playerLive(playerId: string): void;
-        playerLeft(playerId: string, permanently?: boolean): void;
+        playerLeft(playerId: string, permanently?: boolean): games.jass.logic.data.models.player.state.PlayerLeftResult;
         fromClientEvent(action: games.jass.logic.redux.actions.client.from.FromClientAction): void;
         subscribeToClientAction(subscriber: (p0: games.jass.logic.redux.actions.client.to.ToClientAction) => void): void;
         subscribeServerStateUpdate(subscriber: (p0: games.jass.logic.server.data.models.state.ServerStateUpdate) => void): void;