@gamepark/skyrift 0.1.0

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

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+class BrassDragonRule extends CannonCardRule {
+    challenge = true;
+}
+export const BrassDragon = {
+    power: 5,
+    type: CardType.Action,
+    tag: CardTag.Cannon,
+    suit: CardSuit.Day,
+    rule: BrassDragonRule
+};

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

@@ -0,0 +1,4 @@
+import { CardRule } from '../../CardRule';
+export declare abstract class CannonCardRule extends CardRule {
+    canBePlayed(): boolean;
+}

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

@@ -0,0 +1,19 @@
+import { Memory } from '../../../Memory';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardTag } from '../../CardTag';
+import { MaterialType } from '../../MaterialType';
+export class CannonCardRule extends CardRule {
+    canBePlayed() {
+        const hasMistyGunner = new PlayerHelper(this.game, this.player).cardRules.some((rule) => rule.hasPermanentEffectOnTag(CardTag.Cannon));
+        if (hasMistyGunner) {
+            return true;
+        }
+        const hasPlayedCannon = this.remind(Memory.CardsPlayed, this.player).some((cardIndex) => cardProperties[this.material(MaterialType.Card).getItem(cardIndex).id.front].tag === CardTag.Cannon);
+        if (hasPlayedCannon) {
+            return false;
+        }
+        return super.canBePlayed();
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+class DarkBlazerRule extends CannonCardRule {
+    entersEffect = true;
+}
+export const DarkBlazer = {
+    power: 3,
+    type: CardType.Action,
+    tag: CardTag.Cannon,
+    suit: CardSuit.Night,
+    rule: DarkBlazerRule
+};

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

@@ -0,0 +1,4 @@
+import { StunCardRule } from '../../../rules/StunCardRule';
+export declare class DarkBlazerEffectRule extends StunCardRule {
+    stunCount: number;
+}

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

@@ -0,0 +1,4 @@
+import { StunCardRule } from '../../../rules/StunCardRule';
+export class DarkBlazerEffectRule extends StunCardRule {
+    stunCount = 3;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+class DawnsDoomRule extends CannonCardRule {
+    entersEffect = true;
+}
+export const DawnsDoom = {
+    power: 4,
+    type: CardType.Action,
+    tag: CardTag.Cannon,
+    suit: CardSuit.Twilight,
+    rule: DawnsDoomRule
+};

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

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

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

@@ -0,0 +1,14 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class DawnsDoomEffectRule extends DrawEffectRule {
+    getDrawCount() {
+        const onlyTwilightCards = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .getItems()
+            .every((item) => cardProperties[item.id.front].suit === CardSuit.Twilight);
+        return onlyTwilightCards ? 1 : 0;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class LongJawsSilverRule extends CardRule {
+    challenge: boolean;
+    onWinRound(): MaterialMove[];
+}
+export declare const LongJawsSilver: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof LongJawsSilverRule;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { Memory } from '../../../Memory';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class LongJawsSilverRule extends CardRule {
+    challenge = true;
+    onWinRound() {
+        if (this.remind(Memory.CurrentPlayer) !== this.player) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+}
+export const LongJawsSilver = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: LongJawsSilverRule
+};

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

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+declare class MistyGunnerRule extends CardRule {
+    permanentEffectTag: CardTag;
+}
+export declare const MistyGunner: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof MistyGunnerRule;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+class MistyGunnerRule extends CardRule {
+    permanentEffectTag = CardTag.Cannon;
+}
+export const MistyGunner = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: MistyGunnerRule
+};

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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class OttoPouchyEffectRule extends DrawEffectRule {
+    getDrawCount() {
+        const cardsInHands = this.material(MaterialType.Card).location(LocationType.PlayerHand);
+        return cardsInHands.player(this.nextPlayer).length - cardsInHands.player(this.player).length;
+    }
+}

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

@@ -0,0 +1,16 @@
+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 PowderMonkeyRule extends CardRule {
+    onCardEnters(card: Card, side: Deck): MaterialMove[];
+}
+export declare const PowderMonkey: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof PowderMonkeyRule;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+class PowderMonkeyRule extends CardRule {
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].tag === CardTag.Cannon) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+}
+export const PowderMonkey = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: PowderMonkeyRule
+};

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

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

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

@@ -0,0 +1,13 @@
+import { ReturnCardRule } from '../../../rules/ReturnCardRule';
+import { cardProperties } from '../../CardProperties';
+import { CardTag } from '../../CardTag';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class PowderMonkeyEffectRule extends ReturnCardRule {
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerDiscard)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].tag === CardTag.Cannon);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class RicoSkeyeRule extends CardRule {
+    onPlayerTurnStart(player: Deck): MaterialMove[];
+    startEffect(): import("@gamepark/rules-api").StartPlayerTurn<number, import("../../Card").Card>[];
+}
+export declare const RicoSkeye: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof RicoSkeyeRule;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class RicoSkeyeRule extends CardRule {
+    onPlayerTurnStart(player) {
+        if (player !== this.player) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+    startEffect() {
+        return [this.startPlayerTurn(this.card, this.opponent)];
+    }
+}
+export const RicoSkeye = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: RicoSkeyeRule
+};

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

@@ -0,0 +1,7 @@
+import { CustomMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
+export declare class RicoSkeyeEffectRule extends DiscardEffectRule {
+    getPlayerMoves(): MaterialMove[];
+    onDiscard(move: MoveItem): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+}

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

@@ -0,0 +1,21 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
+import { RuleId } from '../../../rules/RuleId';
+export class RicoSkeyeEffectRule extends DiscardEffectRule {
+    getPlayerMoves() {
+        return [...super.getPlayerMoves(), this.customMove(CustomMoveType.ConcedeRound)];
+    }
+    onDiscard(move) {
+        this.memorize(Memory.CardsPlayed, (cards) => [...cards, move.itemIndex], this.player);
+        return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: 1 }), ...this.endEffect()];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ConcedeRound) {
+            return [this.customMove(CustomMoveType.EndEffect), this.startRule(RuleId.EndRound)];
+        }
+        else {
+            return super.onCustomMove(move);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class SaltyDogRule extends CardRule {
+    entersEffect = true;
+}
+export const SaltyDog = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: SaltyDogRule
+};

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

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

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

@@ -0,0 +1,26 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SaltyDogEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = this.endEffect();
+        const cardsPlayed = this.remind(Memory.CardsPlayed, this.nextPlayer);
+        if (cardsPlayed.length > 0) {
+            const cardIndex = cardsPlayed[cardsPlayed.length - 1];
+            const card = this.material(MaterialType.Card).getItem(cardIndex);
+            if (card.location.type === LocationType.PlayArea && cardProperties[card.id.front].type === CardType.Creature) {
+                moves.unshift(this.material(MaterialType.StunToken).createItem({
+                    location: {
+                        type: LocationType.CardStunTokens,
+                        parent: cardIndex
+                    },
+                    quantity: 2
+                }));
+            }
+        }
+        return moves;
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class ScallywagEffectRule extends DestroyEffectRule {
+    getTargets() {
+        const helper = new PlayerHelper(this.game);
+        const scallywagPower = this.cardRule.getPower();
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .index((index) => helper.getCardRule(index).getPower() < scallywagPower);
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { PutPowerTokenEffectRule } from '../../../rules/PutPowerTokenEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SkupperEffectRule extends PutPowerTokenEffectRule {
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class TreasureMapRule extends CardRule {
+    onWinRound() {
+        this.addPendingEffect();
+        return [];
+    }
+}
+export const TreasureMap = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: TreasureMapRule
+};

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

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