doc-slot-core-manual/assets/core/plugins/core.i.ts

declare namespace Core.Pattern {
    interface Command<ParamType = void> {
        execute(param: ParamType): void;
    }
}
declare namespace Core.Pattern {
    interface UndoManager {
        push(undoable: Undoable): any;
        undo(): any;
        isUndoable(): boolean;
        reset(): any;
    }
}
declare namespace Core.Pattern {
    interface Undoable {
        undo(onSuccess?: Function): void;
    }
}
declare namespace Core.Controller {
    interface BalanceController {
        updateBalance(credit: number, freeCredit: number): void;
        withdraw(credit: number): void;
        deposit(credit: number): void;
        releaseBetCredit(): void;
    }
}
declare namespace Core.Controller {
    interface BetController {
        placeBet(betPositionIndex: number): void;
        clearBet(betPositionIndex: number): void;
        clearAllBet(): void;
        doubleBet(): void;
        undo(): void;
        rebet(): void;
        reset(): void;
    }
}
declare namespace Core.Controller {
    interface BetLimitController {
        updateCurrentBetLimit(betLimitModel: Model.BetLimitModel): any;
    }
}
declare namespace Core.Controller {
    interface BetOptionController {
        updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
        changeBetOption(betOption: number): void;
    }
}
declare namespace Core.Controller {
    interface CountdownController {
        startCountdown(duration: number, callbacks?: {
            onComplete?: Function;
            onTick?: Function;
        }): any;
        stop(): any;
        reset(): any;
    }
}
declare namespace Core.Controller {
    interface ErrorController {
        handleError(error: Symbol): void;
        handleServerError(errorCode: number): void;
    }
}
declare namespace Core.Controller {
    interface GameController {
        startNewRound(): void;
        confirmBet(): void;
        collectPoint(): void;
    }
}
declare namespace Core.Controller {
    interface HistoryController<RoundResult> {
        updateHistory(listRoundRecord: Core.Model.RoundRecordModel<RoundResult>[]): void;
    }
}
declare namespace Core.Controller {
    interface LoungeBetLimitController {
        updateBetLimitSetting(listBetLimitSetting: Core.Model.BetLimitModel[]): void;
    }
}
declare namespace Core.Controller {
    interface LoungeBetOptionController {
        updateBetOptionSetting(listBetOptionSetting: Model.ListBetOptionModel[]): void;
    }
}
declare namespace Core.Controller {
    interface OddsController {
        updateListOdds(listOdds: number[]): any;
    }
}
declare namespace Core.Controller {
    interface RoomController {
        joinRoom(roomIndex: number): void;
        leaveRoom(): void;
    }
}
declare namespace Core.Controller {
    interface RoundResultController<RoundResult> {
        updateRoundResult(roundResult: RoundResult): void;
    }
}
declare namespace Core.Controller {
    interface StatisticController<RoundResult> {
        addRoundResult(roundResult: RoundResult): void;
        addListRoundResult(listRoundResult: RoundResult[]): void;
    }
}
declare namespace Core.Controller {
    interface WinController {
        updateTotalWinPoint(totalWinPoint: number): void;
    }
}
declare namespace Core.EventSystem {
    interface EventListener {
        register(type: any, callback: Function): EventContract;
    }
    interface EventPublisher {
        emit(type: any): void;
    }
    interface EventContract {
        on(): void;
        off(): void;
        break(): void;
    }
}
declare namespace Core.Model {
    interface ApplicationConfigModel {
        sessionOCode: string;
        sessionHash: string;
        platform: string;
        port: number;
        address: string;
        currency: string;
        publisher: string;
        enabledSSL: boolean;
    }
}
declare namespace Core.Model {
    interface BalanceModel {
        credit: number;
        freeCredit: number;
        get totalCredit(): number;
    }
}
declare namespace Core.Model {
    interface BetConflictModel {
        listConflictBetPosition: number[];
    }
}
declare namespace Core.Model {
    interface BetLimitModel {
        listMinBetPoint: number[];
        listMaxBetPoint: number[];
        minTotalBetPoint: number;
        maxTotalBetPoint: number;
    }
}
declare namespace Core.Model {
    interface BetModel {
        listBetPoint: number[];
    }
}
declare namespace Core.Model {
    interface BetPositionModel {
        index: number;
    }
}
declare namespace Core.Model {
    interface BetSettingModel {
        listBetPoint: number[];
    }
}
declare namespace Core.Model {
    interface CountdownModel {
        remainTime: number;
    }
}
declare namespace Core.Model {
    interface ErrorModel {
        errorType: Symbol;
        serverErrorCode: number;
    }
}
declare namespace Core.Model {
    interface HistoryModel<RoundResult> {
        listRoundRecord: RoundRecordModel<RoundResult>[];
    }
}
declare namespace Core.Model {
    interface HTTPServerModel {
        url: string;
    }
}
declare namespace Core.Model {
    interface ListBetConflictModel {
        listBetConflict: BetConflictModel[];
    }
}
declare namespace Core.Model {
    interface ListBetOptionModel {
        listBetOption: number[];
    }
}
declare namespace Core.Model {
    interface ListOddsModel {
        listOdds: number[];
    }
}
declare namespace Core.Model {
    interface ListPlayerModel {
        listPlayer: PlayerModel[];
    }
}
declare namespace Core.Model {
    interface ListRoomBetLimitModel {
        listRoomBetLimit: BetLimitModel[];
    }
}
declare namespace Core.Model {
    interface ListRoomBetOptionModel {
        listRoomBetOption: ListBetOptionModel[];
    }
}
declare namespace Core.Model {
    interface PlayerModel {
        id: string;
        name: string;
        balance: number;
    }
}
declare namespace Core.Model {
    interface RoomIndexModel {
        roomIndex: number;
    }
}
declare namespace Core.Model {
    interface RoundRecordModel<RoundResult extends any = number[]> {
        roundId: string;
        betTime: Date;
        stake: number;
        win: number;
        profitLoss: number;
        roundResult: RoundResult;
    }
}
declare namespace Core.Model {
    interface RoundResultModel<RoundResult> {
        roundResult: RoundResult;
    }
}
declare namespace Core.Model {
    interface SelectedBetOptionModel {
        selectedBetOption: number;
    }
}
declare namespace Core.Model {
    interface StatisticModel<RoundResult = any> {
        listRoundResult: RoundResult[];
    }
}
declare namespace Core.Model {
    interface WinModel {
        totalWinPoint: number;
    }
}
declare namespace Core.Network {
    interface Connector {
        connectToServer(): void;
        joinRoom(roomIndex: number): void;
        startNewRound(): void;
        sendConfirmBet(betArray: number[]): void;
        collectPoint(): void;
    }
}
declare namespace Core.Network {
    interface DataProcessor {
        process(data: any): void;
    }
}
declare namespace Core.Network {
    interface NetworkController {
        connectToServer(): any;
        disconnectFromServer(): any;
    }
}
declare namespace Core.Network {
    interface NetworkRequest {
        send(data?: any): void;
    }
}
declare namespace Core.Network {
    interface NetworkResponse {
        onResponse(data?: any): any;
    }
}
declare namespace Core.Parameter {
    interface BetConstantParameter {
        get DEFAULT_LIST_BET_OPTION(): number[];
    }
}
declare namespace Core.Parameter {
    interface GameConstantParameter {
        get BET_POSITION_COUNT(): number;
    }
}
declare namespace Core.Service {
    interface AvailableBetCalculator {
        getAvailableBet(betPositionIndex: number): number;
    }
}
declare namespace Core.Service {
    interface Validator {
        validate(): boolean;
    }
}
declare namespace Core.State {
    interface BetControllerStateContext extends StateContext<BetControllerState> {
    }
}
declare namespace Core.State {
    interface BetControllerStateMachine extends StateMachine<BetControllerState> {
    }
}
declare namespace Core.State {
    interface BetControllerState extends Controller.BetController, State {
    }
}
declare namespace Core.State {
    interface BetOptionControllerStateContext extends StateContext<BetOptionControllerState> {
    }
}
declare namespace Core.State {
    interface BetOptionControllerStateMachine extends StateMachine<BetOptionControllerState> {
    }
}
declare namespace Core.State {
    interface BetOptionControllerState extends Controller.BetOptionController, State {
    }
}
declare namespace Core.State {
    interface GameControllerStateContext extends StateContext<GameControllerState> {
    }
}
declare namespace Core.State {
    interface GameControllerStateMachine extends StateMachine<GameControllerState> {
    }
}
declare namespace Core.State {
    interface GameControllerState extends Controller.GameController, State {
    }
}
declare namespace Core.State {
    interface RoomControllerStateContext extends StateContext<RoomControllerState> {
    }
}
declare namespace Core.State {
    interface RoomControllerStateMachine extends StateMachine<RoomControllerState> {
    }
}
declare namespace Core.State {
    interface RoomControllerState extends Controller.RoomController, State {
    }
}
declare namespace Core.State {
    interface StateContext<T extends State> {
        setState(state: T): void;
        getState(): T;
    }
}
declare namespace Core.State {
    interface StateMachine<T extends State> {
        changeState(event: symbol): void;
        getState(): T;
    }
    interface StateMachineEventManager<T extends State = State> {
        registerStateMachine(stateMachine: StateMachine<T>): void;
        unregisterStateMachine(stateMachine: StateMachine<T>): void;
        emit(event: symbol): void;
    }
}
declare namespace Core.State {
    interface StateTransition<T extends State> {
        from?: new (...arg: any[]) => T;
        event: symbol;
        to: new (...arg: any[]) => T;
    }
    type ListStateTransition<T extends State> = StateTransition<T>[];
    interface ListStateTransitionAssertor<T extends State> {
        assert(listStateTransition: ListStateTransition<T>): any;
    }
    interface ListStateTransitionCreator<T extends State> {
        create(): ListStateTransition<T>;
    }
}
declare namespace Core.State {
    interface State {
        enter(): void;
        leave(): void;
    }
}
declare namespace Core.View {
    interface ComponentView {
        render(): void;
    }
    interface GameView {
        addComponent(component: ComponentView): void;
        update(): void;
    }
}