qpremake 1.5.1

package/lib/specificEffects/e_generic_cardTargetting.d.ts

@@ -0,0 +1,38 @@
+import type { dry_card, dry_system, inputData_card, inputType } from "../data/systemRegistry";
+import type { Action, noExtraParam } from "../_queenSystem/handler/actionGenrator";
+import Effect from "../types/abstract/gameComponents/effect";
+import { oneTarget } from "../_queenSystem/handler/actionGenrator";
+import type { identificationInfo_card } from "../data/systemRegistry";
+import { inputRequester, inputRequester_finalized } from "../_queenSystem/handler/actionInputGenerator";
+type targettableActionName = Exclude<oneTarget<identificationInfo_card, noExtraParam>, "a_add_effect" | "a_add_status_effect">;
+export declare class e_generic_cardTargetting extends Effect<[inputData_card]> {
+    protected resolutionAID?: targettableActionName;
+    createInputObj(c: dry_card, s: dry_system, a: Action): inputRequester<inputType.card, [inputData_card], [inputData_card], inputData_card, inputData_card, []>;
+    canRespondAndActivate_final(c: dry_card, system: dry_system, a: Action): boolean;
+    activate_final(c: dry_card, system: dry_system, a: Action, input: inputRequester_finalized<inputData_card[]>): Action[];
+}
+export declare class e_clear_all_status extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_deactivate extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_decompile extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_destroy extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_execute extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_reactivate extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_reset extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export declare class e_void extends e_generic_cardTargetting {
+    protected resolutionAID: targettableActionName;
+}
+export {};

package/lib/specificEffects/e_generic_cardTargetting.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.e_void = exports.e_reset = exports.e_reactivate = exports.e_execute = exports.e_destroy = exports.e_decompile = exports.e_deactivate = exports.e_clear_all_status = exports.e_generic_cardTargetting = void 0;
+const effect_1 = __importDefault(require("../types/abstract/gameComponents/effect"));
+const actionGenrator_1 = require("../_queenSystem/handler/actionGenrator");
+const actionInputRequesterGenerator_1 = __importDefault(require("../_queenSystem/handler/actionInputRequesterGenerator"));
+class e_generic_cardTargetting extends effect_1.default {
+    createInputObj(c, s, a) {
+        return actionInputRequesterGenerator_1.default.allZones(s, c).cards().once();
+    }
+    canRespondAndActivate_final(c, system, a) {
+        return this.resolutionAID !== undefined;
+    }
+    activate_final(c, system, a, input) {
+        let r = this.resolutionAID;
+        if (r === undefined)
+            return [];
+        const cause = this.cause(system, c);
+        const target = input.next().map(d => d.data.card);
+        return target.map(c => actionGenrator_1.actionConstructorRegistry[r](system, c)(cause));
+    }
+}
+exports.e_generic_cardTargetting = e_generic_cardTargetting;
+class e_clear_all_status extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_clear_all_status_effect";
+    }
+}
+exports.e_clear_all_status = e_clear_all_status;
+class e_deactivate extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_disable_card";
+    }
+}
+exports.e_deactivate = e_deactivate;
+class e_decompile extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_enable_card";
+    }
+}
+exports.e_decompile = e_decompile;
+class e_destroy extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_destroy";
+    }
+}
+exports.e_destroy = e_destroy;
+class e_execute extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_execute";
+    }
+}
+exports.e_execute = e_execute;
+class e_reactivate extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_enable_card";
+    }
+}
+exports.e_reactivate = e_reactivate;
+class e_reset extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_reset_card";
+    }
+}
+exports.e_reset = e_reset;
+class e_void extends e_generic_cardTargetting {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = "a_void";
+    }
+}
+exports.e_void = e_void;

package/lib/specificEffects/e_generic_noneTargetting.d.ts

@@ -0,0 +1,10 @@
+import type { dry_card, dry_system } from "../data/systemRegistry";
+import type { Action } from "../_queenSystem/handler/actionGenrator";
+import Effect from "../types/abstract/gameComponents/effect";
+import { oneTarget, noExtraParam, Action_class } from "../_queenSystem/handler/actionGenrator";
+import type { identificationInfo_none } from "../data/systemRegistry";
+export default class e_generic_noneTargetting extends Effect {
+    protected resolutionAID: oneTarget<identificationInfo_none, noExtraParam> | undefined;
+    canRespondAndActivate_final(c: dry_card, system: dry_system, a: Action): boolean;
+    activate_final(c: dry_card, system: dry_system, a: Action): Action_class<[identificationInfo_none], never, {}>[];
+}

package/lib/specificEffects/e_generic_noneTargetting.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const effect_1 = __importDefault(require("../types/abstract/gameComponents/effect"));
+const actionGenrator_1 = require("../_queenSystem/handler/actionGenrator");
+class e_generic_noneTargetting extends effect_1.default {
+    constructor() {
+        super(...arguments);
+        this.resolutionAID = undefined;
+    }
+    canRespondAndActivate_final(c, system, a) {
+        return this.resolutionAID !== undefined;
+    }
+    activate_final(c, system, a) {
+        let r = this.resolutionAID;
+        if (r === undefined)
+            return [];
+        const cause = this.cause(system, c);
+        return [
+            actionGenrator_1.actionConstructorRegistry[r](cause)
+        ];
+    }
+}
+exports.default = e_generic_noneTargetting;

package/lib/specificEffects/e_status.d.ts

@@ -0,0 +1,80 @@
+import Effect from "../types/abstract/gameComponents/effect";
+import type { dry_card, dry_system } from "../data/systemRegistry";
+import type { Action } from "../_queenSystem/handler/actionGenrator";
+export declare class StatusEffect_base extends Effect {
+    get mergeSignature(): string | undefined;
+    merge(mergeTargets: StatusEffect_base[]): StatusEffect_base[];
+    parseStat(statObj: {
+        level: number;
+        maxAtk: number;
+        maxHp: number;
+        extensionArr: string[];
+    }): void;
+    activateOnTurnStart?(c: dry_card, system: dry_system, a: Action<"a_turn_start">): Action[];
+    activateOnTurnEnd?(c: dry_card, system: dry_system, a: Action<"a_turn_end">): Action[];
+    activateOnApply?(c: dry_card, system: dry_system, a: Action<"a_add_status_effect">): Action[];
+    activateOnRemove?(c: dry_card, system: dry_system, a: Action<"a_remove_status_effect">): Action[];
+    activateOnReProc?(c: dry_card, system: dry_system, a: Action<"a_activate_effect"> | Action<"a_activate_effect_internal">): Action[];
+    canRespondAndActivate_final(c: dry_card, system: dry_system, a: Action): boolean;
+    activate_final(c: dry_card, system: dry_system, a: Action): import("../_queenSystem/handler/actionGenrator").Action_class<import("../data/systemRegistry").identificationInfo[], any, any>[];
+}
+export declare class e_any_extension extends StatusEffect_base {
+    parseStat(statObj: {
+        atk: number;
+        hp: number;
+        level: number;
+        maxAtk: number;
+        maxHp: number;
+        extensionArr: string[];
+    }): void;
+    merge(mergeTargets: StatusEffect_base[]): StatusEffect_base[];
+}
+export declare class genericCounter extends StatusEffect_base {
+    merge(mergeTargets: genericCounter[]): genericCounter[];
+    get count(): number;
+    set count(val: number);
+    getDisplayInput(): (string | number)[];
+}
+export declare class generic_stat_change_diff extends StatusEffect_base {
+    get maxAtk(): number;
+    get maxHp(): number;
+    get level(): number;
+    set maxAtk(val: number);
+    set maxHp(val: number);
+    set level(val: number);
+    parseStat(statObj: {
+        level: number;
+        maxAtk: number;
+        maxHp: number;
+        extensionArr: string[];
+    }): void;
+    merge(mergeTargets: generic_stat_change_diff[]): generic_stat_change_diff[];
+}
+export declare class generic_stat_change_override extends StatusEffect_base {
+    get maxAtk(): number | undefined;
+    get maxHp(): number | undefined;
+    get level(): number | undefined;
+    set maxAtk(val: number);
+    set maxHp(val: number);
+    set level(val: number);
+    parseStat(statObj: {
+        level: number;
+        maxAtk: number;
+        maxHp: number;
+        extensionArr: string[];
+    }): void;
+    merge(mergeTargets: generic_stat_change_override[]): generic_stat_change_override[];
+}
+export declare class e_automate_base extends StatusEffect_base {
+    get countdown(): number;
+    set countdown(a: number);
+    private act;
+    activateOnTurnEnd(c: dry_card, system: dry_system, a: Action<"a_turn_end">): Action[];
+}
+declare const _default: {
+    e_any_extension: typeof e_any_extension;
+    e_generic_counter: typeof genericCounter;
+    e_generic_stat_change_diff: typeof generic_stat_change_diff;
+    e_generic_stat_change_override: typeof generic_stat_change_override;
+};
+export default _default;

package/lib/specificEffects/e_status.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.e_automate_base = exports.generic_stat_change_override = exports.generic_stat_change_diff = exports.genericCounter = exports.e_any_extension = exports.StatusEffect_base = void 0;
+// import type Card from "./card";
+const effect_1 = __importDefault(require("../types/abstract/gameComponents/effect"));
+const actionRegistry_1 = __importDefault(require("../data/actionRegistry"));
+class StatusEffect_base extends effect_1.default {
+    // the existence of id neccessitates a handler
+    // this handler is special tho, it need to create the Status effect first, apply later
+    // unlike card or s.th, which creates and provide in the same function
+    //merge behavior is automatic upon end of turn
+    get mergeSignature() {
+        return this.constructor.name;
+    }
+    //merge target is guaranteed to have the same signature of this
+    merge(mergeTargets) { return mergeTargets; }
+    parseStat(statObj) { }
+    // ^ if this status effects allows for reproc using activateEffect action
+    //normally that isnt fucking possible? 
+    //its like forcefully activating a passive
+    //makes no sense on paper
+    //but in practice....yeh its for expandability
+    canRespondAndActivate_final(c, system, a) {
+        if (system.isInTriggerPhase && this.activateOnTurnStart && a.typeID === actionRegistry_1.default.a_turn_start) {
+            return true;
+        }
+        if (system.isInChainPhase && this.activateOnTurnEnd && a.typeID === actionRegistry_1.default.a_turn_end) {
+            return true;
+        }
+        if (system.isInTriggerPhase && this.activateOnApply && a.typeID === actionRegistry_1.default.a_add_status_effect && a.flatAttr().typeID === this.id) {
+            return true;
+        }
+        if (system.isInChainPhase && this.activateOnRemove && a.typeID === actionRegistry_1.default.a_remove_status_effect && a.flatAttr().typeID === this.id) {
+            return true;
+        }
+        return false;
+    }
+    activate_final(c, system, a) {
+        let res = [];
+        if (this.activateOnTurnStart && a.typeID === actionRegistry_1.default.a_turn_start) {
+            res = this.activateOnTurnStart(c, system, a);
+        }
+        if (this.activateOnTurnEnd && a.typeID === actionRegistry_1.default.a_turn_end) {
+            res = this.activateOnTurnEnd(c, system, a);
+        }
+        if (this.activateOnApply && a.typeID === actionRegistry_1.default.a_add_status_effect) {
+            res = this.activateOnApply(c, system, a);
+        }
+        if (this.activateOnRemove && a.typeID === actionRegistry_1.default.a_remove_status_effect) {
+            res = this.activateOnRemove(c, system, a);
+        }
+        if (this.activateOnReProc && (a.typeID === actionRegistry_1.default.a_activate_effect || a.typeID === actionRegistry_1.default.a_activate_effect_internal)) {
+            res = this.activateOnReProc(c, system, a);
+        }
+        res.forEach(i => i.isChain = true);
+        return res;
+    }
+}
+exports.StatusEffect_base = StatusEffect_base;
+class e_any_extension extends StatusEffect_base {
+    parseStat(statObj) {
+        statObj.extensionArr = ["*"];
+    }
+    merge(mergeTargets) {
+        return [this];
+    }
+}
+exports.e_any_extension = e_any_extension;
+class genericCounter extends StatusEffect_base {
+    merge(mergeTargets) {
+        let c = this.count;
+        mergeTargets.forEach(i => c += i.count);
+        this.count = c;
+        return [this];
+    }
+    get count() { var _a; return (_a = this.attr.get("count")) !== null && _a !== void 0 ? _a : 1; }
+    set count(val) { this.attr.set("count", val); }
+    getDisplayInput() {
+        return [this.count];
+    }
+}
+exports.genericCounter = genericCounter;
+class generic_stat_change_diff extends StatusEffect_base {
+    get maxAtk() { var _a; return (_a = this.attr.get("maxAtk")) !== null && _a !== void 0 ? _a : 0; }
+    get maxHp() { var _a; return (_a = this.attr.get("maxHp")) !== null && _a !== void 0 ? _a : 0; }
+    get level() { var _a; return (_a = this.attr.get("level")) !== null && _a !== void 0 ? _a : 0; }
+    set maxAtk(val) { this.attr.set("maxAtk", val); }
+    set maxHp(val) { this.attr.set("maxHp", val); }
+    set level(val) { this.attr.set("level", val); }
+    parseStat(statObj) {
+        statObj.maxAtk += this.maxAtk;
+        statObj.maxHp += this.maxHp;
+        statObj.level += this.level;
+    }
+    merge(mergeTargets) {
+        mergeTargets.forEach(i => {
+            this.maxAtk += i.maxAtk;
+            this.maxHp += i.maxHp;
+            this.level += i.level;
+        });
+        return [this];
+    }
+}
+exports.generic_stat_change_diff = generic_stat_change_diff;
+class generic_stat_change_override extends StatusEffect_base {
+    get maxAtk() { return this.attr.get("maxAtk"); }
+    get maxHp() { return this.attr.get("maxHp"); }
+    get level() { return this.attr.get("level"); }
+    set maxAtk(val) { this.attr.set("maxAtk", val); }
+    set maxHp(val) { this.attr.set("maxHp", val); }
+    set level(val) { this.attr.set("level", val); }
+    parseStat(statObj) {
+        if (this.maxAtk !== undefined)
+            statObj.maxAtk = this.maxAtk;
+        if (this.maxHp !== undefined)
+            statObj.maxHp = this.maxHp;
+        if (this.level !== undefined)
+            statObj.level = this.level;
+    }
+    merge(mergeTargets) {
+        if (mergeTargets.length === 0)
+            return [this];
+        return [mergeTargets.at(-1)];
+    }
+}
+exports.generic_stat_change_override = generic_stat_change_override;
+class e_automate_base extends StatusEffect_base {
+    get countdown() { var _a; return (_a = this.attr.get("countdown")) !== null && _a !== void 0 ? _a : 0; }
+    ;
+    set countdown(a) { this.attr.set("countdown", a); }
+    ;
+    act(c, system, a) { return []; }
+    activateOnTurnEnd(c, system, a) {
+        this.countdown--;
+        if (this.countdown === 0) {
+            //act
+            return this.act(c, system, a);
+        }
+        return [];
+    }
+}
+exports.e_automate_base = e_automate_base;
+exports.default = {
+    e_any_extension,
+    e_generic_counter: genericCounter,
+    e_generic_stat_change_diff: generic_stat_change_diff,
+    e_generic_stat_change_override: generic_stat_change_override,
+};

package/lib/specificEffects/e_test.d.ts

@@ -0,0 +1,3 @@
+import { inputData_num } from "../data/systemRegistry";
+import Effect from "../types/abstract/gameComponents/effect";
+export declare function get_effect_require_number_input(l: number, set?: number[]): typeof Effect<inputData_num[]>;

package/lib/specificEffects/e_test.js

@@ -0,0 +1,21 @@
+"use strict";
+//effects only used for testing
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_effect_require_number_input = get_effect_require_number_input;
+const actionInputRequesterGenerator_1 = __importDefault(require("../_queenSystem/handler/actionInputRequesterGenerator"));
+const effect_1 = __importDefault(require("../types/abstract/gameComponents/effect"));
+function get_effect_require_number_input(l, set = Utils.range(l)) {
+    return class e_num_x extends effect_1.default {
+        createInputObj(c, s, a) {
+            console.log(`--------> From inside, e_num_${l}, input asked, set = ${set}`);
+            return l === 1 ? actionInputRequesterGenerator_1.default.nums(s, set).once() : actionInputRequesterGenerator_1.default.nums(s, set).many(l);
+        }
+        activate_final(c, s, a, input) {
+            console.log(`------------> From inside, e_num_${l}, input is : `, input.next().map(k => k.data));
+            return [];
+        }
+    };
+}

package/lib/types/abstract/gameComponents/API.d.ts

@@ -0,0 +1,19 @@
+import type { cardData, effectData } from "../../../data/cardRegistry";
+import type { zoneData } from "../../../data/zoneRegistry";
+import type Zone from "./zone";
+import type Effect from "./effect";
+import type EffectSubtype from "./effectSubtype";
+import type queenSystem from "../../../_queenSystem/queenSystem";
+import type { Action } from "../../../_queenSystem/handler/actionGenrator";
+export default interface registryAPI {
+    registry_edit_card(key: string, value: cardData): void;
+    registry_edit_effect_data(key: string, data: effectData): void;
+    registry_edit_effect_class(key: string, constructors: typeof Effect | Record<string, typeof Effect>): void;
+    registry_edit_effect(key: string, data: effectData, constructors: typeof Effect | Record<string, typeof Effect>): void;
+    registry_edit_effect_subtype(key: string, constructor: typeof EffectSubtype): void;
+    registry_edit_zone_data(key: string, data: zoneData): void;
+    registry_edit_zone_class(key: string, constructor: typeof Zone): void;
+    registry_edit_zone(key: string, data: zoneData, constructor: typeof Zone): void;
+    registry_edit_custom_action_handler(actionIDs: number[], handlerFunc: ((a: Action, system: queenSystem) => undefined | void | Action[])): void;
+    registry_edit_localization(language: string, key: string, val: string): void;
+}

package/lib/types/abstract/gameComponents/API.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/abstract/gameComponents/card.d.ts

@@ -0,0 +1,108 @@
+import Effect from "./effect";
+import { StatusEffect_base } from "../../../specificEffects/e_status";
+import Position from "../generics/position";
+import type { dry_card, dry_system } from "../../../data/systemRegistry";
+import { Action } from "../../../_queenSystem/handler/actionGenrator";
+import type res from "../generics/universalResponse";
+import { cardData_unified, partitionData, partitionActivationBehavior, type_and_or_subtype_inference_method } from "../../../data/cardRegistry";
+import { Setting } from "./settings";
+import { id_able } from "../../misc";
+import type { zoneRegistry } from "../../../data/zoneRegistry";
+import { inputRequester } from "../../../_queenSystem/handler/actionInputGenerator";
+export declare class partitionData_class implements partitionData {
+    mapping: number[];
+    behaviorID: partitionActivationBehavior;
+    displayID?: string;
+    typeID: string | type_and_or_subtype_inference_method.first | type_and_or_subtype_inference_method.most;
+    subTypeID: string[] | type_and_or_subtype_inference_method;
+    constructor(behaviorID: partitionActivationBehavior, ...mapping: number[]);
+    constructor(pdata: partitionData);
+}
+declare class Card {
+    setting: Setting;
+    pos: Position;
+    canAct: boolean;
+    originalData: cardData_unified;
+    effects: Effect[];
+    partitionInfo: partitionData_class[];
+    statusEffects: StatusEffect_base[];
+    attr: Map<string, any>;
+    constructor(s: Setting, cardData: cardData_unified, effectArr: Effect[]);
+    loadSetting(s: Setting): void;
+    private repartitioning;
+    private loadStat;
+    get level(): number;
+    set level(newLevel: number);
+    get rarityID(): number;
+    set rarityID(newRarityID: number);
+    get atk(): number;
+    set atk(n: number);
+    get hp(): number;
+    set hp(n: number);
+    get maxAtk(): number;
+    set maxAtk(n: number);
+    get maxHp(): number;
+    set maxHp(n: number);
+    get extensionArr(): string[];
+    set extensionArr(val: string[]);
+    get effectIDs(): string[];
+    get imgUrl(): string;
+    get belongTo(): string[];
+    get id(): string;
+    get dataID(): string;
+    get variants(): string[];
+    get real_effectCount(): number;
+    get display_effectCount(): number;
+    get totalEffects(): Effect[];
+    get hasStatusEffect(): boolean;
+    get isDead(): boolean;
+    get display_atk(): number;
+    get display_hp(): number;
+    private getAllGhostEffects;
+    private throwPartitionConflict;
+    replacePartition(from_eidx: number, to_eidx: number, cardToCopyFrom: Card): res;
+    removePartition(pid: number): res;
+    private sanitizePartitionMapping;
+    insertPartition(partition: partitionData, newEffects?: Effect[]): res;
+    remapPartition(targetPartitionID: number, newMapping: number[]): void;
+    updatePartitionInfo(targetPartitionID: number, patchData: Partial<partitionData>): void;
+    getPartitionDisplayInputs(sys: dry_system, partitionIndex: number): (string | number)[];
+    getPartitionDisplayInputs(sys: dry_system): (string | number)[][];
+    isInSamePartition(eindex1: number, eindex2: number): boolean;
+    getAllPartitionsIDs(eindex: number): number[];
+    private inferPdata;
+    getAllDisplayEffects(): {
+        pid: number;
+        key: string;
+        type: string;
+        subtypes: string[];
+    }[];
+    isStatusPartition(pid: number): boolean;
+    protected pInputMap: Map<number, inputRequester<any, any, any, import("../../../data/systemRegistry").inputData_standard, unknown, unknown[] | import("../../../data/systemRegistry").inputData_standard[]>>;
+    getParititonInputObj(pid: number, s: dry_system, a: Action): inputRequester<any, any, any, any, any, any> | undefined;
+    getFirstActualPartitionIndex(): number;
+    pShareMemory: Map<number, Map<string, number>>;
+    activatePartition(pid: number, s: dry_system, a: Action, input?: any): Action[];
+    addShareMemory(e: Effect<any>, key: string, val: number): void;
+    /** @final */
+    toDry(): dry_card;
+    disableEffect(eid: string): void;
+    disable(): void;
+    enable(): void;
+    findEffectIndex(eid?: string): number;
+    getEffect(eid?: string): Effect | undefined;
+    getResponseIndexArr(system: dry_system, a: Action): number[];
+    reset(): Action[];
+    clearAllStatus(): void;
+    addStatusEffect(s: StatusEffect_base): void;
+    removeStatusEffect(id: string): void;
+    mergeStatusEffect(): void;
+    toString(spaces?: number, simplify?: boolean): string;
+    get numCounters(): number;
+    get hasCounter(): boolean;
+    is(c: id_able): boolean;
+    is(extension: string): boolean;
+    is(extensionArr: ReadonlyArray<string>): boolean;
+    isFrom(s: dry_system, z: zoneRegistry): boolean;
+}
+export default Card;