@gamepark/skyrift 0.1.0

package/dist/material/decks/heathblade/Nightguard.js

@@ -0,0 +1,22 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class NightguardRule extends CardRule {
+    getPowerIfNotStunned() {
+        const creatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        const myCreatures = creatures.player(this.player).length;
+        const opponentCreatures = creatures.player((p) => p !== this.player).length;
+        return super.getPowerIfNotStunned() + (opponentCreatures > myCreatures ? 3 : 0);
+    }
+}
+export const Nightguard = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: NightguardRule
+};

package/dist/material/decks/heathblade/OzmaTheMage.d.ts

@@ -0,0 +1,17 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class OzmaTheMageRule extends CardRule {
+    onCardEnters(card: Card, side: Deck): MaterialMove[];
+    onLeave(): MaterialMove[];
+}
+export declare const OzmaTheMage: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof OzmaTheMageRule;
+};
+export {};

package/dist/material/decks/heathblade/OzmaTheMage.js

@@ -0,0 +1,28 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class OzmaTheMageRule extends CardRule {
+    onCardEnters(card, side) {
+        if (side !== this.player && cardProperties[card].type === CardType.Action) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+    onLeave() {
+        const moves = this.removeStunTokens();
+        const powerTokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
+        if (powerTokens.getQuantity() > 0) {
+            moves.push(powerTokens.moveItem({ type: LocationType.PlayerStash, player: this.player }, powerTokens.getQuantity()));
+        }
+        return moves;
+    }
+}
+export const OzmaTheMage = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: OzmaTheMageRule
+};

package/dist/material/decks/heathblade/OzmaTheMageEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class OzmaTheMageEffectRule extends EffectRule {
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/heathblade/OzmaTheMageEffectRule.js

@@ -0,0 +1,20 @@
+import { EffectRule } from '../../../rules/EffectRule';
+import { Memory } from '../../../Memory';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class OzmaTheMageEffectRule extends EffectRule {
+    onRuleStart() {
+        const ozmaIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
+        return [
+            this.material(MaterialType.PowerToken)
+                .location(LocationType.PowerTokenStock)
+                .createItem({
+                location: {
+                    type: LocationType.CardPowerTokens,
+                    parent: ozmaIndex
+                }
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

package/dist/material/decks/heathblade/PrincessLitha.d.ts

@@ -0,0 +1,17 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+declare class PrincessLithaRule extends CardRule {
+    getPowerIfNotStunned(): number;
+    onWinRound(): MaterialMove[];
+}
+export declare const PrincessLitha: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof PrincessLithaRule;
+};
+export {};

package/dist/material/decks/heathblade/PrincessLitha.js

@@ -0,0 +1,28 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class PrincessLithaRule extends CardRule {
+    getPowerIfNotStunned() {
+        const otherCreaturesCount = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .length - 1;
+        return super.getPowerIfNotStunned() + otherCreaturesCount;
+    }
+    onWinRound() {
+        this.addPendingEffect();
+        return [];
+    }
+}
+export const PrincessLitha = {
+    power: 2,
+    type: CardType.Creature,
+    tag: CardTag.Knight,
+    suit: CardSuit.Day,
+    rule: PrincessLithaRule
+};

package/dist/material/decks/heathblade/PrincessLithaEffectRule.d.ts

@@ -0,0 +1,6 @@
+import { CustomMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class PrincessLithaEffectRule extends EffectRule {
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/heathblade/PrincessLithaEffectRule.js

@@ -0,0 +1,15 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+export class PrincessLithaEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return this.game.players.map((player) => this.customMove(CustomMoveType.ChoosePlayer, player));
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChoosePlayer) {
+            this.memorize(Memory.NextRoundStartPlayer, move.data);
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/material/decks/heathblade/RobbinsMasterOfArms.d.ts

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+declare class RobbinsMasterOfArmsRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const RobbinsMasterOfArms: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof RobbinsMasterOfArmsRule;
+};
+export {};

package/dist/material/decks/heathblade/RobbinsMasterOfArms.js

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+class RobbinsMasterOfArmsRule extends CardRule {
+    entersEffect = true;
+}
+export const RobbinsMasterOfArms = {
+    power: 3,
+    type: CardType.Creature,
+    tag: CardTag.Knight,
+    suit: CardSuit.Day,
+    rule: RobbinsMasterOfArmsRule
+};

package/dist/material/decks/heathblade/RobbinsMasterOfArmsEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class RobbinsMasterOfArmsEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+}

package/dist/material/decks/heathblade/RobbinsMasterOfArmsEffectRule.js

@@ -0,0 +1,29 @@
+import { Memory } from '../../../Memory';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { EffectRule } from '../../../rules/EffectRule';
+export class RobbinsMasterOfArmsEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = [];
+        const robbinsIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
+        const otherCreatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .getIndexes()
+            .filter(index => index !== robbinsIndex);
+        for (const creatureIndex of otherCreatures) {
+            moves.push(this.material(MaterialType.PowerToken)
+                .location(LocationType.PowerTokenStock)
+                .createItem({
+                location: {
+                    type: LocationType.CardPowerTokens,
+                    parent: creatureIndex
+                }
+            }));
+        }
+        return [...moves, ...this.endEffect()];
+    }
+}

package/dist/material/decks/heathblade/Sacrifice.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class SacrificeRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const Sacrifice: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof SacrificeRule;
+};
+export {};

package/dist/material/decks/heathblade/Sacrifice.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class SacrificeRule extends CardRule {
+    entersEffect = true;
+}
+export const Sacrifice = {
+    power: 4,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: SacrificeRule
+};

package/dist/material/decks/heathblade/SacrificeEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+export declare class SacrificeEffectRule extends DestroyEffectRule {
+    onRuleStart(): never[];
+    get isSacrificeStep(): boolean;
+    getPlayerMoves(): MaterialMove[];
+    getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onRuleEnd(): never[];
+}

package/dist/material/decks/heathblade/SacrificeEffectRule.js

@@ -0,0 +1,48 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SacrificeEffectRule extends DestroyEffectRule {
+    onRuleStart() {
+        this.memorize(Memory.EffectCount, 0);
+        return [];
+    }
+    get isSacrificeStep() {
+        return this.remind(Memory.EffectCount) === 0;
+    }
+    getPlayerMoves() {
+        const moves = super.getPlayerMoves();
+        if (this.isSacrificeStep) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    getTargets() {
+        const creatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        if (this.isSacrificeStep) {
+            return creatures.player(this.player);
+        }
+        else {
+            return creatures;
+        }
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            const count = this.memorize(Memory.EffectCount, (count) => count + 1);
+            if (count > 1 || this.getTargets().length === 0) {
+                return this.endEffect();
+            }
+        }
+        return [];
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

package/dist/material/decks/heathblade/Shadowbolt.d.ts

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { ArcherRule } from './ArcherRule';
+declare class ShadowboltRule extends ArcherRule {
+    powerBonus: number;
+}
+export declare const Shadowbolt: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof ShadowboltRule;
+};
+export {};

package/dist/material/decks/heathblade/Shadowbolt.js

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { ArcherRule } from './ArcherRule';
+class ShadowboltRule extends ArcherRule {
+    powerBonus = 3;
+}
+export const Shadowbolt = {
+    power: 2,
+    type: CardType.Creature,
+    tag: CardTag.Archer,
+    suit: CardSuit.Night,
+    rule: ShadowboltRule
+};

package/dist/material/decks/heathblade/SoulBlade.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class SoulBladeRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const SoulBlade: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof SoulBladeRule;
+};
+export {};

package/dist/material/decks/heathblade/SoulBlade.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class SoulBladeRule extends CardRule {
+    entersEffect = true;
+}
+export const SoulBlade = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: SoulBladeRule
+};

package/dist/material/decks/heathblade/SoulBladeEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { Material } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+export declare class SoulBladeEffectRule extends DestroyEffectRule {
+    getTargets(): Material;
+}

package/dist/material/decks/heathblade/SoulBladeEffectRule.js

@@ -0,0 +1,15 @@
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SoulBladeEffectRule extends DestroyEffectRule {
+    getTargets() {
+        const helper = new PlayerHelper(this.game);
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .index((index) => helper.getCardRule(index).getPower() <= 4);
+    }
+}

package/dist/material/decks/heathblade/WatchTower.d.ts

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class WatchTowerRule extends CardRule {
+    challenge: boolean;
+    onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
+}
+export declare const WatchTower: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof WatchTowerRule;
+};
+export {};

package/dist/material/decks/heathblade/WatchTower.js

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class WatchTowerRule extends CardRule {
+    challenge = true;
+    onChallengeAccepted() {
+        this.addPendingEffect();
+        return super.onChallengeAccepted();
+    }
+}
+export const WatchTower = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: WatchTowerRule
+};

package/dist/material/decks/heathblade/WatchTowerEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+export declare class WatchTowerEffectRule extends DrawEffectRule {
+    getDrawCount(): number;
+}

package/dist/material/decks/heathblade/WatchTowerEffectRule.js

@@ -0,0 +1,13 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class WatchTowerEffectRule extends DrawEffectRule {
+    getDrawCount() {
+        const creatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        return creatures.length - 2 * creatures.player(this.player).length;
+    }
+}

package/dist/material/decks/heathblade/WoodSlinger.d.ts

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { ArcherRule } from './ArcherRule';
+declare class WoodSlingerRule extends ArcherRule {
+    powerBonus: number;
+}
+export declare const WoodSlinger: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof WoodSlingerRule;
+};
+export {};

package/dist/material/decks/heathblade/WoodSlinger.js

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { ArcherRule } from './ArcherRule';
+class WoodSlingerRule extends ArcherRule {
+    powerBonus = 2;
+}
+export const WoodSlinger = {
+    power: 2,
+    type: CardType.Creature,
+    tag: CardTag.Archer,
+    suit: CardSuit.Twilight,
+    rule: WoodSlingerRule
+};

package/dist/material/decks/highwave/AeliaSteadyHand.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class AeliaSteadyHandRule extends CardRule {
+    oncePerTurnEffect: boolean;
+}
+export declare const AeliaSteadyHand: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof AeliaSteadyHandRule;
+};
+export {};

package/dist/material/decks/highwave/AeliaSteadyHand.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AeliaSteadyHandRule extends CardRule {
+    oncePerTurnEffect = true;
+}
+export const AeliaSteadyHand = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: AeliaSteadyHandRule
+};

package/dist/material/decks/highwave/BoardingParty.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class BoardingPartyRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const BoardingParty: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof BoardingPartyRule;
+};
+export {};

package/dist/material/decks/highwave/BoardingParty.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class BoardingPartyRule extends CardRule {
+    entersEffect = true;
+}
+export const BoardingParty = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: BoardingPartyRule
+};

package/dist/material/decks/highwave/BoardingPartyEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { CustomMove, ItemMove } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+export declare class BoardingPartyEffectRule extends DestroyEffectRule {
+    onRuleStart(): never[];
+    get isBoardingPlayer(): boolean;
+    getPlayerMoves(): import("@gamepark/rules-api").MaterialMove[];
+    getTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/highwave/BoardingPartyEffectRule.js

@@ -0,0 +1,59 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class BoardingPartyEffectRule extends DestroyEffectRule {
+    onRuleStart() {
+        if (this.isBoardingPlayer) {
+            this.memorize(Memory.EffectCount, 0);
+        }
+        return [];
+    }
+    get isBoardingPlayer() {
+        return this.remind(Memory.CurrentPlayer) === this.player;
+    }
+    getPlayerMoves() {
+        const moves = super.getPlayerMoves();
+        if (this.isBoardingPlayer) {
+            moves.push(this.customMove(CustomMoveType.Pass));
+        }
+        return moves;
+    }
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .player(this.player);
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            if (this.isBoardingPlayer) {
+                this.memorize(Memory.EffectCount, (count) => count + 1);
+            }
+            else {
+                const count = this.memorize(Memory.EffectCount, (count) => count - 1);
+                if (!count || !this.getTargets().length) {
+                    this.forget(Memory.EffectCount);
+                    return this.endEffect();
+                }
+            }
+        }
+        return [];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.Pass) {
+            if (this.remind(Memory.EffectCount)) {
+                return [this.startPlayerTurn(RuleId.BoardingPartyEffect, this.nextPlayer)];
+            }
+            else {
+                return this.endEffect();
+            }
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/material/decks/highwave/BrassDragon.d.ts

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+declare class BrassDragonRule extends CannonCardRule {
+    challenge: boolean;
+}
+export declare const BrassDragon: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof BrassDragonRule;
+};
+export {};