import 'reflect-metadata';
export declare class GameEventContract implements Core.EventSystem.EventContract {
    type: any;
    callback: Function;
    expired: boolean;
    broken: boolean;
    register(type: any, callback: Function): void;
    off(): void;
    on(): void;
    break(): void;
}
import { GameEventContract } from "./game-event-contract";
export declare class GameEventListener implements Core.EventSystem.EventListener {
    private listEventContract;
    getContract(): GameEventContract[];
    register(type: any, callback: Function): Core.EventSystem.EventContract;
}
import { GameEventListener } from "./game-event-listener";
export declare class GameEventPublisher implements Core.EventSystem.EventPublisher {
    private listEventListener;
    add(listener: GameEventListener): void;
    emit(type: any): void;
    private executeListenerCallback;
    private removeBrokenContract;
}
export declare class BetConstantParameter implements Core.Parameter.BetConstantParameter {
    get DEFAULT_LIST_BET_OPTION(): number[];
}
export declare const COMMAND: {
    Default: symbol;
    Target: symbol;
    Decorator: symbol;
    PlaceBet: symbol;
    ClearBet: symbol;
    ClearAllBet: symbol;
    DoubleBet: symbol;
    Rebet: symbol;
    ResetBet: symbol;
};
export declare const UNDO_MANAGER: {
    Bet: symbol;
};
export declare const CONTROLLER: {
    Default: symbol;
    Game: symbol;
    Room: symbol;
    Bet: symbol;
    BetOption: symbol;
    Balance: symbol;
    Countdown: symbol;
    Statistic: symbol;
    Odds: symbol;
    History: symbol;
    BetLimit: symbol;
    RoundResult: symbol;
    Win: symbol;
    Error: symbol;
    LoungeBetLimit: symbol;
    LoungeBetOption: symbol;
};
export declare const CONTROLLER_EVENT_PUBLISHER: {
    Default: symbol;
};
export declare const CONTROLLER_EVENT_LISTENER: {
    Default: symbol;
};
export declare const GAME_VIEW: {
    Bet: symbol;
    BetOption: symbol;
    Countdown: symbol;
    Statistic: symbol;
    Odds: symbol;
    Balance: symbol;
    History: symbol;
    BetLimit: symbol;
    RoundResult: symbol;
    Win: symbol;
    Error: symbol;
    Lounge: symbol;
};
export declare const MODEL: {
    ApplicationConfig: symbol;
    BetLimit: symbol;
    RemainBalance: symbol;
    BetBalance: symbol;
    Bet: symbol;
    Rebet: symbol;
    BetPosition: symbol;
    ListBetOption: symbol;
    SelectedBetOption: symbol;
    RoomIndex: symbol;
    BetConflict: symbol;
    ListBetConflict: symbol;
    History: symbol;
    RoundRecord: symbol;
    Statistic: symbol;
    ListOdds: symbol;
    RoundResult: symbol;
    Win: symbol;
    Countdown: symbol;
    Error: symbol;
    HttpServer: symbol;
    ListRoomBetOption: symbol;
    ListRoomBetLimit: symbol;
};
export declare const NETWORK_CONNECTOR: {
    Default: symbol;
    EventProcessor: symbol;
};
export declare const NETWORK_REQUEST: {
    Default: symbol;
};
export declare const NETWORK_RESPONSE: {
    Default: symbol;
    OnConnect: symbol;
    OnConnectRetry: symbol;
    OnDisconnect: symbol;
    OnLogout: symbol;
    OnRoomJoin: symbol;
    OnMessageData: symbol;
    OnError: symbol;
    OnLoginError: symbol;
    OnBetLimit: symbol;
    OnBalance: symbol;
    OnGameStart: symbol;
    OnBetSettings: symbol;
    OnStatistic: symbol;
    OnRoundStart: symbol;
    OnResult: symbol;
    OnWin: symbol;
    OnRoundEnd: symbol;
    OnConfirmBetSuccessfully: symbol;
    OnConfirmBetFailed: symbol;
    OnOdds: symbol;
};
export declare const NETWORK_COMMAND: {
    Connect: symbol;
    JoinRoom: symbol;
    StartNewRound: symbol;
    ConfirmBet: symbol;
    CollectPoint: symbol;
};
export declare const NETWORK_EVENT_PUBLISHER: {
    Default: symbol;
};
export declare const NETWORK_EVENT_LISTENER: {
    Default: symbol;
};
export declare const DATA_PROCESSOR: {
    Default: symbol;
    Chain: symbol;
};
export declare const HTTP_RESPONSE: {
    Success: symbol;
    Failed: symbol;
    Invalid: symbol;
    Error: symbol;
};
export declare const PARAMETER: {
    BetConstant: symbol;
    GameConstant: symbol;
};
export declare const AVAILABLE_BET_CALCULATOR: unique symbol;
export declare const VALIDATOR: {
    EnoughBalanceToBet: symbol;
    BetConflict: symbol;
    BetPointBelowMaxBetLimit: symbol;
    TotalBetBelowMaxTotalBetLimit: symbol;
    BetForbidden: symbol;
    EmptyBetTable: symbol;
};
export type StateMachineKeys = {
    EventManager: symbol;
    StateMachine: symbol;
};
export declare const CONTROLLER_STATE_MACHINE: Record<string, StateMachineKeys>;
export declare const STATE_CONTEXT: unique symbol;
export declare const DEFAULT_STATE: unique symbol;
export declare const LIST_STATE_TRANSITION_CREATOR: unique symbol;
export declare const LIST_STATE_TRANSITION_ASSERTOR: {
    Default: symbol;
    Chain: symbol;
};
import { Container } from "inversify";
declare const container: Container;
export { container };
export declare class AvailableBetCalculator implements Core.Service.AvailableBetCalculator {
    private betModel;
    private currentBetLimitModel;
    private remainBalanceModel;
    private listBetOptionModel;
    private betConstantParameter;
    constructor(betModel: Core.Model.BetModel, currentBetLimitModel: Core.Model.BetLimitModel, remainBalanceModel: Core.Model.BalanceModel, listBetOptionModel: Core.Model.ListBetOptionModel, betConstantParameter: Core.Parameter.BetConstantParameter);
    getAvailableBet(betPositionIndex: number): number;
    private getAvailableBetPoint;
    private getAvailableTotalBet;
}
export declare abstract class ChainDataProcessor implements Core.Network.DataProcessor {
    private nextDataProcessor;
    constructor(nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
}
import { CommandWrapper } from "./command-wrapper";
export declare abstract class CommandProxy extends CommandWrapper {
    execute(): void;
    protected handleValidateFailed(): void;
    protected abstract validate(): boolean;
}
export declare abstract class CommandWrapper implements Core.Pattern.Command {
    protected targetCommand: Core.Pattern.Command;
    constructor(targetCommand: Core.Pattern.Command);
    execute(): void;
}
export declare class UndoManager implements Core.Pattern.UndoManager {
    private undoableQueue;
    push(undoable: Core.Pattern.Undoable): void;
    undo(): void;
    isUndoable(): boolean;
    reset(): void;
    private removeUndoable;
}
export declare class BetConflictValidator implements Core.Service.Validator {
    private betModel;
    private betPositionModel;
    private listBetConflictModel;
    constructor(betModel: Core.Model.BetModel, betPositionModel: Core.Model.BetPositionModel, listBetConflictModel: Core.Model.ListBetConflictModel);
    validate(): boolean;
    private isConflict;
}
export declare class BetPointBelowMaxBetLimitValidator implements Core.Service.Validator {
    private betPositionModel;
    private betModel;
    private betLimitModel;
    constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel);
    validate(): boolean;
}
export declare class EnoughBalanceToBetValidator implements Core.Service.Validator {
    private listBetOptionModel;
    private remainBalanceModel;
    private betConstantParameter;
    constructor(listBetOptionModel: Core.Model.ListBetOptionModel, remainBalanceModel: Core.Model.BalanceModel, betConstantParameter: Core.Parameter.BetConstantParameter);
    validate(): boolean;
}
export declare class TotalBetBelowMaxTotalBetLimitValidator implements Core.Service.Validator {
    private betModel;
    private betLimitModel;
    constructor(betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel);
    validate(): boolean;
}
export declare class EmptyBetTableValidator implements Core.Service.Validator {
    private betModel;
    constructor(betModel: Core.Model.BetModel);
    validate(): boolean;
}
export declare abstract class ListStateTransitionCreator<T extends Core.State.State> implements Core.State.ListStateTransitionCreator<T> {
    private assertor;
    constructor(assertor: Core.State.ListStateTransitionAssertor<T>);
    create(): Core.State.ListStateTransition<T>;
    protected abstract getListStateTransition(): Core.State.ListStateTransition<T>;
}
export declare abstract class ChainListStateTransitionAssertor<T extends Core.State.State> implements Core.State.ListStateTransitionAssertor<T> {
    private nextAssertor?;
    constructor(nextAssertor?: Core.State.ListStateTransitionAssertor<T>);
    assert(listStateTransition: Core.State.ListStateTransition<T>): void;
    protected abstract _assert(listStateTransition: Core.State.ListStateTransition<T>): void;
}
import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor";
export declare class ListStateTransitionDuplicateAssertor extends ChainListStateTransitionAssertor<Core.State.State> {
    protected _assert(listStateTransition: Core.State.ListStateTransition<Core.State.State>): void;
    private convertTransitionToString;
    private isDuplicateTransition;
    private isSameFromState;
    private isSameEvent;
}
import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor";
export declare class ListStateTransitionInheritanceAssertor extends ChainListStateTransitionAssertor<Core.State.State> {
    protected _assert(listStateTransition: Core.State.ListStateTransition<Core.State.State>): void;
    private getListState;
    private assertNoStateInheritance;
    private throwErrorIfInherited;
    private isInheritedState;
}
export declare function registerStateMachineNetworkEvent(listNetworkEvent: symbol[], stateMachine: Core.State.StateMachine<Core.State.State>): void;
import { StateMachineKeys } from "../ioc-config/ioc-config-state";
export declare function setupStateMachineEventManager(stateMachineKeys: StateMachineKeys): void;
export declare class StateContext<T extends Core.State.State> implements Core.State.StateContext<T> {
    protected currentState: T;
    constructor(defaultState: T);
    setState(state: T): void;
    getState(): T;
}
export declare class StateMachineEventManager implements Core.State.StateMachineEventManager {
    private listStateMachine;
    registerStateMachine(stateMachine: Core.State.StateMachine<Core.State.State>): void;
    unregisterStateMachine(stateMachine: Core.State.StateMachine<Core.State.State>): void;
    emit(event: symbol): void;
}
export declare class StateMachine<T extends Core.State.State> implements Core.State.StateMachine<T> {
    protected stateContext: Core.State.StateContext<T>;
    private listStateTransition;
    constructor(stateContext: Core.State.StateContext<T>, listStateTransitionCreator: Core.State.ListStateTransitionCreator<T>);
    getState(): T;
    changeState(event: Symbol): void;
    private getTransition;
    private executeTransition;
}
import { interfaces } from "inversify";
declare class BindingHelper {
    targetNamed(request: interfaces.Request, name: string | number | symbol): boolean;
    targetTagged(request: interfaces.Request, key: string | number | symbol, value: unknown): boolean;
    targetIsDefault(request: interfaces.Request): boolean;
    injectInto(request: interfaces.Request, parent: (NewableFunction | string)): boolean;
    parentNamed(request: interfaces.Request, name: string | number | symbol): boolean;
    parentTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
    anyAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean;
    noAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean;
    anyAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
    noAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
    anyAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean;
    noAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean;
}
declare var when: BindingHelper;
export { when };
import { interfaces } from 'inversify';
declare function customServiceLocator(container: interfaces.Container, doCache?: boolean): {
    customInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
    customInjectNamed: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, named: string) => (proto: any, key: string) => void;
    customInjectTagged: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, key: string, value: any) => (proto: any, propertyName: string) => void;
    customMultiInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
};
export { customServiceLocator };
import { interfaces } from "inversify";
interface DependencyBranch {
    from(type: any): DependencyGraphHelper;
}
declare class DependencyGraphHelper implements DependencyBranch {
    private container;
    private graphs;
    private isBranching;
    private branchNode;
    private isSingletonGraph;
    inSingletonScope(): DependencyGraphHelper;
    bind(identifier: any, type: any, isConstant?: boolean): DependencyGraphHelper;
    branch(identifier: any, type: any, isConstant?: boolean): DependencyBranch;
    from(type: any): DependencyGraphHelper;
    registerTo(container: interfaces.Container): void;
    private registerGraphToContainer;
    private resetGraph;
    private bindInSingletonScopeTo;
    private bindTo;
    private bindToConstant;
    private recursiveCheckBindingCondition;
}
declare var dependencyGraph: DependencyGraphHelper;
export { dependencyGraph };
export declare class BalanceController implements Core.Controller.BalanceController {
    private betBalanceModel;
    private remainBalanceModel;
    private balanceGameView;
    constructor(betBalanceModel: Core.Model.BalanceModel, remainBalanceModel: Core.Model.BalanceModel, balanceGameView: Core.View.GameView);
    updateBalance(credit: number, freeCredit: number): void;
    releaseBetCredit(): void;
    withdraw(amount: number): void;
    deposit(amount: number): void;
    private getBalanceModelName;
    private transferCredit;
    private calculateTransferAmounts;
    private resetBetBalance;
}
export declare class ClearAllBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
    private betModel;
    private remainBalanceModel;
    private balanceController;
    private errorController;
    private betUndoManager;
    private betGameView;
    private listReturnBetPoint;
    private get totalReturnBetPoint();
    constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, errorController: Core.Controller.ErrorController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView);
    execute(): void;
    undo(onSuccess?: Function): void;
}
export declare class ClearBetCommand implements Core.Pattern.Command {
    private betPositionModel;
    private betModel;
    private controllerEventPublisher;
    private balanceController;
    constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, controllerEventPublisher: Core.EventSystem.EventPublisher, balanceController: Core.Controller.BalanceController);
    execute(): void;
}
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
export declare class CheckBetConflictCommandProxy extends CommandProxy {
    private betConflictValidator;
    private errorController;
    constructor(targetCommand: Core.Pattern.Command, betConflictValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
    protected validate(): boolean;
    protected handleValidateFailed(): void;
}
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
export declare class CheckEmptyBetTableCommandProxy extends CommandProxy {
    private emptyBetTableValidator;
    constructor(targetCommand: Core.Pattern.Command, emptyBetTableValidator: Core.Service.Validator);
    protected validate(): boolean;
}
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
export declare class CheckEnoughBalanceCommandProxy extends CommandProxy {
    private enoughBalanceToBetValidator;
    private errorController;
    constructor(targetCommand: Core.Pattern.Command, enoughBalanceToBetValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
    protected validate(): boolean;
    protected handleValidateFailed(): void;
}
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
export declare class CheckMaxBetLimitCommandProxy extends CommandProxy {
    private betPointBelowMaxBetLimitValidator;
    private errorController;
    constructor(targetCommand: Core.Pattern.Command, betPointBelowMaxBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
    protected validate(): boolean;
    protected handleValidateFailed(): void;
}
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
export declare class CheckMaxTotalBetLimitCommandProxy extends CommandProxy {
    private totalBetBelowMaxTotalBetLimitValidator;
    private errorController;
    constructor(targetCommand: Core.Pattern.Command, totalBetBelowMaxTotalBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
    protected validate(): boolean;
    protected handleValidateFailed(): void;
}
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
export declare class DoubleBetCommandWrapper extends CommandWrapper {
}
import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command";
import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data";
export declare class DoubleBetCommand extends PlaceMultiBetCommand {
    constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator);
    protected getTargetPlaceMultiBetData(): PlaceMultiBetData;
}
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
export declare class PlaceBetCommandWrapper extends CommandWrapper {
}
export declare class PlaceBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
    protected betPositionModel: Core.Model.BetPositionModel;
    protected selectedBetOptionModel: Core.Model.SelectedBetOptionModel;
    protected betModel: Core.Model.BetModel;
    protected availableBetCalculator: Core.Service.AvailableBetCalculator;
    protected betUndoManager: Core.Pattern.UndoManager;
    private balanceController;
    private betGameView;
    constructor(betPositionModel: Core.Model.BetPositionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betModel: Core.Model.BetModel, availableBetCalculator: Core.Service.AvailableBetCalculator, betUndoManager: Core.Pattern.UndoManager, balanceController: Core.Controller.BalanceController, betGameView: Core.View.GameView);
    protected placeBetPositionIndex: number;
    protected placedBetValue: number;
    execute(): void;
    undo(onSuccess?: Function): void;
    private placeBet;
}
import { PlaceMultiBetData } from "./place-multi-bet-data";
export declare abstract class PlaceMultiBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
    protected betModel: Core.Model.BetModel;
    protected remainBalanceModel: Core.Model.BalanceModel;
    protected balanceController: Core.Controller.BalanceController;
    protected betUndoManager: Core.Pattern.UndoManager;
    protected betGameView: Core.View.GameView;
    private availableBetCalculator;
    private listPlacedBet;
    constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator);
    execute(): void;
    undo(onSuccess?: Function): void;
    private registerUndo;
    private adjustBets;
    private adjustBetsToAvailableBet;
    private adjustBetsToBalance;
    protected abstract getTargetPlaceMultiBetData(): PlaceMultiBetData;
}
export type PlaceMultiBetData = {
    betPositionIndex: number;
    betPoint: number;
}[];
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
export declare class RebetCommandWrapper extends CommandWrapper {
}
import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command";
import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data";
export declare class RebetCommand extends PlaceMultiBetCommand {
    private rebetModel;
    constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator, rebetModel: Core.Model.BetModel);
    protected getTargetPlaceMultiBetData(): PlaceMultiBetData;
}
export declare class ResetBetCommand implements Core.Pattern.Command {
    private balanceController;
    private betBalanceModel;
    private betModel;
    private betUndoManager;
    private betGameView;
    constructor(balanceController: Core.Controller.BalanceController, betBalanceModel: Core.Model.BalanceModel, betModel: Core.Model.BetModel, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView);
    execute(): void;
    private returnBetPointToBalance;
    private resetBet;
}
export declare class BetController implements Core.Controller.BetController {
    private betControllerStateMachine;
    constructor(betControllerStateMachine: Core.State.BetControllerStateMachine);
    placeBet(betPositionIndex: number): void;
    clearBet(betPositionIndex: number): void;
    clearAllBet(): void;
    doubleBet(): void;
    rebet(): void;
    undo(): void;
    reset(): void;
}
export declare class BetControllerDisableState implements Core.State.BetControllerState {
    placeBet(): void;
    clearBet(): void;
    clearAllBet(): void;
    doubleBet(): void;
    undo(): void;
    rebet(): void;
    reset(): void;
    enter(): void;
    leave(): void;
}
export declare class BetControllerEnableState implements Core.State.BetControllerState {
    private betPositionModel;
    private betUndoManager;
    constructor(betPositionModel: Core.Model.BetPositionModel, betUndoManager: Core.Pattern.UndoManager);
    placeBet(betPositionIndex: number): void;
    clearBet(betPositionIndex: number): void;
    clearAllBet(): void;
    doubleBet(): void;
    rebet(): void;
    undo(): void;
    reset(): void;
    enter(): void;
    leave(): void;
}
export declare const BET_CONTROLLER_EVENT: {
    Enable: symbol;
    Disable: symbol;
};
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
export declare class BetControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.BetControllerState> {
    protected getListStateTransition(): Core.State.ListStateTransition<Core.State.BetControllerState>;
}
import { StateContext } from "../../../../common/state/state-context";
export declare class BetControllerStateContext extends StateContext<Core.State.BetControllerState> implements BetControllerStateContext {
}
import { StateMachine } from "../../../../common/state/state-machine";
export declare class BetControllerStateMachine extends StateMachine<Core.State.BetControllerState> {
}
export declare class BetLimitController implements Core.Controller.BetLimitController {
    private listRoomBetLimitModel;
    private betLimitModel;
    private betLimitGameView;
    constructor(listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, betLimitModel: Core.Model.BetLimitModel, betLimitGameView: Core.View.GameView);
    updateCurrentBetLimit(roomIndex: number): void;
}
export declare class LoungeBetLimitController implements Core.Controller.LoungeBetLimitController {
    private listRoomBetLimitModel;
    private loungeGameView;
    constructor(listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, loungeGameView: Core.View.GameView);
    updateBetLimitSetting(listBetLimitSetting: Core.Model.BetLimitModel[]): void;
}
export declare class BetOptionController implements Core.Controller.BetOptionController {
    private listBetOptionModel;
    private selectedBetOptionModel;
    private betOptionGameView;
    private betOptionControllerStateMachine;
    constructor(listBetOptionModel: Core.Model.ListBetOptionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView, betOptionControllerStateMachine: Core.State.StateMachine<Core.State.BetOptionControllerState>);
    updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
    changeBetOption(betOption: number): void;
}
export declare class LoungeBetOptionController implements Core.Controller.LoungeBetOptionController {
    private listRoomBetOptionModel;
    private loungeGameView;
    constructor(listRoomBetOptionModel: Core.Model.ListRoomBetOptionModel, loungeGameView: Core.View.GameView);
    updateBetOptionSetting(listBetOptionSetting: Core.Model.ListBetOptionModel[]): void;
}
export declare class BetOptionControllerDisableState implements Core.State.BetOptionControllerState {
    updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
    changeBetOption(betOption: number): void;
    enter(): void;
    leave(): void;
}
export declare class BetOptionControllerEnableState implements Core.State.BetOptionControllerState {
    private selectedBetOptionModel;
    private betOptionGameView;
    constructor(selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView);
    changeBetOption(betOption: number): void;
    updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
    enter(): void;
    leave(): void;
}
export declare const BET_OPTION_CONTROLLER_EVENT: {
    Disable: symbol;
    Enable: symbol;
};
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
export declare class BetOptionControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.BetOptionControllerState> {
    protected getListStateTransition(): Core.State.ListStateTransition<Core.State.BetOptionControllerState>;
}
import { StateContext } from "../../../../common/state/state-context";
export declare class BetOptionControllerStateContext extends StateContext<Core.State.BetOptionControllerState> implements Core.State.BetOptionControllerStateContext {
}
import { StateMachine } from "../../../../common/state/state-machine";
export declare class BetOptionControllerStateMachine extends StateMachine<Core.State.BetOptionControllerState> {
}
export declare class SecondTickCountdownController implements Core.Controller.CountdownController {
    private countdownModel;
    private countdownGameView;
    private intervalId;
    constructor(countdownModel: Core.Model.CountdownModel, countdownGameView: Core.View.GameView);
    startCountdown(duration: number, callbacks?: {
        onComplete?: Function;
        onTick?: Function;
    }): void;
    stop(): void;
    reset(): void;
    private setRemainTime;
}
export declare class ErrorController implements Core.Controller.ErrorController {
    private errorModel;
    private errorGameView;
    constructor(errorModel: Core.Model.ErrorModel, errorGameView: Core.View.GameView);
    handleServerError(errorCode: number): void;
    handleError(error: Symbol): void;
}
export declare const ERROR_TYPE: {
    MaxBetReached: symbol;
    BetConflict: symbol;
    NotEnoughBalanceToBet: symbol;
    ServerError: symbol;
    Disconnect: symbol;
};
export declare class GameController implements Core.Controller.GameController {
    private gameControllerStateMachine;
    constructor(gameControllerStateMachine: Core.State.GameControllerStateMachine);
    startNewRound(): void;
    confirmBet(): void;
    collectPoint(): void;
}
import { GameControllerState } from "./game-controller-state";
export declare class GameControllerBetState extends GameControllerState {
    private connector;
    private betModel;
    private gameControllerEventManager;
    private betControllerEventManager;
    private betOptionControllerEventManager;
    constructor(connector: Core.Network.Connector, betModel: Core.Model.BetModel, gameControllerEventManager: Core.State.StateMachineEventManager, betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager);
    confirmBet(): void;
    enter(): void;
    leave(): void;
    private enableControllers;
    private disableControllers;
}
import { GameControllerState } from "./game-controller-state";
export declare class GameControllerCollectingPointState extends GameControllerState {
    private connector;
    constructor(connector: Core.Network.Connector);
    collectPoint(): void;
}
import { GameControllerState } from "./game-controller-state";
export declare class GameControllerDisableState extends GameControllerState {
    private betControllerEventManager;
    private betOptionControllerEventManager;
    constructor(betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager);
    enter(): void;
}
import { GameControllerState } from "./game-controller-state";
export declare class GameControllerEndRoundState extends GameControllerState {
    private betController;
    private connector;
    constructor(betController: Core.Controller.BetController, connector: Core.Network.Connector);
    startNewRound(): void;
    leave(): void;
}
export declare class GameControllerState implements Core.State.GameControllerState {
    startNewRound(): void;
    confirmBet(): void;
    collectPoint(): void;
    enter(): void;
    leave(): void;
}
export declare const GAME_CONTROLLER_EVENT: {
    SendNetworkRequest: symbol;
};
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
export declare class GameControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.GameControllerState> {
    protected getListStateTransition(): Core.State.ListStateTransition<Core.State.GameControllerState>;
}
import { StateContext } from "../../../../common/state/state-context";
export declare class GameControllerStateContext extends StateContext<Core.State.GameControllerState> {
}
import { StateMachine } from "../../../../common/state/state-machine";
export declare class GameControllerStateMachine extends StateMachine<Core.State.GameControllerState> {
}
export declare class HistoryController<RoundResult> implements Core.Controller.HistoryController<RoundResult> {
    private historyModel;
    private historyGameView;
    constructor(historyModel: Core.Model.HistoryModel<RoundResult>, historyGameView: Core.View.GameView);
    updateHistory(listRoundRecord: Core.Model.RoundRecordModel<RoundResult>[]): void;
}
export declare class OddsController implements Core.Controller.OddsController {
    private listOddsModel;
    private oddsView;
    constructor(listOddsModel: Core.Model.ListOddsModel, oddsView: Core.View.GameView);
    updateListOdds(listOdds: number[]): void;
}
export declare class RoundResultController<RoundResult> implements Core.Controller.RoundResultController<RoundResult> {
    private statisticController;
    private roundResultModel;
    private roundResultGameView;
    constructor(statisticController: Core.Controller.StatisticController<RoundResult>, roundResultModel: Core.Model.RoundResultModel<RoundResult>, roundResultGameView: Core.View.GameView);
    updateRoundResult(roundResult: RoundResult): void;
}
export declare class RoomController implements Core.Controller.RoomController {
    private roomControllerStateMachine;
    constructor(roomControllerStateMachine: Core.State.StateMachine<Core.State.RoomControllerState>);
    joinRoom(roomIndex: number): void;
    leaveRoom(): void;
}
import { RoomControllerState } from "./room-controller-state";
export declare class RoomControllerDisableState extends RoomControllerState {
}
export declare const ROOM_CONTROLLER_EVENT: {
    RequestJoinRoom: symbol;
    LeaveRoom: symbol;
};
import { RoomControllerState } from "./room-controller-state";
export declare class RoomControllerInRoomState extends RoomControllerState {
    private roomControllerEventManager;
    private rebetModel;
    private statisticModel;
    private betController;
    constructor(roomControllerEventManager: Core.State.StateMachineEventManager, rebetModel: Core.Model.BetModel, statisticModel: Core.Model.StatisticModel, betController: Core.Controller.BetController);
    leaveRoom(): void;
    leave(): void;
    private clearStatistics;
    private clearBet;
}
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
export declare class RoomControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.RoomControllerState> {
    protected getListStateTransition(): Core.State.ListStateTransition<Core.State.RoomControllerState>;
}
import { RoomControllerState } from "./room-controller-state";
export declare class RoomControllerLoungeState extends RoomControllerState {
    private roomControllerEventManager;
    private connector;
    constructor(roomControllerEventManager: Core.State.StateMachineEventManager, connector: Core.Network.Connector);
    joinRoom(roomIndex: number): void;
}
import { StateContext } from "../../../../common/state/state-context";
export declare class RoomControllerStateContext extends StateContext<Core.State.RoomControllerState> implements Core.State.RoomControllerStateContext {
}
import { StateMachine } from "../../../../common/state/state-machine";
export declare class RoomControllerStateMachine extends StateMachine<Core.State.RoomControllerState> {
}
export declare class RoomControllerState implements Core.State.RoomControllerState {
    joinRoom(roomIndex: number): void;
    leaveRoom(): void;
    enter(): void;
    leave(): void;
}
export declare class StatisticController<RoundResult> implements Core.Controller.StatisticController<RoundResult> {
    private statisticModel;
    private statisticView;
    constructor(statisticModel: Core.Model.StatisticModel<RoundResult>, statisticView: Core.View.GameView);
    addRoundResult(roundResult: RoundResult): void;
    addListRoundResult(listRoundResult: RoundResult[]): void;
}
export declare class WinController implements Core.Controller.WinController {
    private winModel;
    private winGameView;
    constructor(winModel: Core.Model.WinModel, winGameView: Core.View.GameView);
    updateTotalWinPoint(totalWinPoint: number): void;
}
export declare abstract class HttpNetworkCommand<ParamType = void> implements Core.Pattern.Command<ParamType> {
    protected networkRequest: Core.Network.NetworkRequest;
    constructor(networkRequest: Core.Network.NetworkRequest);
    execute(param: ParamType): void;
    protected getRequestData(param: ParamType): any;
}
export declare class Connector implements Core.Network.Connector {
    private connectCommand;
    private joinRoomCommand;
    private startNewRoundCommand;
    private confirmBetCommand;
    private collectPointCommand;
    constructor(connectCommand: Core.Pattern.Command, joinRoomCommand: Core.Pattern.Command<number>, startNewRoundCommand: Core.Pattern.Command, confirmBetCommand: Core.Pattern.Command<number[]>, collectPointCommand: Core.Pattern.Command);
    connectToServer(): void;
    joinRoom(roomIndex: number): void;
    startNewRound(): void;
    sendConfirmBet(betArray: number[]): void;
    collectPoint(): void;
}
import { RESTfulAPIRequest } from "./restful-api-request";
export declare abstract class APIGet extends RESTfulAPIRequest {
    protected getAPIMethod(): string;
}
import { RESTfulAPIRequest } from "./restful-api-request";
export declare abstract class APIPost extends RESTfulAPIRequest {
    protected getAPIMethod(): string;
}
export declare abstract class RESTfulAPIRequest implements Core.Network.NetworkRequest {
    private successResponseHandler;
    private invalidResponseHandler?;
    private failedResponseHandler?;
    private errorResponseHandler?;
    private httpServerModel;
    constructor(successResponseHandler: Core.Network.NetworkResponse, invalidResponseHandler?: Core.Network.NetworkResponse, failedResponseHandler?: Core.Network.NetworkResponse, errorResponseHandler?: Core.Network.NetworkResponse);
    send(data?: any): void;
    private sendHTTPRequest;
    protected getHeader(): HeadersInit;
    protected abstract getAPIMethod(): string;
    protected abstract getAPIName(): string;
    private onSuccessResponse;
    private onInvalidResponse;
    private onRequestFailed;
    private onError;
}
export declare class ConsoleTraceResponse implements Core.Network.NetworkResponse {
    onResponse(data?: any): void;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultBalanceProcessor extends ChainDataProcessor {
    private balanceController;
    private betController;
    private betBalanceModel;
    constructor(balanceController: Core.Controller.BalanceController, betController: Core.Controller.BetController, betBalanceModel: Core.Model.BalanceModel, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getBalance;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultBetOptionProcessor extends ChainDataProcessor {
    private betOptionController;
    constructor(betOptionController: Core.Controller.BetOptionController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getDefaultBetOption;
    private getListBetOption;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultBetSettingProcessor extends ChainDataProcessor {
    private betLimitController;
    private roomIndexModel;
    constructor(betLimitController: Core.Controller.BetLimitController, roomIndexModel: Core.Model.RoomIndexModel, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getRoomIndex;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultLoungeBetLimitProcessor extends ChainDataProcessor {
    private loungeBetLimitController;
    constructor(loungeBetLimitController: Core.Controller.LoungeBetLimitController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getListBetLimitSetting;
    private getBetLimit;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultLoungeBetOptionProcessor extends ChainDataProcessor {
    private loungeBetOptionController;
    constructor(loungeBetOptionController: Core.Controller.LoungeBetOptionController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getListBetOptionSetting;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultOddsProcessor extends ChainDataProcessor {
    private oddsController;
    constructor(oddsController: Core.Controller.OddsController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getListOdds;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultServerErrorProcessor extends ChainDataProcessor {
    private errorController;
    constructor(errorController: Core.Controller.ErrorController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getErrorCode;
}
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
export declare class DefaultWinProcessor extends ChainDataProcessor {
    private winController;
    constructor(winController: Core.Controller.WinController, nextDataProcessor?: Core.Network.DataProcessor);
    process(data: any): void;
    private getTotalWinPoint;
}
export declare abstract class NetworkResponse implements Core.Network.NetworkResponse {
    protected networkEventPublisher: Core.EventSystem.EventPublisher;
    protected dataProcessor?: Core.Network.DataProcessor;
    constructor(networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
    onResponse(data?: any): void;
    protected abstract getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnBalance extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnBetLimitResponse extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnBetSettings extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnConfirmBetFailed extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnConfirmBetSuccessfully extends NetworkResponse {
    private betModel;
    private rebetModel;
    private balanceController;
    constructor(betModel: Core.Model.BetModel, rebetModel: Core.Model.BetModel, balanceController: Core.Controller.BalanceController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
    protected getNetworkResponseSymbol(): Symbol;
    onResponse(data?: any): void;
    private setConfirmedBetToRebet;
}
import { NetworkResponse } from "./network-response";
export declare class OnConnect extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnDisconnect extends NetworkResponse {
    private errorController;
    constructor(errorController: Core.Controller.ErrorController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
    onResponse(data?: any): void;
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnError extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnGameStart extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnOdds extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnRoomJoin extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnRoundEnd extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnRoundResult extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnRoundStart extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnStatistic extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
import { NetworkResponse } from "./network-response";
export declare class OnWin extends NetworkResponse {
    protected getNetworkResponseSymbol(): Symbol;
}
export declare class ApplicationConfigModel implements Core.Model.ApplicationConfigModel {
    sessionOCode: string;
    sessionHash: string;
    platform: string;
    port: number;
    address: string;
    currency: string;
    publisher: string;
    enabledSSL: boolean;
}
export declare class BalanceModel implements Core.Model.BalanceModel {
    credit: number;
    freeCredit: number;
    get totalCredit(): number;
}
export declare class BetLimitModel implements Core.Model.BetLimitModel {
    listMinBetPoint: number[];
    listMaxBetPoint: number[];
    minTotalBetPoint: number;
    maxTotalBetPoint: number;
}
export declare class BetModel implements Core.Model.BetModel {
    listBetPoint: number[];
    constructor(gameConstantParameter: Core.Parameter.GameConstantParameter);
}
export declare class BetPositionModel implements Core.Model.BetPositionModel {
    index: number;
}
export declare class CountdownModel implements Core.Model.CountdownModel {
    remainTime: number;
}
export declare class ErrorModel implements Core.Model.ErrorModel {
    errorType: Symbol;
    serverErrorCode: number;
}
export declare class ListBetConflictModel implements Core.Model.ListBetConflictModel {
    listBetConflict: Core.Model.BetConflictModel[];
}
export declare class ListBetOptionModel implements Core.Model.ListBetOptionModel {
    listBetOption: number[];
}
export declare class ListOddsModel implements Core.Model.ListOddsModel {
    listOdds: number[];
    constructor(gameConstantParameter: Core.Parameter.GameConstantParameter);
}
export declare class ListRoomBetLimitModel implements Core.Model.ListRoomBetLimitModel {
    listRoomBetLimit: Core.Model.BetLimitModel[];
}
export declare class ListRoomBetOptionModel implements Core.Model.ListRoomBetOptionModel {
    listRoomBetOption: Core.Model.ListBetOptionModel[];
}
export declare class RoomIndexModel implements Core.Model.RoomIndexModel {
    roomIndex: number;
}
export declare class RoundResultModel<RoundResult> implements Core.Model.RoundResultModel<RoundResult> {
    roundResult: RoundResult;
}
export declare class SelectedBetOptionModel implements Core.Model.SelectedBetOptionModel {
    selectedBetOption: number;
}
export declare class WinModel implements Core.Model.WinModel {
    totalWinPoint: number;
}
export declare class GameView implements Core.View.GameView {
    private listComponent;
    addComponent(component: Core.View.ComponentView): void;
    update(): void;
}