import * as Data from "./standardRule/data";
import * as OrderModule from "./standardRule/order";
import * as ErrorModule from "./standardRule/error";
import * as Types from "./standardRule/types";
import * as UtilsModule from "./standardRule/utils";
import * as HelperModule from "./standardRule/helper";
import * as RuleModule from "./standardRule/rule";
export declare namespace standardRule {
    type Location<Power> = Types.Location<Power>;
    const Location: typeof Types.Location;
    type Unit<Power> = Types.Unit<Power>;
    const Unit: typeof Types.Unit;
    type DiplomacyMap<Power> = Types.DiplomacyMap<Power>;
    const DiplomacyMap: typeof Types.DiplomacyMap;
    type Board<Power> = Types.Board<Power>;
    const Board: typeof Types.Board;
    type MilitaryBranch = Data.MilitaryBranch;
    const MilitaryBranch: typeof Data.MilitaryBranch;
    type Phase = Data.Phase;
    const Phase: typeof Data.Phase;
    type Turn = Data.Turn;
    type State = Data.State;
    const State: typeof Data.State;
    type Dislodged<Power> = Data.Dislodged<Power>;
    const Dislodged: typeof Data.Dislodged;
    type ProvinceStatus<Power> = Data.ProvinceStatus<Power>;
    const ProvinceStatus: typeof Data.ProvinceStatus;
    type Result = Data.Result;
    const Result: typeof Data.Result;
    namespace Order {
        type OrderType = OrderModule.OrderType;
        const OrderType: typeof OrderModule.OrderType;
        type Order<Power> = OrderModule.Order<Power>;
        const Order: typeof OrderModule.Order;
        type Hold<Power> = OrderModule.Hold<Power>;
        const Hold: typeof OrderModule.Hold;
        type Move<Power> = OrderModule.Move<Power>;
        const Move: typeof OrderModule.Move;
        type Support<Power> = OrderModule.Support<Power>;
        const Support: typeof OrderModule.Support;
        type Convoy<Power> = OrderModule.Convoy<Power>;
        const Convoy: typeof OrderModule.Convoy;
        type Retreat<Power> = OrderModule.Retreat<Power>;
        const Retreat: typeof OrderModule.Retreat;
        type Disband<Power> = OrderModule.Disband<Power>;
        const Disband: typeof OrderModule.Disband;
        type Build<Power> = OrderModule.Build<Power>;
        const Build: typeof OrderModule.Build;
    }
    namespace Error {
        type Error = ErrorModule.Error;
        const Error: typeof ErrorModule.Error;
        type PowerWithProblem<Power> = ErrorModule.PowerWithProblem<Power>;
        const PowerWithProblem: typeof ErrorModule.PowerWithProblem;
        type UnmovableLocation<Power> = ErrorModule.UnmovableLocation<Power>;
        const UnmovableLocation: typeof ErrorModule.UnmovableLocation;
        type UnsupportableLocation<Power> = ErrorModule.UnsupportableLocation<Power>;
        const UnsupportableLocation: typeof ErrorModule.UnsupportableLocation;
        type UnconvoyableLocation<Power> = ErrorModule.UnconvoyableLocation<Power>;
        const UnconvoyableLocation: typeof ErrorModule.UnconvoyableLocation;
        type UnbuildableLocation<Power> = ErrorModule.UnbuildableLocation<Power>;
        const UnbuildableLocation: typeof ErrorModule.UnbuildableLocation;
        type UnitNotExisted<Power> = ErrorModule.UnitNotExisted<Power>;
        const UnitNotExisted: typeof ErrorModule.UnitNotExisted;
        type CannotBeOrdered<Power> = ErrorModule.CannotBeOrdered<Power>;
        const CannotBeOrdered: typeof ErrorModule.CannotBeOrdered;
        type InvalidPhase<Power> = ErrorModule.InvalidPhase<Power>;
        const InvalidPhase: typeof ErrorModule.InvalidPhase;
        type SeveralOrders<Power> = ErrorModule.SeveralOrders<Power>;
        const SeveralOrders: typeof ErrorModule.SeveralOrders;
        type OrderNotExisted<Power> = ErrorModule.OrderNotExisted<Power>;
        const OrderNotExisted: typeof ErrorModule.OrderNotExisted;
    }
    type Utils = UtilsModule.Utils;
    const Utils: typeof UtilsModule.Utils;
    type Helper<Power> = HelperModule.Helper<Power>;
    const Helper: typeof HelperModule.Helper;
    type Rule<Power> = RuleModule.Rule<Power>;
    const Rule: typeof RuleModule.Rule;
}