game_client_logic_deb 1.4.49 → 1.4.51

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/Logic_Debertz-core.js +1 -1
  2. package/Logic_Debertz-engine.js +15 -8
  3. package/Logic_Debertz-engine.js.map +1 -1
  4. package/Logic_Debertz-game_client.d.ts +753 -0
  5. package/package.json +2 -1
package/Logic_Debertz-game_client.d.ts ADDED
@@ -0,0 +1,753 @@
1
+ type Nullable<T> = T | null | undefined
2
+ export declare namespace com.logic {
3
+ const GameEngineConfig: {
4
+ get version(): string;
5
+ };
6
+ }
7
+ export declare namespace com.logic.data.models {
8
+ abstract class TerminationGameReason {
9
+ protected constructor();
10
+ static TerminationGameReason_init_$Create$(seen1: number, serializationConstructorMarker: Nullable<any>/* Nullable<kotlinx.serialization.internal.SerializationConstructorMarker> */): com.logic.data.models.TerminationGameReason;
11
+ static get Companion(): {
12
+ serializer(): any/* kotlinx.serialization.KSerializer<com.logic.data.models.TerminationGameReason> */;
13
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
14
+ }
15
+ }
16
+ export declare namespace com.logic.data.models.player {
17
+ class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
18
+ constructor(playerId: string, name: string, avatarUrl: string, isBot?: boolean, payload?: Nullable<any>);
19
+ get playerId(): string;
20
+ get name(): string;
21
+ get avatarUrl(): string;
22
+ get isBot(): boolean;
23
+ get payload(): Nullable<any>;
24
+ copy(playerId?: string, name?: string, avatarUrl?: string, isBot?: boolean, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
25
+ toString(): string;
26
+ hashCode(): number;
27
+ equals(other: Nullable<any>): boolean;
28
+ readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
29
+ }
30
+ }
31
+ export declare namespace com.logic.data.models.player {
32
+ interface PlayerIdContract {
33
+ readonly playerId: string;
34
+ readonly __doNotUseOrImplementIt: {
35
+ readonly "com.logic.data.models.player.PlayerIdContract": unique symbol;
36
+ };
37
+ }
38
+ function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, id: string): T;
39
+ function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, playerId: string): number;
40
+ }
41
+ export declare namespace com.logic.data.models.player {
42
+ abstract class PlayerConnectionState {
43
+ private constructor();
44
+ static get LIVE(): com.logic.data.models.player.PlayerConnectionState & {
45
+ get name(): "LIVE";
46
+ get ordinal(): 0;
47
+ };
48
+ static get TIMEOUT(): com.logic.data.models.player.PlayerConnectionState & {
49
+ get name(): "TIMEOUT";
50
+ get ordinal(): 1;
51
+ };
52
+ static get LOST_CONNECTION(): com.logic.data.models.player.PlayerConnectionState & {
53
+ get name(): "LOST_CONNECTION";
54
+ get ordinal(): 2;
55
+ };
56
+ static get LEFT(): com.logic.data.models.player.PlayerConnectionState & {
57
+ get name(): "LEFT";
58
+ get ordinal(): 3;
59
+ };
60
+ static get DISCONNECTING(): com.logic.data.models.player.PlayerConnectionState & {
61
+ get name(): "DISCONNECTING";
62
+ get ordinal(): 4;
63
+ };
64
+ static get DELETED(): com.logic.data.models.player.PlayerConnectionState & {
65
+ get name(): "DELETED";
66
+ get ordinal(): 5;
67
+ };
68
+ get isLive(): boolean;
69
+ get isTimeOut(): boolean;
70
+ get isLostConnection(): boolean;
71
+ get isLeft(): boolean;
72
+ get isDeleted(): boolean;
73
+ get isDisconnecting(): boolean;
74
+ get isNotAlive(): boolean;
75
+ get isDisconnected(): boolean;
76
+ static values(): Array<com.logic.data.models.player.PlayerConnectionState>;
77
+ static valueOf(value: string): com.logic.data.models.player.PlayerConnectionState;
78
+ get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
79
+ get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
80
+ static get Companion(): {
81
+ serializer(): any/* kotlinx.serialization.KSerializer<com.logic.data.models.player.PlayerConnectionState> */;
82
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
83
+ }
84
+ }
85
+ export declare namespace com.logic.data.models.rules {
86
+ class Rules {
87
+ constructor(needToPutHigherTrump: boolean, distributePoints: boolean, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, enableFineIfNoBribes: boolean, fineIfNoBribes: number, enableFineAfterThirdByte: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, tenCardsInHand: boolean);
88
+ get needToPutHigherTrump(): boolean;
89
+ get distributePoints(): boolean;
90
+ get protectBella(): boolean;
91
+ get oneTryToProtectBella(): boolean;
92
+ get enableFourSevensCombination(): boolean;
93
+ get enableTrumpSevenCombination(): boolean;
94
+ get enableTrumpSevenCombinationAfterDistribution(): boolean;
95
+ get playerWhoChooseSuitGoFirst(): boolean;
96
+ get winnerShuffleCards(): boolean;
97
+ get playWithoutLiabilities(): boolean;
98
+ get trumpCardGoToPlayerWhoShuffleCards(): boolean;
99
+ get enableFineIfNoBribes(): boolean;
100
+ get fineIfNoBribes(): number;
101
+ get enableFineAfterThirdByte(): boolean;
102
+ get checkTrumpCombination(): boolean;
103
+ get checkOnlyTrumpDebertz(): boolean;
104
+ get tenCardsInHand(): boolean;
105
+ copy(needToPutHigherTrump?: boolean, distributePoints?: boolean, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, playerWhoChooseSuitGoFirst?: boolean, winnerShuffleCards?: boolean, playWithoutLiabilities?: boolean, trumpCardGoToPlayerWhoShuffleCards?: boolean, enableFineIfNoBribes?: boolean, fineIfNoBribes?: number, enableFineAfterThirdByte?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: boolean, tenCardsInHand?: boolean): com.logic.data.models.rules.Rules;
106
+ toString(): string;
107
+ hashCode(): number;
108
+ equals(other: Nullable<any>): boolean;
109
+ static get Companion(): {
110
+ kharkiv(): com.logic.data.models.rules.Rules;
111
+ klabor(): com.logic.data.models.rules.Rules;
112
+ debertzCommon(): com.logic.data.models.rules.Rules;
113
+ belot(): com.logic.data.models.rules.Rules;
114
+ custom(): com.logic.data.models.rules.Rules;
115
+ };
116
+ }
117
+ }
118
+ export declare namespace com.logic.data.models.rules {
119
+ abstract class RulesSetType {
120
+ private constructor();
121
+ static get belot(): com.logic.data.models.rules.RulesSetType & {
122
+ get name(): "belot";
123
+ get ordinal(): 0;
124
+ };
125
+ static get klabor(): com.logic.data.models.rules.RulesSetType & {
126
+ get name(): "klabor";
127
+ get ordinal(): 1;
128
+ };
129
+ static get debertzCommon(): com.logic.data.models.rules.RulesSetType & {
130
+ get name(): "debertzCommon";
131
+ get ordinal(): 2;
132
+ };
133
+ static get debertzKharkiv(): com.logic.data.models.rules.RulesSetType & {
134
+ get name(): "debertzKharkiv";
135
+ get ordinal(): 3;
136
+ };
137
+ static get custom(): com.logic.data.models.rules.RulesSetType & {
138
+ get name(): "custom";
139
+ get ordinal(): 4;
140
+ };
141
+ static values(): Array<com.logic.data.models.rules.RulesSetType>;
142
+ static valueOf(value: string): com.logic.data.models.rules.RulesSetType;
143
+ get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "custom";
144
+ get ordinal(): 0 | 1 | 2 | 3 | 4;
145
+ }
146
+ }
147
+ export declare namespace com.logic.domain.engine.definitions {
148
+ interface Action {
149
+ readonly actionTag: string;
150
+ readonly __doNotUseOrImplementIt: {
151
+ readonly "com.logic.domain.engine.definitions.Action": unique symbol;
152
+ };
153
+ }
154
+ }
155
+ export declare namespace com.logic.domain.engine.definitions {
156
+ interface Store<State> {
157
+ readonly state: State;
158
+ dispatch: (p0: com.logic.domain.engine.definitions.Action) => void;
159
+ readonly observe: any/* kotlinx.coroutines.flow.Flow<State> */;
160
+ readonly replaceReducer: (p0: any/* com.logic.domain.engine.definitions.Reducer<State> */) => void;
161
+ readonly __doNotUseOrImplementIt: {
162
+ readonly "com.logic.domain.engine.definitions.Store": unique symbol;
163
+ };
164
+ }
165
+ }
166
+ export declare namespace com.logic.redux.actions {
167
+ interface BufferedAction extends com.logic.domain.engine.definitions.Action {
168
+ readonly actionTag: string;
169
+ readonly __doNotUseOrImplementIt: {
170
+ readonly "com.logic.redux.actions.BufferedAction": unique symbol;
171
+ } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
172
+ }
173
+ interface ReleaseBufferTriggerAction extends com.logic.domain.engine.definitions.Action {
174
+ readonly actionTag: string;
175
+ readonly __doNotUseOrImplementIt: {
176
+ readonly "com.logic.redux.actions.ReleaseBufferTriggerAction": unique symbol;
177
+ } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
178
+ }
179
+ }
180
+ export declare namespace com.logic.redux.actions.validation {
181
+ interface NotValidateIfGameFinished {
182
+ notValidateWhenFinished(): boolean;
183
+ readonly __doNotUseOrImplementIt: {
184
+ readonly "com.logic.redux.actions.validation.NotValidateIfGameFinished": unique symbol;
185
+ };
186
+ }
187
+ }
188
+ export declare namespace com.logic.redux.actions.validation {
189
+ interface NotValidateIfGameFinishing {
190
+ notValidateWhenFinishing(): boolean;
191
+ readonly __doNotUseOrImplementIt: {
192
+ readonly "com.logic.redux.actions.validation.NotValidateIfGameFinishing": unique symbol;
193
+ };
194
+ }
195
+ }
196
+ export declare namespace com.logic.utils.logger.game {
197
+ interface LoggerPayload {
198
+ readonly __doNotUseOrImplementIt: {
199
+ readonly "com.logic.utils.logger.game.LoggerPayload": unique symbol;
200
+ };
201
+ }
202
+ }
203
+ export declare namespace com.debertz.logic {
204
+ interface GameStoreContract {
205
+ readonly id: string;
206
+ readonly table: com.debertz.logic.data.models.table.DebertzTable;
207
+ readonly isTableExists: boolean;
208
+ readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
209
+ readonly __doNotUseOrImplementIt: {
210
+ readonly "com.debertz.logic.GameStoreContract": unique symbol;
211
+ };
212
+ }
213
+ }
214
+ export declare namespace com.debertz.logic.data.models {
215
+ class BotReduxConfig {
216
+ constructor(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean);
217
+ get botExitsWhenNGameNumberIsFinished(): Nullable<number>;
218
+ get autoStepLastCard(): boolean;
219
+ get simulateBotThinkingDelay(): boolean;
220
+ get isDelayForBot(): boolean;
221
+ copy(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean): com.debertz.logic.data.models.BotReduxConfig;
222
+ toString(): string;
223
+ hashCode(): number;
224
+ equals(other: Nullable<any>): boolean;
225
+ }
226
+ }
227
+ export declare namespace com.debertz.logic.data.models {
228
+ abstract class GameLifecycleState {
229
+ private constructor();
230
+ static get CREATED(): com.debertz.logic.data.models.GameLifecycleState & {
231
+ get name(): "CREATED";
232
+ get ordinal(): 0;
233
+ };
234
+ static get CREATING(): com.debertz.logic.data.models.GameLifecycleState & {
235
+ get name(): "CREATING";
236
+ get ordinal(): 1;
237
+ };
238
+ static get FINISHING(): com.debertz.logic.data.models.GameLifecycleState & {
239
+ get name(): "FINISHING";
240
+ get ordinal(): 2;
241
+ };
242
+ static get FINISHED(): com.debertz.logic.data.models.GameLifecycleState & {
243
+ get name(): "FINISHED";
244
+ get ordinal(): 3;
245
+ };
246
+ static values(): Array<com.debertz.logic.data.models.GameLifecycleState>;
247
+ static valueOf(value: string): com.debertz.logic.data.models.GameLifecycleState;
248
+ get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
249
+ get ordinal(): 0 | 1 | 2 | 3;
250
+ static get Companion(): {
251
+ serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.GameLifecycleState> */;
252
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
253
+ }
254
+ }
255
+ export declare namespace com.debertz.logic.data.models.scenes {
256
+ interface ActData {
257
+ readonly actId: string;
258
+ readonly __doNotUseOrImplementIt: {
259
+ readonly "com.debertz.logic.data.models.scenes.ActData": unique symbol;
260
+ };
261
+ }
262
+ }
263
+ export declare namespace com.debertz.logic.data.models.scenes {
264
+ interface SceneData {
265
+ readonly sceneId: string;
266
+ readonly __doNotUseOrImplementIt: {
267
+ readonly "com.debertz.logic.data.models.scenes.SceneData": unique symbol;
268
+ };
269
+ }
270
+ }
271
+ export declare namespace com.debertz.logic.data.models.table {
272
+ class DebertzTable {
273
+ constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* com.debertz.logic.data.models.table.GameInfo */);
274
+ get id(): string;
275
+ get version(): string;
276
+ get createdAt(): any/* kotlinx.datetime.Instant */;
277
+ get config(): com.debertz.logic.data.models.table.config.Config;
278
+ get players(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */;
279
+ get sceneInfo(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
280
+ get cardsOnTable(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */;
281
+ get bribes(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
282
+ get cardDeck(): Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
283
+ get gameInfo(): any/* com.debertz.logic.data.models.table.GameInfo */;
284
+ get playersConnections(): any/* kotlin.collections.List<kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState>> */;
285
+ get users(): Array<com.logic.data.models.player.GameUserInfo>;
286
+ get isCardDeckExist(): boolean;
287
+ get requireCardDeck(): any/* com.debertz.logic.data.models.table.cards.CardDeck */;
288
+ get currentTrump(): Nullable<any>/* Nullable<com.logic.data.models.table.cards.Suit> */;
289
+ copy(id?: string, version?: string, createdAt?: any/* kotlinx.datetime.Instant */, config?: com.debertz.logic.data.models.table.config.Config, players?: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck?: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* com.debertz.logic.data.models.table.GameInfo */): com.debertz.logic.data.models.table.DebertzTable;
290
+ toString(): string;
291
+ hashCode(): number;
292
+ equals(other: Nullable<any>): boolean;
293
+ static get Companion(): {
294
+ initial(id: string, version: string, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */): com.debertz.logic.data.models.table.DebertzTable;
295
+ };
296
+ }
297
+ }
298
+ export declare namespace com.debertz.logic.data.models.table {
299
+ class TableLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
300
+ constructor(id: string, players: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>);
301
+ get id(): string;
302
+ get players(): Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>;
303
+ toString(): string;
304
+ equals(other: Nullable<any>): boolean;
305
+ hashCode(): number;
306
+ copy(id?: string, players?: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>): com.debertz.logic.data.models.table.TableLoggerPayload;
307
+ readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
308
+ }
309
+ class PlayerLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
310
+ constructor(playerId: string, connectionState: com.logic.data.models.player.PlayerConnectionState);
311
+ get playerId(): string;
312
+ get connectionState(): com.logic.data.models.player.PlayerConnectionState;
313
+ toString(): string;
314
+ copy(playerId?: string, connectionState?: com.logic.data.models.player.PlayerConnectionState): com.debertz.logic.data.models.table.PlayerLoggerPayload;
315
+ hashCode(): number;
316
+ equals(other: Nullable<any>): boolean;
317
+ readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
318
+ }
319
+ }
320
+ export declare namespace com.debertz.logic.data.models.table.config {
321
+ abstract class BotIntelligenceLevel {
322
+ private constructor();
323
+ static get SUPER_HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
324
+ get name(): "SUPER_HARD";
325
+ get ordinal(): 0;
326
+ };
327
+ static get HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
328
+ get name(): "HARD";
329
+ get ordinal(): 1;
330
+ };
331
+ static get MEDIUM(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
332
+ get name(): "MEDIUM";
333
+ get ordinal(): 2;
334
+ };
335
+ static get EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
336
+ get name(): "EASY";
337
+ get ordinal(): 3;
338
+ };
339
+ static get SUPER_EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
340
+ get name(): "SUPER_EASY";
341
+ get ordinal(): 4;
342
+ };
343
+ static values(): Array<com.debertz.logic.data.models.table.config.BotIntelligenceLevel>;
344
+ static valueOf(value: string): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
345
+ get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
346
+ get ordinal(): 0 | 1 | 2 | 3 | 4;
347
+ static get Companion(): {
348
+ serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.BotIntelligenceLevel> */;
349
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
350
+ }
351
+ function getLevel(_this_: com.debertz.logic.data.models.table.config.BotIntelligenceLevel): number;
352
+ }
353
+ export declare namespace com.debertz.logic.data.models.table.config {
354
+ class Config {
355
+ constructor(rules: com.logic.data.models.rules.Rules, rulesSetType: com.logic.data.models.rules.RulesSetType, options: com.debertz.logic.data.models.table.config.Options, playersMode: com.debertz.logic.data.models.table.config.PlayersMode, pointsMode: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, isPrivate: boolean);
356
+ get rules(): com.logic.data.models.rules.Rules;
357
+ get rulesSetType(): com.logic.data.models.rules.RulesSetType;
358
+ get options(): com.debertz.logic.data.models.table.config.Options;
359
+ get playersMode(): com.debertz.logic.data.models.table.config.PlayersMode;
360
+ get pointsMode(): com.debertz.logic.data.models.table.config.PointsMode;
361
+ get timeoutTimeMillis(): number;
362
+ get isPrivate(): boolean;
363
+ copy(rules?: com.logic.data.models.rules.Rules, rulesSetType?: com.logic.data.models.rules.RulesSetType, options?: com.debertz.logic.data.models.table.config.Options, playersMode?: com.debertz.logic.data.models.table.config.PlayersMode, pointsMode?: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, isPrivate?: boolean): com.debertz.logic.data.models.table.config.Config;
364
+ toString(): string;
365
+ hashCode(): number;
366
+ equals(other: Nullable<any>): boolean;
367
+ }
368
+ }
369
+ export declare namespace com.debertz.logic.data.models.table.config {
370
+ class Options {
371
+ constructor(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean);
372
+ get isEnableChat(): boolean;
373
+ get botIntelligenceLevel(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
374
+ get timeForCountdownMillis(): number;
375
+ get timeForBotMillis(): number;
376
+ get isEnableChoosePartnerScreen(): boolean;
377
+ get isEnablePreviewScreen(): boolean;
378
+ copy(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean): com.debertz.logic.data.models.table.config.Options;
379
+ toString(): string;
380
+ hashCode(): number;
381
+ equals(other: Nullable<any>): boolean;
382
+ }
383
+ }
384
+ export declare namespace com.debertz.logic.data.models.table.config {
385
+ abstract class PlayersMode {
386
+ private constructor();
387
+ get players(): number;
388
+ static get TWO_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
389
+ get name(): "TWO_PLAYERS";
390
+ get ordinal(): 0;
391
+ };
392
+ static get THREE_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
393
+ get name(): "THREE_PLAYERS";
394
+ get ordinal(): 1;
395
+ };
396
+ static get FOUR_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
397
+ get name(): "FOUR_PLAYERS";
398
+ get ordinal(): 2;
399
+ };
400
+ static get FOUR_PLAYERS_BY_TEAM(): com.debertz.logic.data.models.table.config.PlayersMode & {
401
+ get name(): "FOUR_PLAYERS_BY_TEAM";
402
+ get ordinal(): 3;
403
+ };
404
+ get isTeamGame(): boolean;
405
+ get count(): number;
406
+ static values(): Array<com.debertz.logic.data.models.table.config.PlayersMode>;
407
+ static valueOf(value: string): com.debertz.logic.data.models.table.config.PlayersMode;
408
+ get name(): "TWO_PLAYERS" | "THREE_PLAYERS" | "FOUR_PLAYERS" | "FOUR_PLAYERS_BY_TEAM";
409
+ get ordinal(): 0 | 1 | 2 | 3;
410
+ static get Companion(): {
411
+ create(points: number): com.debertz.logic.data.models.table.config.PlayersMode;
412
+ serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.PlayersMode> */;
413
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
414
+ }
415
+ }
416
+ export declare namespace com.debertz.logic.data.models.table.config {
417
+ abstract class PointsMode {
418
+ private constructor();
419
+ get points(): number;
420
+ static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
421
+ get name(): "SMALL";
422
+ get ordinal(): 0;
423
+ };
424
+ static get MEDIUM(): com.debertz.logic.data.models.table.config.PointsMode & {
425
+ get name(): "MEDIUM";
426
+ get ordinal(): 1;
427
+ };
428
+ static get BIG(): com.debertz.logic.data.models.table.config.PointsMode & {
429
+ get name(): "BIG";
430
+ get ordinal(): 2;
431
+ };
432
+ static get TEST(): com.debertz.logic.data.models.table.config.PointsMode & {
433
+ get name(): "TEST";
434
+ get ordinal(): 3;
435
+ };
436
+ static values(): Array<com.debertz.logic.data.models.table.config.PointsMode>;
437
+ static valueOf(value: string): com.debertz.logic.data.models.table.config.PointsMode;
438
+ get name(): "SMALL" | "MEDIUM" | "BIG" | "TEST";
439
+ get ordinal(): 0 | 1 | 2 | 3;
440
+ static get Companion(): {
441
+ create(points: number): com.debertz.logic.data.models.table.config.PointsMode;
442
+ serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.PointsMode> */;
443
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
444
+ }
445
+ }
446
+ export declare namespace com.debertz.logic.redux.actions {
447
+ const ClearAction: {
448
+ toString(): string;
449
+ get actionTag(): string;
450
+ notValidateWhenFinishing(): boolean;
451
+ notValidateWhenFinished(): boolean;
452
+ readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
453
+ } & com.logic.domain.engine.definitions.Action & com.logic.redux.actions.validation.NotValidateIfGameFinishing & com.logic.redux.actions.validation.NotValidateIfGameFinished;
454
+ }
455
+ export declare namespace com.debertz.logic.redux.actions.client.from {
456
+ abstract class FromClientAction implements com.logic.domain.engine.definitions.Action {
457
+ protected constructor();
458
+ abstract get playerId(): string;
459
+ get actionTag(): string;
460
+ readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
461
+ }
462
+ }
463
+ export declare namespace com.debertz.logic.redux.actions.client.to {
464
+ class ActionDeliveryPayload {
465
+ constructor(roomId: string, sendToPlayerIds: Array<string>, deliveryType: com.debertz.logic.redux.actions.client.to.ActionDeliveryType);
466
+ get roomId(): string;
467
+ get sendToPlayerIds(): Array<string>;
468
+ get deliveryType(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
469
+ equals(other: Nullable<any>): boolean;
470
+ hashCode(): number;
471
+ copy(roomId?: string, sendToPlayerIds?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
472
+ toString(): string;
473
+ static get Companion(): {
474
+ user(roomId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
475
+ };
476
+ }
477
+ abstract class ActionDeliveryType {
478
+ private constructor();
479
+ static get ROOM_ALL(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
480
+ get name(): "ROOM_ALL";
481
+ get ordinal(): 0;
482
+ };
483
+ static get ROOM_EXCEPT_CURRENT(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
484
+ get name(): "ROOM_EXCEPT_CURRENT";
485
+ get ordinal(): 1;
486
+ };
487
+ static get USER(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
488
+ get name(): "USER";
489
+ get ordinal(): 2;
490
+ };
491
+ static values(): Array<com.debertz.logic.redux.actions.client.to.ActionDeliveryType>;
492
+ static valueOf(value: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
493
+ get name(): "ROOM_ALL" | "ROOM_EXCEPT_CURRENT" | "USER";
494
+ get ordinal(): 0 | 1 | 2;
495
+ static get Companion(): {
496
+ serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.redux.actions.client.to.ActionDeliveryType> */;
497
+ } & any/* kotlinx.serialization.internal.SerializerFactory */;
498
+ }
499
+ }
500
+ export declare namespace com.debertz.logic.redux.actions.client.to {
501
+ abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
502
+ protected constructor();
503
+ abstract get deliveryPayload(): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
504
+ get sendToPlayerId(): string;
505
+ get sendToPlayerIds(): Array<string>;
506
+ get roomId(): string;
507
+ get actionTag(): string;
508
+ readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
509
+ }
510
+ }
511
+ export declare namespace com.debertz.logic.redux.actions.game {
512
+ abstract class GameAction implements com.logic.domain.engine.definitions.Action {
513
+ protected constructor();
514
+ get actionTag(): string;
515
+ readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
516
+ }
517
+ class PartyStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
518
+ constructor(roomId: string, partyNumber: number, players: Array<string>, isFirstParty: boolean, gameNumber: number);
519
+ get roomId(): string;
520
+ get partyNumber(): number;
521
+ get players(): Array<string>;
522
+ get isFirstParty(): boolean;
523
+ get gameNumber(): number;
524
+ equals(other: Nullable<any>): boolean;
525
+ hashCode(): number;
526
+ copy(roomId?: string, partyNumber?: number, players?: Array<string>, isFirstParty?: boolean, gameNumber?: number): com.debertz.logic.redux.actions.game.PartyStartedAction;
527
+ toString(): string;
528
+ get actionTag(): string;
529
+ }
530
+ class PartyEndedAction extends com.debertz.logic.redux.actions.game.GameAction {
531
+ constructor(roomId: string, partyNumber: number, earnedBiggestPointPlayerId: string, partyLosers: Array<string>, partyWinners: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>);
532
+ get roomId(): string;
533
+ get partyNumber(): number;
534
+ get earnedBiggestPointPlayerId(): string;
535
+ get partyLosers(): Array<string>;
536
+ get partyWinners(): Array<string>;
537
+ get gameLosers(): Nullable<Array<string>>;
538
+ get gameWinners(): Nullable<Array<string>>;
539
+ get isGameFinished(): boolean;
540
+ equals(other: Nullable<any>): boolean;
541
+ hashCode(): number;
542
+ copy(roomId?: string, partyNumber?: number, earnedBiggestPointPlayerId?: string, partyLosers?: Array<string>, partyWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>): com.debertz.logic.redux.actions.game.PartyEndedAction;
543
+ toString(): string;
544
+ get actionTag(): string;
545
+ }
546
+ class PartyRestartedAction implements com.logic.domain.engine.definitions.Action {
547
+ constructor(roomId: string, partyNumber: number);
548
+ get roomId(): string;
549
+ get partyNumber(): number;
550
+ copy(roomId?: string, partyNumber?: number): com.debertz.logic.redux.actions.game.PartyRestartedAction;
551
+ toString(): string;
552
+ hashCode(): number;
553
+ equals(other: Nullable<any>): boolean;
554
+ get actionTag(): string;
555
+ readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
556
+ }
557
+ }
558
+ export declare namespace com.debertz.logic.redux.actions.mechanic {
559
+ abstract class MechanicAction implements com.logic.redux.actions.BufferedAction {
560
+ protected constructor();
561
+ get actionTag(): string;
562
+ readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
563
+ }
564
+ class FinishingGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
565
+ constructor(reason: com.logic.data.models.TerminationGameReason);
566
+ get reason(): com.logic.data.models.TerminationGameReason;
567
+ copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
568
+ toString(): string;
569
+ hashCode(): number;
570
+ equals(other: Nullable<any>): boolean;
571
+ get actionTag(): string;
572
+ readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
573
+ }
574
+ class FinishGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.debertz.logic.redux.actions.mechanic.TerminatedAction {
575
+ constructor(reason: com.logic.data.models.TerminationGameReason);
576
+ get reason(): com.logic.data.models.TerminationGameReason;
577
+ copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishGameMechanicAction;
578
+ toString(): string;
579
+ hashCode(): number;
580
+ equals(other: Nullable<any>): boolean;
581
+ get actionTag(): string;
582
+ notValidateWhenFinishing(): boolean;
583
+ readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
584
+ }
585
+ interface NavigationMechanicAction extends com.logic.domain.engine.definitions.Action {
586
+ readonly sceneId: string;
587
+ readonly actId: Nullable<string>;
588
+ readonly actPayload: Nullable<com.debertz.logic.data.models.scenes.ActData>;
589
+ readonly actionTag: string;
590
+ readonly __doNotUseOrImplementIt: {
591
+ readonly "com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
592
+ } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
593
+ }
594
+ class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.domain.engine.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
595
+ constructor(sceneId: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>);
596
+ get sceneId(): string;
597
+ get actId(): Nullable<string>;
598
+ get scenePayload(): Nullable<com.debertz.logic.data.models.scenes.SceneData>;
599
+ get actPayload(): Nullable<com.debertz.logic.data.models.scenes.ActData>;
600
+ notValidateWhenFinished(): boolean;
601
+ notValidateWhenFinishing(): boolean;
602
+ copy(sceneId?: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>): com.debertz.logic.redux.actions.mechanic.SceneMechanicAction;
603
+ toString(): string;
604
+ hashCode(): number;
605
+ equals(other: Nullable<any>): boolean;
606
+ get actionTag(): string;
607
+ readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction["__doNotUseOrImplementIt"] & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.ReleaseBufferTriggerAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
608
+ }
609
+ interface TerminatedAction extends com.logic.domain.engine.definitions.Action {
610
+ readonly reason: com.logic.data.models.TerminationGameReason;
611
+ readonly actionTag: string;
612
+ readonly __doNotUseOrImplementIt: {
613
+ readonly "com.debertz.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
614
+ } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
615
+ }
616
+ class PlayerConnectionChangedMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished {
617
+ constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>);
618
+ get playerId(): string;
619
+ get state(): com.logic.data.models.player.PlayerConnectionState;
620
+ get isNoneActivePlayers(): boolean;
621
+ get reconnectUntilTime(): Nullable<string>;
622
+ get isLive(): boolean;
623
+ get isTimeOut(): boolean;
624
+ get isLostConnection(): boolean;
625
+ get isLeft(): boolean;
626
+ get isDeleted(): boolean;
627
+ get shouldNotifyPlayers(): boolean;
628
+ copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>): com.debertz.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
629
+ toString(): string;
630
+ hashCode(): number;
631
+ equals(other: Nullable<any>): boolean;
632
+ get actionTag(): string;
633
+ notValidateWhenFinishing(): boolean;
634
+ notValidateWhenFinished(): boolean;
635
+ readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
636
+ }
637
+ }
638
+ export declare const ERROR: string;
639
+ export declare const DEBUG: string;
640
+ export declare const WARN: string;
641
+ export declare interface ParserHelper {
642
+ encodeFromClientEvent(action: com.debertz.logic.redux.actions.client.from.FromClientAction): string;
643
+ decodeFromClientEvent(fromPlayerId: string, json: string): com.debertz.logic.redux.actions.client.from.FromClientAction;
644
+ encodeToClientEvent(action: com.debertz.logic.redux.actions.client.to.ToClientAction): string;
645
+ decodeToClientEvent(playerId: string, table: com.debertz.logic.data.models.table.DebertzTable, json: string): com.debertz.logic.redux.actions.client.to.ToClientAction;
646
+ decodeToClientEventToMechanicAction(playerId: string, engine: com.debertz.logic.GameStoreContract, json: string): com.debertz.logic.redux.actions.mechanic.MechanicAction;
647
+ readonly __doNotUseOrImplementIt: {
648
+ readonly ParserHelper: unique symbol;
649
+ };
650
+ }
651
+ export declare namespace com.debertz.logic.client.domain.mechanic {
652
+ interface GameMechanic extends com.debertz.logic.GameStoreContract/*, com.debertz.logic.client.domain.scenes.PlayersSceneContract */ {
653
+ onCreate(): void;
654
+ onDestroy(): void;
655
+ getConfig(): com.debertz.logic.data.models.table.config.Config;
656
+ getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
657
+ observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
658
+ observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
659
+ observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
660
+ observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
661
+ observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
662
+ observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
663
+ observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
664
+ observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
665
+ observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
666
+ observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
667
+ observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
668
+ observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.LastBribeViewModel>> */;
669
+ observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.GameInfoViewModel>> */;
670
+ observeSettingsOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
671
+ switchLastBribe(open: boolean): void;
672
+ switchGameInfo(open: boolean): void;
673
+ switchSettings(open: boolean): void;
674
+ switchChat(open: boolean): void;
675
+ foreground(foreground: boolean): void;
676
+ updateConfig(updateConfig: any/* com.debertz.logic.client.data.models.config.UpdateConfigModel */): void;
677
+ observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
678
+ tutorialPassed(skipped: boolean): void;
679
+ playerExit(): void;
680
+ readonly id: string;
681
+ readonly table: com.debertz.logic.data.models.table.DebertzTable;
682
+ readonly isTableExists: boolean;
683
+ readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
684
+ readonly __doNotUseOrImplementIt: {
685
+ readonly "com.debertz.logic.client.domain.mechanic.GameMechanic": unique symbol;
686
+ } & com.debertz.logic.GameStoreContract["__doNotUseOrImplementIt"];
687
+ }
688
+ }
689
+ export declare namespace com.debertz.logic.client.domain.mechanic.online {
690
+ interface OnlineGameMechanic extends com.debertz.logic.client.domain.mechanic.GameMechanic {
691
+ readonly currentPlayerId: string;
692
+ observeFromClientAction(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.redux.actions.client.from.FromClientAction> */;
693
+ mechanicAction(action: com.debertz.logic.redux.actions.mechanic.MechanicAction): void;
694
+ error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
695
+ onCreate(): void;
696
+ onDestroy(): void;
697
+ getConfig(): com.debertz.logic.data.models.table.config.Config;
698
+ getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
699
+ observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
700
+ observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
701
+ observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
702
+ observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
703
+ observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
704
+ observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
705
+ observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
706
+ observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
707
+ observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
708
+ observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
709
+ observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
710
+ observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.LastBribeViewModel>> */;
711
+ observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.GameInfoViewModel>> */;
712
+ observeSettingsOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
713
+ switchLastBribe(open: boolean): void;
714
+ switchGameInfo(open: boolean): void;
715
+ switchSettings(open: boolean): void;
716
+ switchChat(open: boolean): void;
717
+ foreground(foreground: boolean): void;
718
+ updateConfig(updateConfig: any/* com.debertz.logic.client.data.models.config.UpdateConfigModel */): void;
719
+ observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
720
+ tutorialPassed(skipped: boolean): void;
721
+ playerExit(): void;
722
+ readonly id: string;
723
+ readonly table: com.debertz.logic.data.models.table.DebertzTable;
724
+ readonly isTableExists: boolean;
725
+ readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
726
+ readonly __doNotUseOrImplementIt: {
727
+ readonly "com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic": unique symbol;
728
+ } & com.debertz.logic.client.domain.mechanic.GameMechanic["__doNotUseOrImplementIt"];
729
+ }
730
+ }
731
+ export declare namespace com.debertz.logic.client.redux.state {
732
+ class ErrorState {
733
+ constructor(message?: Nullable<string>, userInfo?: Nullable<com.logic.data.models.player.GameUserInfo>, reason: com.logic.data.models.TerminationGameReason);
734
+ get message(): Nullable<string>;
735
+ get userInfo(): Nullable<com.logic.data.models.player.GameUserInfo>;
736
+ get reason(): com.logic.data.models.TerminationGameReason;
737
+ copy(message?: Nullable<string>, userInfo?: Nullable<com.logic.data.models.player.GameUserInfo>, reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.client.redux.state.ErrorState;
738
+ toString(): string;
739
+ hashCode(): number;
740
+ equals(other: Nullable<any>): boolean;
741
+ }
742
+ }
743
+ export declare interface GameClientEngineController {
744
+ readonly parser: ParserHelper;
745
+ setEnableLogger(enabled: boolean): void;
746
+ createOnlineGameEngine(currentPlayerId: string): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
747
+ createOnlineGameEngineWithLogic(currentPlayerId: string, reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.domain.engine.definitions.Action) => void, p2: any) => void>, isAutoStepCurrentPlayer?: boolean, botExitsWhenNGameNumberIsFinished?: Nullable<number>): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
748
+ readonly __doNotUseOrImplementIt: {
749
+ readonly GameClientEngineController: unique symbol;
750
+ };
751
+ }
752
+ export declare function createGameClientController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<any>) => void): GameClientEngineController;
753
+ export as namespace Logic_Debertz_game_client;