type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
export declare interface KtList<E> /* extends Collection<E> */ {
    asJsReadonlyArrayView(): ReadonlyArray<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtList": unique symbol;
    };
}
export declare abstract class KtList<E> extends KtSingleton<KtList.$metadata$.constructor>() {
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtList.$metadata$ {
    abstract class constructor {
        fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
        private constructor();
    }
}
/** @deprecated  */
export declare const initHook: { get(): any; };
export declare abstract class PokeApi {
    getPokeathlonStatListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokeathlonStat>>;
    getPokemonFormListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonForm>>;
    getMoveTargetAsync(id: number): Promise<MoveTarget>;
    getGenderListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Gender>>;
    getPokemonSpeciesListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonSpecies>>;
    getVersionGroupListAsync(offset: number, limit: number): Promise<PaginatedList.Named<VersionGroup>>;
    getNatureAsync(id: number): Promise<Nature>;
    getContestTypeAsync(id: number): Promise<ContestType>;
    getPokemonHabitatAsync(id: number): Promise<PokemonHabitat>;
    getEncounterConditionValueListAsync(offset: number, limit: number): Promise<PaginatedList.Named<EncounterConditionValue>>;
    getEvolutionChainListAsync(offset: number, limit: number): Promise<PaginatedList.Unnamed<EvolutionChain>>;
    getEggGroupListAsync(offset: number, limit: number): Promise<PaginatedList.Named<EggGroup>>;
    getGrowthRateAsync(id: number): Promise<GrowthRate>;
    getContestTypeListAsync(offset: number, limit: number): Promise<PaginatedList.Named<ContestType>>;
    getMoveLearnMethodAsync(id: number): Promise<MoveLearnMethod>;
    getEggGroupAsync(id: number): Promise<EggGroup>;
    getGrowthRateListAsync(offset: number, limit: number): Promise<PaginatedList.Named<GrowthRate>>;
    getAbilityAsync(id: number): Promise<Ability>;
    getItemPocketListAsync(offset: number, limit: number): Promise<PaginatedList.Named<ItemPocket>>;
    getMoveListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Move>>;
    getSuperContestEffectListAsync(offset: number, limit: number): Promise<PaginatedList.Unnamed<SuperContestEffect>>;
    getLocationAreaAsync(id: number): Promise<LocationArea>;
    getEncounterConditionValueAsync(id: number): Promise<EncounterConditionValue>;
    getStatAsync(id: number): Promise<Stat>;
    getPokemonHabitatListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonHabitat>>;
    getEncounterMethodListAsync(offset: number, limit: number): Promise<PaginatedList.Named<EncounterMethod>>;
    getAbilityListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Ability>>;
    getVersionGroupAsync(id: number): Promise<VersionGroup>;
    getCharacteristicListAsync(offset: number, limit: number): Promise<PaginatedList.Unnamed<Characteristic>>;
    getPokedexListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Pokedex>>;
    getPokemonColorAsync(id: number): Promise<PokemonColor>;
    getContestEffectListAsync(offset: number, limit: number): Promise<PaginatedList.Unnamed<ContestEffect>>;
    getItemAsync(id: number): Promise<Item>;
    getEncounterConditionListAsync(offset: number, limit: number): Promise<PaginatedList.Named<EncounterCondition>>;
    getGenderAsync(id: number): Promise<Gender>;
    getEvolutionTriggerListAsync(offset: number, limit: number): Promise<PaginatedList.Named<EvolutionTrigger>>;
    getRegionAsync(id: number): Promise<Region>;
    getMoveAsync(id: number): Promise<Move>;
    getTypeAsync(id: number): Promise<Type>;
    getPokemonSpeciesAsync(id: number): Promise<PokemonSpecies>;
    getMoveDamageClassListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveDamageClass>>;
    getCharacteristicAsync(id: number): Promise<Characteristic>;
    getPokemonVarietyAsync(id: number): Promise<PokemonVariety>;
    getLanguageListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Language>>;
    getEncounterMethodAsync(id: number): Promise<EncounterMethod>;
    getItemAttributeAsync(id: number): Promise<ItemAttribute>;
    getEncounterConditionAsync(id: number): Promise<EncounterCondition>;
    getPokeathlonStatAsync(id: number): Promise<PokeathlonStat>;
    getItemAttributeListAsync(offset: number, limit: number): Promise<PaginatedList.Named<ItemAttribute>>;
    getMoveAilmentListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveAilment>>;
    getPokemonVarietyListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonVariety>>;
    getPokemonShapeAsync(id: number): Promise<PokemonShape>;
    getLocationAreaListAsync(offset: number, limit: number): Promise<PaginatedList.Named<LocationArea>>;
    getEvolutionChainAsync(id: number): Promise<EvolutionChain>;
    getVersionAsync(id: number): Promise<Version>;
    getNatureListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Nature>>;
    getGenerationAsync(id: number): Promise<Generation>;
    getPokemonEncounterListAsync(id: number): Promise<KtList<LocationAreaEncounter>>;
    getMachineAsync(id: number): Promise<Machine>;
    getItemListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Item>>;
    getMoveDamageClassAsync(id: number): Promise<MoveDamageClass>;
    getItemFlingEffectListAsync(offset: number, limit: number): Promise<PaginatedList.Named<ItemFlingEffect>>;
    getMoveCategoryListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveCategory>>;
    getGenerationListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Generation>>;
    getRegionListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Region>>;
    getLocationListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Location>>;
    getVersionListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Version>>;
    getLocationAsync(id: number): Promise<Location>;
    getMoveTargetListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveTarget>>;
    getMoveBattleStyleListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveBattleStyle>>;
    getBerryFlavorListAsync(offset: number, limit: number): Promise<PaginatedList.Named<BerryFlavor>>;
    getBerryFirmnessAsync(id: number): Promise<BerryFirmness>;
    getMoveBattleStyleAsync(id: number): Promise<MoveBattleStyle>;
    getEvolutionTriggerAsync(id: number): Promise<EvolutionTrigger>;
    getAsync<T extends Model>(_this_: Handle<T>): Promise<T>;
    getItemPocketAsync(id: number): Promise<ItemPocket>;
    getPokemonColorListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonColor>>;
    getTypeListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Type>>;
    getItemCategoryAsync(id: number): Promise<ItemCategory>;
    getSuperContestEffectAsync(id: number): Promise<SuperContestEffect>;
    getItemFlingEffectAsync(id: number): Promise<ItemFlingEffect>;
    getPalParkAreaListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PalParkArea>>;
    getMoveLearnMethodListAsync(offset: number, limit: number): Promise<PaginatedList.Named<MoveLearnMethod>>;
    getBerryAsync(id: number): Promise<Berry>;
    getMoveAilmentAsync(id: number): Promise<MoveAilment>;
    getMoveCategoryAsync(id: number): Promise<MoveCategory>;
    getItemCategoryListAsync(offset: number, limit: number): Promise<PaginatedList.Named<ItemCategory>>;
    getMachineListAsync(offset: number, limit: number): Promise<PaginatedList.Unnamed<Machine>>;
    getContestEffectAsync(id: number): Promise<ContestEffect>;
    getPalParkAreaAsync(id: number): Promise<PalParkArea>;
    getPokedexAsync(id: number): Promise<Pokedex>;
    getPokemonFormAsync(id: number): Promise<PokemonForm>;
    getStatListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Stat>>;
    getBerryFirmnessListAsync(offset: number, limit: number): Promise<PaginatedList.Named<BerryFirmness>>;
    getBerryListAsync(offset: number, limit: number): Promise<PaginatedList.Named<Berry>>;
    getPokemonShapeListAsync(offset: number, limit: number): Promise<PaginatedList.Named<PokemonShape>>;
    getLanguageAsync(id: number): Promise<Language>;
    getBerryFlavorAsync(id: number): Promise<BerryFlavor>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokeApi.$metadata$ {
    const constructor: abstract new () => PokeApi;
}
export declare namespace PokeApi {
    class Custom extends PokeApi.$metadata$.constructor {
        private constructor();
        static create(baseUrl?: string): PokeApi.Custom;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Custom.$metadata$ {
        const constructor: abstract new () => Custom;
    }
    abstract class Default extends KtSingleton<Default.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Default.$metadata$ {
        abstract class constructor extends PokeApi.$metadata$.constructor {
            private constructor();
        }
    }
}
export declare interface Model {
    readonly id: number;
    readonly __doNotUseOrImplementIt: {
        readonly "co.pokeapi.pokekotlin.model.Model": unique symbol;
    };
}
export declare abstract class Model extends KtSingleton<Model.$metadata$.constructor>() {
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Model.$metadata$ {
    abstract class constructor /* implements SerializerFactory */ {
        private constructor();
    }
}
export declare interface NamedModel extends Model {
    readonly name: string;
    readonly __doNotUseOrImplementIt: {
        readonly "co.pokeapi.pokekotlin.model.NamedModel": unique symbol;
    } & Model["__doNotUseOrImplementIt"];
}
export declare abstract class NamedModel extends KtSingleton<NamedModel.$metadata$.constructor>() {
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NamedModel.$metadata$ {
    abstract class constructor /* implements SerializerFactory */ {
        private constructor();
    }
}
export declare class Berry implements NamedModel {
    constructor(id: number, name: string, growthTime: number, maxHarvest: number, naturalGiftPower: number, size: number, smoothness: number, soilDryness: number, firmness: Handle.Named<BerryFirmness>, flavors: KtList<BerryFlavorMap>, item: Handle.Named<Item>, naturalGiftType: Handle.Named<Type>);
    get id(): number;
    get name(): string;
    get growthTime(): number;
    get maxHarvest(): number;
    get naturalGiftPower(): number;
    get size(): number;
    get smoothness(): number;
    get soilDryness(): number;
    get firmness(): Handle.Named<BerryFirmness>;
    get flavors(): KtList<BerryFlavorMap>;
    get item(): Handle.Named<Item>;
    get naturalGiftType(): Handle.Named<Type>;
    copy(id?: number, name?: string, growthTime?: number, maxHarvest?: number, naturalGiftPower?: number, size?: number, smoothness?: number, soilDryness?: number, firmness?: Handle.Named<BerryFirmness>, flavors?: KtList<BerryFlavorMap>, item?: Handle.Named<Item>, naturalGiftType?: Handle.Named<Type>): Berry;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Berry.$metadata$ {
    const constructor: abstract new () => Berry;
}
export declare namespace Berry {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class BerryFlavorMap {
    constructor(potency: number, flavor: Handle.Named<BerryFlavor>);
    get potency(): number;
    get flavor(): Handle.Named<BerryFlavor>;
    copy(potency?: number, flavor?: Handle.Named<BerryFlavor>): BerryFlavorMap;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BerryFlavorMap.$metadata$ {
    const constructor: abstract new () => BerryFlavorMap;
}
export declare namespace BerryFlavorMap {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class BerryFirmness implements NamedModel {
    constructor(id: number, name: string, berries: KtList<Handle.Named<Berry>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get berries(): KtList<Handle.Named<Berry>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, berries?: KtList<Handle.Named<Berry>>, names?: KtList<Name>): BerryFirmness;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BerryFirmness.$metadata$ {
    const constructor: abstract new () => BerryFirmness;
}
export declare namespace BerryFirmness {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class BerryFlavor implements NamedModel {
    constructor(id: number, name: string, berries: KtList<FlavorBerryMap>, contestType: Handle.Named<ContestType>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get berries(): KtList<FlavorBerryMap>;
    get contestType(): Handle.Named<ContestType>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, berries?: KtList<FlavorBerryMap>, contestType?: Handle.Named<ContestType>, names?: KtList<Name>): BerryFlavor;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BerryFlavor.$metadata$ {
    const constructor: abstract new () => BerryFlavor;
}
export declare namespace BerryFlavor {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class FlavorBerryMap {
    constructor(potency: number, berry: Handle.Named<Berry>);
    get potency(): number;
    get berry(): Handle.Named<Berry>;
    copy(potency?: number, berry?: Handle.Named<Berry>): FlavorBerryMap;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FlavorBerryMap.$metadata$ {
    const constructor: abstract new () => FlavorBerryMap;
}
export declare namespace FlavorBerryMap {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ContestType implements NamedModel {
    constructor(id: number, name: string, berryFlavor: Handle.Named<BerryFlavor>, names: KtList<ContestName>);
    get id(): number;
    get name(): string;
    get berryFlavor(): Handle.Named<BerryFlavor>;
    get names(): KtList<ContestName>;
    copy(id?: number, name?: string, berryFlavor?: Handle.Named<BerryFlavor>, names?: KtList<ContestName>): ContestType;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContestType.$metadata$ {
    const constructor: abstract new () => ContestType;
}
export declare namespace ContestType {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ContestName {
    constructor(name: string, color: string, language: Handle.Named<Language>);
    get name(): string;
    get color(): string;
    get language(): Handle.Named<Language>;
    copy(name?: string, color?: string, language?: Handle.Named<Language>): ContestName;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContestName.$metadata$ {
    const constructor: abstract new () => ContestName;
}
export declare namespace ContestName {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ContestEffect implements Model {
    constructor(id: number, appeal: number, jam: number, effectEntries: KtList<Effect>, flavorTextEntries: KtList<FlavorText>);
    get id(): number;
    get appeal(): number;
    get jam(): number;
    get effectEntries(): KtList<Effect>;
    get flavorTextEntries(): KtList<FlavorText>;
    copy(id?: number, appeal?: number, jam?: number, effectEntries?: KtList<Effect>, flavorTextEntries?: KtList<FlavorText>): ContestEffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Model["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContestEffect.$metadata$ {
    const constructor: abstract new () => ContestEffect;
}
export declare namespace ContestEffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class SuperContestEffect implements Model {
    constructor(id: number, appeal: number, flavorTextEntries: KtList<FlavorText>, moves: KtList<Handle.Named<Move>>);
    get id(): number;
    get appeal(): number;
    get flavorTextEntries(): KtList<FlavorText>;
    get moves(): KtList<Handle.Named<Move>>;
    copy(id?: number, appeal?: number, flavorTextEntries?: KtList<FlavorText>, moves?: KtList<Handle.Named<Move>>): SuperContestEffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Model["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SuperContestEffect.$metadata$ {
    const constructor: abstract new () => SuperContestEffect;
}
export declare namespace SuperContestEffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EncounterMethod implements NamedModel {
    constructor(id: number, name: string, order: number, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get order(): number;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, order?: number, names?: KtList<Name>): EncounterMethod;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EncounterMethod.$metadata$ {
    const constructor: abstract new () => EncounterMethod;
}
export declare namespace EncounterMethod {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EncounterCondition implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, values: KtList<Handle.Named<EncounterConditionValue>>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get values(): KtList<Handle.Named<EncounterConditionValue>>;
    copy(id?: number, name?: string, names?: KtList<Name>, values?: KtList<Handle.Named<EncounterConditionValue>>): EncounterCondition;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EncounterCondition.$metadata$ {
    const constructor: abstract new () => EncounterCondition;
}
export declare namespace EncounterCondition {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EncounterConditionValue implements NamedModel {
    constructor(id: number, name: string, condition: Handle.Named<EncounterCondition>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get condition(): Handle.Named<EncounterCondition>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, condition?: Handle.Named<EncounterCondition>, names?: KtList<Name>): EncounterConditionValue;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EncounterConditionValue.$metadata$ {
    const constructor: abstract new () => EncounterConditionValue;
}
export declare namespace EncounterConditionValue {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EvolutionChain implements Model {
    constructor(id: number, babyTriggerItem: Nullable<Handle.Named<Item>>, chain: ChainLink);
    get id(): number;
    get babyTriggerItem(): Nullable<Handle.Named<Item>>;
    get chain(): ChainLink;
    copy(id?: number, babyTriggerItem?: Nullable<Handle.Named<Item>>, chain?: ChainLink): EvolutionChain;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Model["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EvolutionChain.$metadata$ {
    const constructor: abstract new () => EvolutionChain;
}
export declare namespace EvolutionChain {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ChainLink {
    constructor(isBaby: boolean, species: Handle.Named<PokemonSpecies>, evolutionDetails: KtList<EvolutionDetail>, evolvesTo: KtList<ChainLink>);
    get isBaby(): boolean;
    get species(): Handle.Named<PokemonSpecies>;
    get evolutionDetails(): KtList<EvolutionDetail>;
    get evolvesTo(): KtList<ChainLink>;
    copy(isBaby?: boolean, species?: Handle.Named<PokemonSpecies>, evolutionDetails?: KtList<EvolutionDetail>, evolvesTo?: KtList<ChainLink>): ChainLink;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChainLink.$metadata$ {
    const constructor: abstract new () => ChainLink;
}
export declare namespace ChainLink {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EvolutionDetail {
    constructor(trigger: Handle.Named<EvolutionTrigger>, item?: Nullable<Handle.Named<Item>>, gender?: Nullable<number>, heldItem?: Nullable<Handle.Named<Item>>, knownMove?: Nullable<Handle.Named<Move>>, knownMoveType?: Nullable<Handle.Named<Type>>, location?: Nullable<Handle.Named<Location>>, minLevel?: Nullable<number>, minHappiness?: Nullable<number>, minBeauty?: Nullable<number>, minAffection?: Nullable<number>, partySpecies?: Nullable<Handle.Named<PokemonSpecies>>, partyType?: Nullable<Handle.Named<Type>>, relativePhysicalStats?: Nullable<number>, timeOfDay?: string, tradeSpecies?: Nullable<Handle.Named<PokemonSpecies>>, needsOverworldRain?: boolean, turnUpsideDown?: boolean);
    get trigger(): Handle.Named<EvolutionTrigger>;
    get item(): Nullable<Handle.Named<Item>>;
    get gender(): Nullable<number>;
    get heldItem(): Nullable<Handle.Named<Item>>;
    get knownMove(): Nullable<Handle.Named<Move>>;
    get knownMoveType(): Nullable<Handle.Named<Type>>;
    get location(): Nullable<Handle.Named<Location>>;
    get minLevel(): Nullable<number>;
    get minHappiness(): Nullable<number>;
    get minBeauty(): Nullable<number>;
    get minAffection(): Nullable<number>;
    get partySpecies(): Nullable<Handle.Named<PokemonSpecies>>;
    get partyType(): Nullable<Handle.Named<Type>>;
    get relativePhysicalStats(): Nullable<number>;
    get timeOfDay(): string;
    get tradeSpecies(): Nullable<Handle.Named<PokemonSpecies>>;
    get needsOverworldRain(): boolean;
    get turnUpsideDown(): boolean;
    copy(trigger?: Handle.Named<EvolutionTrigger>, item?: Nullable<Handle.Named<Item>>, gender?: Nullable<number>, heldItem?: Nullable<Handle.Named<Item>>, knownMove?: Nullable<Handle.Named<Move>>, knownMoveType?: Nullable<Handle.Named<Type>>, location?: Nullable<Handle.Named<Location>>, minLevel?: Nullable<number>, minHappiness?: Nullable<number>, minBeauty?: Nullable<number>, minAffection?: Nullable<number>, partySpecies?: Nullable<Handle.Named<PokemonSpecies>>, partyType?: Nullable<Handle.Named<Type>>, relativePhysicalStats?: Nullable<number>, timeOfDay?: string, tradeSpecies?: Nullable<Handle.Named<PokemonSpecies>>, needsOverworldRain?: boolean, turnUpsideDown?: boolean): EvolutionDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EvolutionDetail.$metadata$ {
    const constructor: abstract new () => EvolutionDetail;
}
export declare namespace EvolutionDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EvolutionTrigger implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, names?: KtList<Name>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): EvolutionTrigger;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EvolutionTrigger.$metadata$ {
    const constructor: abstract new () => EvolutionTrigger;
}
export declare namespace EvolutionTrigger {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Generation implements NamedModel {
    constructor(id: number, name: string, abilities: KtList<Handle.Named<Ability>>, names: KtList<Name>, mainRegion: Handle.Named<Region>, moves: KtList<Handle.Named<Move>>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>, types: KtList<Handle.Named<Type>>, versionGroups: KtList<Handle.Named<VersionGroup>>);
    get id(): number;
    get name(): string;
    get abilities(): KtList<Handle.Named<Ability>>;
    get names(): KtList<Name>;
    get mainRegion(): Handle.Named<Region>;
    get moves(): KtList<Handle.Named<Move>>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    get types(): KtList<Handle.Named<Type>>;
    get versionGroups(): KtList<Handle.Named<VersionGroup>>;
    copy(id?: number, name?: string, abilities?: KtList<Handle.Named<Ability>>, names?: KtList<Name>, mainRegion?: Handle.Named<Region>, moves?: KtList<Handle.Named<Move>>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>, types?: KtList<Handle.Named<Type>>, versionGroups?: KtList<Handle.Named<VersionGroup>>): Generation;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Generation.$metadata$ {
    const constructor: abstract new () => Generation;
}
export declare namespace Generation {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Pokedex implements NamedModel {
    constructor(id: number, name: string, isMainSeries: boolean, descriptions: KtList<Description>, names: KtList<Name>, pokemonEntries: KtList<PokemonEntry>, region: Nullable<Handle.Named<Region>>, versionGroups: KtList<Handle.Named<VersionGroup>>);
    get id(): number;
    get name(): string;
    get isMainSeries(): boolean;
    get descriptions(): KtList<Description>;
    get names(): KtList<Name>;
    get pokemonEntries(): KtList<PokemonEntry>;
    get region(): Nullable<Handle.Named<Region>>;
    get versionGroups(): KtList<Handle.Named<VersionGroup>>;
    copy(id?: number, name?: string, isMainSeries?: boolean, descriptions?: KtList<Description>, names?: KtList<Name>, pokemonEntries?: KtList<PokemonEntry>, region?: Nullable<Handle.Named<Region>>, versionGroups?: KtList<Handle.Named<VersionGroup>>): Pokedex;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Pokedex.$metadata$ {
    const constructor: abstract new () => Pokedex;
}
export declare namespace Pokedex {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonEntry {
    constructor(entryNumber: number, pokemonSpecies: Handle.Named<PokemonSpecies>);
    get entryNumber(): number;
    get pokemonSpecies(): Handle.Named<PokemonSpecies>;
    copy(entryNumber?: number, pokemonSpecies?: Handle.Named<PokemonSpecies>): PokemonEntry;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonEntry.$metadata$ {
    const constructor: abstract new () => PokemonEntry;
}
export declare namespace PokemonEntry {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Version implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, versionGroup: Handle.Named<VersionGroup>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(id?: number, name?: string, names?: KtList<Name>, versionGroup?: Handle.Named<VersionGroup>): Version;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Version.$metadata$ {
    const constructor: abstract new () => Version;
}
export declare namespace Version {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionGroup implements NamedModel {
    constructor(id: number, name: string, order: number, generation: Handle.Named<Generation>, moveLearnMethods: KtList<Handle.Named<MoveLearnMethod>>, pokedexes: KtList<Handle.Named<Pokedex>>, regions: KtList<Handle.Named<Region>>, versions: KtList<Handle.Named<Version>>);
    get id(): number;
    get name(): string;
    get order(): number;
    get generation(): Handle.Named<Generation>;
    get moveLearnMethods(): KtList<Handle.Named<MoveLearnMethod>>;
    get pokedexes(): KtList<Handle.Named<Pokedex>>;
    get regions(): KtList<Handle.Named<Region>>;
    get versions(): KtList<Handle.Named<Version>>;
    copy(id?: number, name?: string, order?: number, generation?: Handle.Named<Generation>, moveLearnMethods?: KtList<Handle.Named<MoveLearnMethod>>, pokedexes?: KtList<Handle.Named<Pokedex>>, regions?: KtList<Handle.Named<Region>>, versions?: KtList<Handle.Named<Version>>): VersionGroup;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionGroup.$metadata$ {
    const constructor: abstract new () => VersionGroup;
}
export declare namespace VersionGroup {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Item implements NamedModel {
    constructor(id: number, name: string, cost: number, flingPower: Nullable<number>, flingEffect: Nullable<Handle.Named<ItemFlingEffect>>, attributes: KtList<Handle.Named<ItemAttribute>>, category: Handle.Named<ItemCategory>, effectEntries: KtList<VerboseEffect>, flavorTextEntries: KtList<VersionGroupFlavorText>, gameIndices: KtList<GenerationGameIndex>, names: KtList<Name>, heldByPokemon: KtList<ItemHolderPokemon>, babyTriggerFor: Nullable<Handle.Unnamed<EvolutionChain>>, sprites: ItemSprites, machines: KtList<MachineVersionDetail>);
    get id(): number;
    get name(): string;
    get cost(): number;
    get flingPower(): Nullable<number>;
    get flingEffect(): Nullable<Handle.Named<ItemFlingEffect>>;
    get attributes(): KtList<Handle.Named<ItemAttribute>>;
    get category(): Handle.Named<ItemCategory>;
    get effectEntries(): KtList<VerboseEffect>;
    get flavorTextEntries(): KtList<VersionGroupFlavorText>;
    get gameIndices(): KtList<GenerationGameIndex>;
    get names(): KtList<Name>;
    get heldByPokemon(): KtList<ItemHolderPokemon>;
    get babyTriggerFor(): Nullable<Handle.Unnamed<EvolutionChain>>;
    get sprites(): ItemSprites;
    get machines(): KtList<MachineVersionDetail>;
    copy(id?: number, name?: string, cost?: number, flingPower?: Nullable<number>, flingEffect?: Nullable<Handle.Named<ItemFlingEffect>>, attributes?: KtList<Handle.Named<ItemAttribute>>, category?: Handle.Named<ItemCategory>, effectEntries?: KtList<VerboseEffect>, flavorTextEntries?: KtList<VersionGroupFlavorText>, gameIndices?: KtList<GenerationGameIndex>, names?: KtList<Name>, heldByPokemon?: KtList<ItemHolderPokemon>, babyTriggerFor?: Nullable<Handle.Unnamed<EvolutionChain>>, sprites?: ItemSprites, machines?: KtList<MachineVersionDetail>): Item;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Item.$metadata$ {
    const constructor: abstract new () => Item;
}
export declare namespace Item {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemSprites {
    constructor(_default: Nullable<string>);
    get default(): Nullable<string>;
    copy(_default?: Nullable<string>): ItemSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemSprites.$metadata$ {
    const constructor: abstract new () => ItemSprites;
}
export declare namespace ItemSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemHolderPokemon {
    constructor(pokemon: Handle.Named<PokemonVariety>, versionDetails: KtList<ItemHolderPokemonVersionDetail>);
    get pokemon(): Handle.Named<PokemonVariety>;
    get versionDetails(): KtList<ItemHolderPokemonVersionDetail>;
    copy(pokemon?: Handle.Named<PokemonVariety>, versionDetails?: KtList<ItemHolderPokemonVersionDetail>): ItemHolderPokemon;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemHolderPokemon.$metadata$ {
    const constructor: abstract new () => ItemHolderPokemon;
}
export declare namespace ItemHolderPokemon {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemHolderPokemonVersionDetail {
    constructor(rarity: number, version: Handle.Named<Version>);
    get rarity(): number;
    get version(): Handle.Named<Version>;
    copy(rarity?: number, version?: Handle.Named<Version>): ItemHolderPokemonVersionDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemHolderPokemonVersionDetail.$metadata$ {
    const constructor: abstract new () => ItemHolderPokemonVersionDetail;
}
export declare namespace ItemHolderPokemonVersionDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemAttribute implements NamedModel {
    constructor(id: number, name: string, items: KtList<Handle.Named<Item>>, names: KtList<Name>, descriptions: KtList<Description>);
    get id(): number;
    get name(): string;
    get items(): KtList<Handle.Named<Item>>;
    get names(): KtList<Name>;
    get descriptions(): KtList<Description>;
    copy(id?: number, name?: string, items?: KtList<Handle.Named<Item>>, names?: KtList<Name>, descriptions?: KtList<Description>): ItemAttribute;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemAttribute.$metadata$ {
    const constructor: abstract new () => ItemAttribute;
}
export declare namespace ItemAttribute {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemCategory implements NamedModel {
    constructor(id: number, name: string, items: KtList<Handle.Named<Item>>, names: KtList<Name>, pocket: Handle.Named<ItemPocket>);
    get id(): number;
    get name(): string;
    get items(): KtList<Handle.Named<Item>>;
    get names(): KtList<Name>;
    get pocket(): Handle.Named<ItemPocket>;
    copy(id?: number, name?: string, items?: KtList<Handle.Named<Item>>, names?: KtList<Name>, pocket?: Handle.Named<ItemPocket>): ItemCategory;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemCategory.$metadata$ {
    const constructor: abstract new () => ItemCategory;
}
export declare namespace ItemCategory {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemFlingEffect implements NamedModel {
    constructor(id: number, name: string, effectEntries: KtList<Effect>, items: KtList<Handle.Named<Item>>);
    get id(): number;
    get name(): string;
    get effectEntries(): KtList<Effect>;
    get items(): KtList<Handle.Named<Item>>;
    copy(id?: number, name?: string, effectEntries?: KtList<Effect>, items?: KtList<Handle.Named<Item>>): ItemFlingEffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemFlingEffect.$metadata$ {
    const constructor: abstract new () => ItemFlingEffect;
}
export declare namespace ItemFlingEffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ItemPocket implements NamedModel {
    constructor(id: number, name: string, categories: KtList<Handle.Named<ItemCategory>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get categories(): KtList<Handle.Named<ItemCategory>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, categories?: KtList<Handle.Named<ItemCategory>>, names?: KtList<Name>): ItemPocket;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemPocket.$metadata$ {
    const constructor: abstract new () => ItemPocket;
}
export declare namespace ItemPocket {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Location implements NamedModel {
    constructor(id: number, name: string, region: Nullable<Handle.Named<Region>>, names: KtList<Name>, gameIndices: KtList<GenerationGameIndex>, areas: KtList<Handle.Named<LocationArea>>);
    get id(): number;
    get name(): string;
    get region(): Nullable<Handle.Named<Region>>;
    get names(): KtList<Name>;
    get gameIndices(): KtList<GenerationGameIndex>;
    get areas(): KtList<Handle.Named<LocationArea>>;
    copy(id?: number, name?: string, region?: Nullable<Handle.Named<Region>>, names?: KtList<Name>, gameIndices?: KtList<GenerationGameIndex>, areas?: KtList<Handle.Named<LocationArea>>): Location;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Location.$metadata$ {
    const constructor: abstract new () => Location;
}
export declare namespace Location {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class LocationArea implements NamedModel {
    constructor(id: number, name: string, gameIndex: number, encounterMethodRates: KtList<EncounterMethodRate>, location: Handle.Named<Location>, names: KtList<Name>, pokemonEncounters: KtList<PokemonEncounter>);
    get id(): number;
    get name(): string;
    get gameIndex(): number;
    get encounterMethodRates(): KtList<EncounterMethodRate>;
    get location(): Handle.Named<Location>;
    get names(): KtList<Name>;
    get pokemonEncounters(): KtList<PokemonEncounter>;
    copy(id?: number, name?: string, gameIndex?: number, encounterMethodRates?: KtList<EncounterMethodRate>, location?: Handle.Named<Location>, names?: KtList<Name>, pokemonEncounters?: KtList<PokemonEncounter>): LocationArea;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LocationArea.$metadata$ {
    const constructor: abstract new () => LocationArea;
}
export declare namespace LocationArea {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EncounterMethodRate {
    constructor(encounterMethod: Handle.Named<EncounterMethod>, versionDetails: KtList<EncounterMethodRateVersionDetail>);
    get encounterMethod(): Handle.Named<EncounterMethod>;
    get versionDetails(): KtList<EncounterMethodRateVersionDetail>;
    copy(encounterMethod?: Handle.Named<EncounterMethod>, versionDetails?: KtList<EncounterMethodRateVersionDetail>): EncounterMethodRate;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EncounterMethodRate.$metadata$ {
    const constructor: abstract new () => EncounterMethodRate;
}
export declare namespace EncounterMethodRate {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EncounterMethodRateVersionDetail {
    constructor(rate: number, version: Handle.Named<Version>);
    get rate(): number;
    get version(): Handle.Named<Version>;
    copy(rate?: number, version?: Handle.Named<Version>): EncounterMethodRateVersionDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EncounterMethodRateVersionDetail.$metadata$ {
    const constructor: abstract new () => EncounterMethodRateVersionDetail;
}
export declare namespace EncounterMethodRateVersionDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonEncounter {
    constructor(pokemon: Handle.Named<PokemonVariety>, versionDetails: KtList<VersionEncounterDetail>);
    get pokemon(): Handle.Named<PokemonVariety>;
    get versionDetails(): KtList<VersionEncounterDetail>;
    copy(pokemon?: Handle.Named<PokemonVariety>, versionDetails?: KtList<VersionEncounterDetail>): PokemonEncounter;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonEncounter.$metadata$ {
    const constructor: abstract new () => PokemonEncounter;
}
export declare namespace PokemonEncounter {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PalParkArea implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, pokemonEncounters: KtList<PalParkEncounterSpecies>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get pokemonEncounters(): KtList<PalParkEncounterSpecies>;
    copy(id?: number, name?: string, names?: KtList<Name>, pokemonEncounters?: KtList<PalParkEncounterSpecies>): PalParkArea;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PalParkArea.$metadata$ {
    const constructor: abstract new () => PalParkArea;
}
export declare namespace PalParkArea {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PalParkEncounterSpecies {
    constructor(baseScore: number, rate: number, pokemonSpecies: Handle.Named<PokemonSpecies>);
    get baseScore(): number;
    get rate(): number;
    get pokemonSpecies(): Handle.Named<PokemonSpecies>;
    copy(baseScore?: number, rate?: number, pokemonSpecies?: Handle.Named<PokemonSpecies>): PalParkEncounterSpecies;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PalParkEncounterSpecies.$metadata$ {
    const constructor: abstract new () => PalParkEncounterSpecies;
}
export declare namespace PalParkEncounterSpecies {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Region implements NamedModel {
    constructor(id: number, name: string, locations: KtList<Handle.Named<Location>>, mainGeneration: Nullable<Handle.Named<Generation>>, names: KtList<Name>, pokedexes: KtList<Handle.Named<Pokedex>>, versionGroups: KtList<Handle.Named<VersionGroup>>);
    get id(): number;
    get name(): string;
    get locations(): KtList<Handle.Named<Location>>;
    get mainGeneration(): Nullable<Handle.Named<Generation>>;
    get names(): KtList<Name>;
    get pokedexes(): KtList<Handle.Named<Pokedex>>;
    get versionGroups(): KtList<Handle.Named<VersionGroup>>;
    copy(id?: number, name?: string, locations?: KtList<Handle.Named<Location>>, mainGeneration?: Nullable<Handle.Named<Generation>>, names?: KtList<Name>, pokedexes?: KtList<Handle.Named<Pokedex>>, versionGroups?: KtList<Handle.Named<VersionGroup>>): Region;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Region.$metadata$ {
    const constructor: abstract new () => Region;
}
export declare namespace Region {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Machine implements Model {
    constructor(id: number, item: Handle.Named<Item>, move: Handle.Named<Move>, versionGroup: Handle.Named<VersionGroup>);
    get id(): number;
    get item(): Handle.Named<Item>;
    get move(): Handle.Named<Move>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(id?: number, item?: Handle.Named<Item>, move?: Handle.Named<Move>, versionGroup?: Handle.Named<VersionGroup>): Machine;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Model["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Machine.$metadata$ {
    const constructor: abstract new () => Machine;
}
export declare namespace Machine {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Move implements NamedModel {
    constructor(id: number, name: string, accuracy: Nullable<number>, effectChance: Nullable<number>, pp: Nullable<number>, priority: number, power: Nullable<number>, contestCombos: Nullable<ContestComboSets>, contestType: Nullable<Handle.Named<ContestType>>, contestEffect: Nullable<Handle.Unnamed<ContestEffect>>, superContestEffect: Nullable<Handle.Unnamed<SuperContestEffect>>, damageClass: Handle.Named<MoveDamageClass>, effectEntries: KtList<VerboseEffect>, effectChanges: KtList<AbilityEffectChange>, generation: Handle.Named<Generation>, learnedByPokemon: KtList<Handle.Named<PokemonVariety>>, meta: Nullable<MoveMetaData>, names: KtList<Name>, pastValues: KtList<PastMoveStatValues>, statChanges: KtList<MoveStatChange>, target: Handle.Named<MoveTarget>, type: Handle.Named<Type>, machines: KtList<MachineVersionDetail>, flavorTextEntries: KtList<MoveFlavorText>);
    get id(): number;
    get name(): string;
    get accuracy(): Nullable<number>;
    get effectChance(): Nullable<number>;
    get pp(): Nullable<number>;
    get priority(): number;
    get power(): Nullable<number>;
    get contestCombos(): Nullable<ContestComboSets>;
    get contestType(): Nullable<Handle.Named<ContestType>>;
    get contestEffect(): Nullable<Handle.Unnamed<ContestEffect>>;
    get superContestEffect(): Nullable<Handle.Unnamed<SuperContestEffect>>;
    get damageClass(): Handle.Named<MoveDamageClass>;
    get effectEntries(): KtList<VerboseEffect>;
    get effectChanges(): KtList<AbilityEffectChange>;
    get generation(): Handle.Named<Generation>;
    get learnedByPokemon(): KtList<Handle.Named<PokemonVariety>>;
    get meta(): Nullable<MoveMetaData>;
    get names(): KtList<Name>;
    get pastValues(): KtList<PastMoveStatValues>;
    get statChanges(): KtList<MoveStatChange>;
    get target(): Handle.Named<MoveTarget>;
    get type(): Handle.Named<Type>;
    get machines(): KtList<MachineVersionDetail>;
    get flavorTextEntries(): KtList<MoveFlavorText>;
    copy(id?: number, name?: string, accuracy?: Nullable<number>, effectChance?: Nullable<number>, pp?: Nullable<number>, priority?: number, power?: Nullable<number>, contestCombos?: Nullable<ContestComboSets>, contestType?: Nullable<Handle.Named<ContestType>>, contestEffect?: Nullable<Handle.Unnamed<ContestEffect>>, superContestEffect?: Nullable<Handle.Unnamed<SuperContestEffect>>, damageClass?: Handle.Named<MoveDamageClass>, effectEntries?: KtList<VerboseEffect>, effectChanges?: KtList<AbilityEffectChange>, generation?: Handle.Named<Generation>, learnedByPokemon?: KtList<Handle.Named<PokemonVariety>>, meta?: Nullable<MoveMetaData>, names?: KtList<Name>, pastValues?: KtList<PastMoveStatValues>, statChanges?: KtList<MoveStatChange>, target?: Handle.Named<MoveTarget>, type?: Handle.Named<Type>, machines?: KtList<MachineVersionDetail>, flavorTextEntries?: KtList<MoveFlavorText>): Move;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Move.$metadata$ {
    const constructor: abstract new () => Move;
}
export declare namespace Move {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ContestComboSets {
    constructor(normalSet: ContestComboDetail, superSet: ContestComboDetail);
    get normalSet(): ContestComboDetail;
    get superSet(): ContestComboDetail;
    copy(normalSet?: ContestComboDetail, superSet?: ContestComboDetail): ContestComboSets;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContestComboSets.$metadata$ {
    const constructor: abstract new () => ContestComboSets;
}
export declare namespace ContestComboSets {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ContestComboDetail {
    constructor(useBefore: Nullable<KtList<Handle.Named<Move>>>, useAfter: Nullable<KtList<Handle.Named<Move>>>);
    get useBefore(): Nullable<KtList<Handle.Named<Move>>>;
    get useAfter(): Nullable<KtList<Handle.Named<Move>>>;
    copy(useBefore?: Nullable<KtList<Handle.Named<Move>>>, useAfter?: Nullable<KtList<Handle.Named<Move>>>): ContestComboDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContestComboDetail.$metadata$ {
    const constructor: abstract new () => ContestComboDetail;
}
export declare namespace ContestComboDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveMetaData {
    constructor(ailment: Handle.Named<MoveAilment>, category: Handle.Named<MoveCategory>, minHits: Nullable<number>, maxHits: Nullable<number>, minTurns: Nullable<number>, maxTurns: Nullable<number>, drain: number, healing: number, critRate: number, ailmentChance: number, flinchChance: number, statChance: number);
    get ailment(): Handle.Named<MoveAilment>;
    get category(): Handle.Named<MoveCategory>;
    get minHits(): Nullable<number>;
    get maxHits(): Nullable<number>;
    get minTurns(): Nullable<number>;
    get maxTurns(): Nullable<number>;
    get drain(): number;
    get healing(): number;
    get critRate(): number;
    get ailmentChance(): number;
    get flinchChance(): number;
    get statChance(): number;
    copy(ailment?: Handle.Named<MoveAilment>, category?: Handle.Named<MoveCategory>, minHits?: Nullable<number>, maxHits?: Nullable<number>, minTurns?: Nullable<number>, maxTurns?: Nullable<number>, drain?: number, healing?: number, critRate?: number, ailmentChance?: number, flinchChance?: number, statChance?: number): MoveMetaData;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveMetaData.$metadata$ {
    const constructor: abstract new () => MoveMetaData;
}
export declare namespace MoveMetaData {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveStatChange {
    constructor(change: number, stat: Handle.Named<Stat>);
    get change(): number;
    get stat(): Handle.Named<Stat>;
    copy(change?: number, stat?: Handle.Named<Stat>): MoveStatChange;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveStatChange.$metadata$ {
    const constructor: abstract new () => MoveStatChange;
}
export declare namespace MoveStatChange {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PastMoveStatValues {
    constructor(accuracy: Nullable<number>, effectChance: Nullable<number>, power: Nullable<number>, pp: Nullable<number>, effectEntries: KtList<VerboseEffect>, type: Nullable<Handle.Named<Type>>, versionGroup: Handle.Named<VersionGroup>);
    get accuracy(): Nullable<number>;
    get effectChance(): Nullable<number>;
    get power(): Nullable<number>;
    get pp(): Nullable<number>;
    get effectEntries(): KtList<VerboseEffect>;
    get type(): Nullable<Handle.Named<Type>>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(accuracy?: Nullable<number>, effectChance?: Nullable<number>, power?: Nullable<number>, pp?: Nullable<number>, effectEntries?: KtList<VerboseEffect>, type?: Nullable<Handle.Named<Type>>, versionGroup?: Handle.Named<VersionGroup>): PastMoveStatValues;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PastMoveStatValues.$metadata$ {
    const constructor: abstract new () => PastMoveStatValues;
}
export declare namespace PastMoveStatValues {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveAilment implements NamedModel {
    constructor(id: number, name: string, moves: KtList<Handle.Named<Move>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get moves(): KtList<Handle.Named<Move>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, moves?: KtList<Handle.Named<Move>>, names?: KtList<Name>): MoveAilment;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveAilment.$metadata$ {
    const constructor: abstract new () => MoveAilment;
}
export declare namespace MoveAilment {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveBattleStyle implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, names?: KtList<Name>): MoveBattleStyle;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveBattleStyle.$metadata$ {
    const constructor: abstract new () => MoveBattleStyle;
}
export declare namespace MoveBattleStyle {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveCategory implements NamedModel {
    constructor(id: number, name: string, moves: KtList<Handle.Named<Move>>, descriptions: KtList<Description>);
    get id(): number;
    get name(): string;
    get moves(): KtList<Handle.Named<Move>>;
    get descriptions(): KtList<Description>;
    copy(id?: number, name?: string, moves?: KtList<Handle.Named<Move>>, descriptions?: KtList<Description>): MoveCategory;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveCategory.$metadata$ {
    const constructor: abstract new () => MoveCategory;
}
export declare namespace MoveCategory {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveDamageClass implements NamedModel {
    constructor(id: number, name: string, descriptions: KtList<Description>, moves: KtList<Handle.Named<Move>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get descriptions(): KtList<Description>;
    get moves(): KtList<Handle.Named<Move>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, descriptions?: KtList<Description>, moves?: KtList<Handle.Named<Move>>, names?: KtList<Name>): MoveDamageClass;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveDamageClass.$metadata$ {
    const constructor: abstract new () => MoveDamageClass;
}
export declare namespace MoveDamageClass {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveLearnMethod implements NamedModel {
    constructor(id: number, name: string, descriptions: KtList<Description>, names: KtList<Name>, versionGroups: KtList<Handle.Named<VersionGroup>>);
    get id(): number;
    get name(): string;
    get descriptions(): KtList<Description>;
    get names(): KtList<Name>;
    get versionGroups(): KtList<Handle.Named<VersionGroup>>;
    copy(id?: number, name?: string, descriptions?: KtList<Description>, names?: KtList<Name>, versionGroups?: KtList<Handle.Named<VersionGroup>>): MoveLearnMethod;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveLearnMethod.$metadata$ {
    const constructor: abstract new () => MoveLearnMethod;
}
export declare namespace MoveLearnMethod {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveTarget implements NamedModel {
    constructor(id: number, name: string, descriptions: KtList<Description>, moves: KtList<Handle.Named<Move>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get descriptions(): KtList<Description>;
    get moves(): KtList<Handle.Named<Move>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, descriptions?: KtList<Description>, moves?: KtList<Handle.Named<Move>>, names?: KtList<Name>): MoveTarget;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveTarget.$metadata$ {
    const constructor: abstract new () => MoveTarget;
}
export declare namespace MoveTarget {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveFlavorText {
    constructor(flavorText: string, language: Handle.Named<Language>, versionGroup: Handle.Named<VersionGroup>);
    get flavorText(): string;
    get language(): Handle.Named<Language>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(flavorText?: string, language?: Handle.Named<Language>, versionGroup?: Handle.Named<VersionGroup>): MoveFlavorText;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveFlavorText.$metadata$ {
    const constructor: abstract new () => MoveFlavorText;
}
export declare namespace MoveFlavorText {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Ability implements NamedModel {
    constructor(id: number, name: string, isMainSeries: boolean, generation: Handle.Named<Generation>, names: KtList<Name>, effectEntries: KtList<VerboseEffect>, effectChanges: KtList<AbilityEffectChange>, flavorTextEntries: KtList<AbilityFlavorText>, pokemon: KtList<AbilityPokemon>);
    get id(): number;
    get name(): string;
    get isMainSeries(): boolean;
    get generation(): Handle.Named<Generation>;
    get names(): KtList<Name>;
    get effectEntries(): KtList<VerboseEffect>;
    get effectChanges(): KtList<AbilityEffectChange>;
    get flavorTextEntries(): KtList<AbilityFlavorText>;
    get pokemon(): KtList<AbilityPokemon>;
    copy(id?: number, name?: string, isMainSeries?: boolean, generation?: Handle.Named<Generation>, names?: KtList<Name>, effectEntries?: KtList<VerboseEffect>, effectChanges?: KtList<AbilityEffectChange>, flavorTextEntries?: KtList<AbilityFlavorText>, pokemon?: KtList<AbilityPokemon>): Ability;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Ability.$metadata$ {
    const constructor: abstract new () => Ability;
}
export declare namespace Ability {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class AbilityEffectChange {
    constructor(effectEntries: KtList<Effect>, versionGroup: Handle.Named<VersionGroup>);
    get effectEntries(): KtList<Effect>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(effectEntries?: KtList<Effect>, versionGroup?: Handle.Named<VersionGroup>): AbilityEffectChange;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AbilityEffectChange.$metadata$ {
    const constructor: abstract new () => AbilityEffectChange;
}
export declare namespace AbilityEffectChange {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class AbilityFlavorText {
    constructor(flavorText: string, language: Handle.Named<Language>, versionGroup: Handle.Named<VersionGroup>);
    get flavorText(): string;
    get language(): Handle.Named<Language>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(flavorText?: string, language?: Handle.Named<Language>, versionGroup?: Handle.Named<VersionGroup>): AbilityFlavorText;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AbilityFlavorText.$metadata$ {
    const constructor: abstract new () => AbilityFlavorText;
}
export declare namespace AbilityFlavorText {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class AbilityPokemon {
    constructor(isHidden: boolean, slot: number, pokemon: Handle.Named<PokemonVariety>);
    get isHidden(): boolean;
    get slot(): number;
    get pokemon(): Handle.Named<PokemonVariety>;
    copy(isHidden?: boolean, slot?: number, pokemon?: Handle.Named<PokemonVariety>): AbilityPokemon;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AbilityPokemon.$metadata$ {
    const constructor: abstract new () => AbilityPokemon;
}
export declare namespace AbilityPokemon {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Characteristic implements Model {
    constructor(id: number, geneModulo: number, possibleValues: KtList<number>, descriptions: KtList<Description>);
    get id(): number;
    get geneModulo(): number;
    get possibleValues(): KtList<number>;
    get descriptions(): KtList<Description>;
    copy(id?: number, geneModulo?: number, possibleValues?: KtList<number>, descriptions?: KtList<Description>): Characteristic;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Model["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Characteristic.$metadata$ {
    const constructor: abstract new () => Characteristic;
}
export declare namespace Characteristic {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EggGroup implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, names?: KtList<Name>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): EggGroup;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EggGroup.$metadata$ {
    const constructor: abstract new () => EggGroup;
}
export declare namespace EggGroup {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Gender implements NamedModel {
    constructor(id: number, name: string, pokemonSpeciesDetails: KtList<PokemonSpeciesGender>, requiredForEvolution: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get pokemonSpeciesDetails(): KtList<PokemonSpeciesGender>;
    get requiredForEvolution(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, pokemonSpeciesDetails?: KtList<PokemonSpeciesGender>, requiredForEvolution?: KtList<Handle.Named<PokemonSpecies>>): Gender;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Gender.$metadata$ {
    const constructor: abstract new () => Gender;
}
export declare namespace Gender {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSpeciesGender {
    constructor(rate: number, pokemonSpecies: Handle.Named<PokemonSpecies>);
    get rate(): number;
    get pokemonSpecies(): Handle.Named<PokemonSpecies>;
    copy(rate?: number, pokemonSpecies?: Handle.Named<PokemonSpecies>): PokemonSpeciesGender;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSpeciesGender.$metadata$ {
    const constructor: abstract new () => PokemonSpeciesGender;
}
export declare namespace PokemonSpeciesGender {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GrowthRate implements NamedModel {
    constructor(id: number, name: string, formula: string, descriptions: KtList<Description>, levels: KtList<GrowthRateExperienceLevel>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get formula(): string;
    get descriptions(): KtList<Description>;
    get levels(): KtList<GrowthRateExperienceLevel>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, formula?: string, descriptions?: KtList<Description>, levels?: KtList<GrowthRateExperienceLevel>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): GrowthRate;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrowthRate.$metadata$ {
    const constructor: abstract new () => GrowthRate;
}
export declare namespace GrowthRate {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GrowthRateExperienceLevel {
    constructor(level: number, experience: number);
    get level(): number;
    get experience(): number;
    copy(level?: number, experience?: number): GrowthRateExperienceLevel;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrowthRateExperienceLevel.$metadata$ {
    const constructor: abstract new () => GrowthRateExperienceLevel;
}
export declare namespace GrowthRateExperienceLevel {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Nature implements NamedModel {
    constructor(id: number, name: string, decreasedStat: Nullable<Handle.Named<Stat>>, increasedStat: Nullable<Handle.Named<Stat>>, hatesFlavor: Nullable<Handle.Named<BerryFlavor>>, likesFlavor: Nullable<Handle.Named<BerryFlavor>>, pokeathlonStatChanges: KtList<NatureStatChange>, moveBattleStylePreferences: KtList<MoveBattleStylePreference>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get decreasedStat(): Nullable<Handle.Named<Stat>>;
    get increasedStat(): Nullable<Handle.Named<Stat>>;
    get hatesFlavor(): Nullable<Handle.Named<BerryFlavor>>;
    get likesFlavor(): Nullable<Handle.Named<BerryFlavor>>;
    get pokeathlonStatChanges(): KtList<NatureStatChange>;
    get moveBattleStylePreferences(): KtList<MoveBattleStylePreference>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, decreasedStat?: Nullable<Handle.Named<Stat>>, increasedStat?: Nullable<Handle.Named<Stat>>, hatesFlavor?: Nullable<Handle.Named<BerryFlavor>>, likesFlavor?: Nullable<Handle.Named<BerryFlavor>>, pokeathlonStatChanges?: KtList<NatureStatChange>, moveBattleStylePreferences?: KtList<MoveBattleStylePreference>, names?: KtList<Name>): Nature;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Nature.$metadata$ {
    const constructor: abstract new () => Nature;
}
export declare namespace Nature {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class NatureStatChange {
    constructor(maxChange: number, pokeathlonStat: Handle.Named<PokeathlonStat>);
    get maxChange(): number;
    get pokeathlonStat(): Handle.Named<PokeathlonStat>;
    copy(maxChange?: number, pokeathlonStat?: Handle.Named<PokeathlonStat>): NatureStatChange;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NatureStatChange.$metadata$ {
    const constructor: abstract new () => NatureStatChange;
}
export declare namespace NatureStatChange {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveBattleStylePreference {
    constructor(lowHpPreference: number, highHpPreference: number, moveBattleStyle: Handle.Named<MoveBattleStyle>);
    get lowHpPreference(): number;
    get highHpPreference(): number;
    get moveBattleStyle(): Handle.Named<MoveBattleStyle>;
    copy(lowHpPreference?: number, highHpPreference?: number, moveBattleStyle?: Handle.Named<MoveBattleStyle>): MoveBattleStylePreference;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveBattleStylePreference.$metadata$ {
    const constructor: abstract new () => MoveBattleStylePreference;
}
export declare namespace MoveBattleStylePreference {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokeathlonStat implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, affectingNatures: NaturePokeathlonStatEffectSets);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get affectingNatures(): NaturePokeathlonStatEffectSets;
    copy(id?: number, name?: string, names?: KtList<Name>, affectingNatures?: NaturePokeathlonStatEffectSets): PokeathlonStat;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokeathlonStat.$metadata$ {
    const constructor: abstract new () => PokeathlonStat;
}
export declare namespace PokeathlonStat {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class NaturePokeathlonStatEffectSets {
    constructor(increase: KtList<NaturePokeathlonStatEffect>, decrease: KtList<NaturePokeathlonStatEffect>);
    get increase(): KtList<NaturePokeathlonStatEffect>;
    get decrease(): KtList<NaturePokeathlonStatEffect>;
    copy(increase?: KtList<NaturePokeathlonStatEffect>, decrease?: KtList<NaturePokeathlonStatEffect>): NaturePokeathlonStatEffectSets;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NaturePokeathlonStatEffectSets.$metadata$ {
    const constructor: abstract new () => NaturePokeathlonStatEffectSets;
}
export declare namespace NaturePokeathlonStatEffectSets {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class NaturePokeathlonStatEffect {
    constructor(maxChange: number, nature: Handle.Named<Nature>);
    get maxChange(): number;
    get nature(): Handle.Named<Nature>;
    copy(maxChange?: number, nature?: Handle.Named<Nature>): NaturePokeathlonStatEffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NaturePokeathlonStatEffect.$metadata$ {
    const constructor: abstract new () => NaturePokeathlonStatEffect;
}
export declare namespace NaturePokeathlonStatEffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonVariety implements NamedModel {
    constructor(id: number, name: string, baseExperience: number, height: number, isDefault: boolean, order: number, weight: number, species: Handle.Named<PokemonSpecies>, abilities: KtList<PokemonAbility>, forms: KtList<Handle.Named<PokemonForm>>, gameIndices: KtList<VersionGameIndex>, heldItems: KtList<PokemonHeldItem>, moves: KtList<PokemonMove>, stats: KtList<PokemonStat>, types: KtList<PokemonType>, pastTypes: KtList<PokemonPastType>, pastAbilities: KtList<PokemonPastAbility>, cries: PokemonCries, sprites: PokemonSprites);
    get id(): number;
    get name(): string;
    get baseExperience(): number;
    get height(): number;
    get isDefault(): boolean;
    get order(): number;
    get weight(): number;
    get species(): Handle.Named<PokemonSpecies>;
    get abilities(): KtList<PokemonAbility>;
    get forms(): KtList<Handle.Named<PokemonForm>>;
    get gameIndices(): KtList<VersionGameIndex>;
    get heldItems(): KtList<PokemonHeldItem>;
    get moves(): KtList<PokemonMove>;
    get stats(): KtList<PokemonStat>;
    get types(): KtList<PokemonType>;
    get pastTypes(): KtList<PokemonPastType>;
    get pastAbilities(): KtList<PokemonPastAbility>;
    get cries(): PokemonCries;
    get sprites(): PokemonSprites;
    copy(id?: number, name?: string, baseExperience?: number, height?: number, isDefault?: boolean, order?: number, weight?: number, species?: Handle.Named<PokemonSpecies>, abilities?: KtList<PokemonAbility>, forms?: KtList<Handle.Named<PokemonForm>>, gameIndices?: KtList<VersionGameIndex>, heldItems?: KtList<PokemonHeldItem>, moves?: KtList<PokemonMove>, stats?: KtList<PokemonStat>, types?: KtList<PokemonType>, pastTypes?: KtList<PokemonPastType>, pastAbilities?: KtList<PokemonPastAbility>, cries?: PokemonCries, sprites?: PokemonSprites): PokemonVariety;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonVariety.$metadata$ {
    const constructor: abstract new () => PokemonVariety;
}
export declare namespace PokemonVariety {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSprites {
    constructor(backDefault: Nullable<string>, backShiny: Nullable<string>, frontDefault: Nullable<string>, frontShiny: Nullable<string>, backFemale: Nullable<string>, backShinyFemale: Nullable<string>, frontFemale: Nullable<string>, frontShinyFemale: Nullable<string>, other: OtherGameSprites, versions: VersionGameSprites);
    get backDefault(): Nullable<string>;
    get backShiny(): Nullable<string>;
    get frontDefault(): Nullable<string>;
    get frontShiny(): Nullable<string>;
    get backFemale(): Nullable<string>;
    get backShinyFemale(): Nullable<string>;
    get frontFemale(): Nullable<string>;
    get frontShinyFemale(): Nullable<string>;
    get other(): OtherGameSprites;
    get versions(): VersionGameSprites;
    copy(backDefault?: Nullable<string>, backShiny?: Nullable<string>, frontDefault?: Nullable<string>, frontShiny?: Nullable<string>, backFemale?: Nullable<string>, backShinyFemale?: Nullable<string>, frontFemale?: Nullable<string>, frontShinyFemale?: Nullable<string>, other?: OtherGameSprites, versions?: VersionGameSprites): PokemonSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSprites.$metadata$ {
    const constructor: abstract new () => PokemonSprites;
}
export declare namespace PokemonSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class OtherGameSprites {
    constructor(dreamWorld: GameSprites, home: GameSprites, officialArtwork: GameSprites, showdown: GameSprites);
    get dreamWorld(): GameSprites;
    get home(): GameSprites;
    get officialArtwork(): GameSprites;
    get showdown(): GameSprites;
    copy(dreamWorld?: GameSprites, home?: GameSprites, officialArtwork?: GameSprites, showdown?: GameSprites): OtherGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OtherGameSprites.$metadata$ {
    const constructor: abstract new () => OtherGameSprites;
}
export declare namespace OtherGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionGameSprites {
    constructor(generationI: GenerationIGameSprites, generationIi: GenerationIiGameSprites, generationIii: GenerationIiiGameSprites, generationIv: GenerationIvGameSprites, generationV: GenerationVGameSprites, generationVi: GenerationViGameSprites, generationVii: GenerationViiGameSprites, generationViii: GenerationViiiGameSprites);
    get generationI(): GenerationIGameSprites;
    get generationIi(): GenerationIiGameSprites;
    get generationIii(): GenerationIiiGameSprites;
    get generationIv(): GenerationIvGameSprites;
    get generationV(): GenerationVGameSprites;
    get generationVi(): GenerationViGameSprites;
    get generationVii(): GenerationViiGameSprites;
    get generationViii(): GenerationViiiGameSprites;
    copy(generationI?: GenerationIGameSprites, generationIi?: GenerationIiGameSprites, generationIii?: GenerationIiiGameSprites, generationIv?: GenerationIvGameSprites, generationV?: GenerationVGameSprites, generationVi?: GenerationViGameSprites, generationVii?: GenerationViiGameSprites, generationViii?: GenerationViiiGameSprites): VersionGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionGameSprites.$metadata$ {
    const constructor: abstract new () => VersionGameSprites;
}
export declare namespace VersionGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIGameSprites {
    constructor(redBlue: GameSprites, yellow: GameSprites);
    get redBlue(): GameSprites;
    get yellow(): GameSprites;
    copy(redBlue?: GameSprites, yellow?: GameSprites): GenerationIGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationIGameSprites;
}
export declare namespace GenerationIGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIiGameSprites {
    constructor(crystal: GameSprites, gold: GameSprites, silver: GameSprites);
    get crystal(): GameSprites;
    get gold(): GameSprites;
    get silver(): GameSprites;
    copy(crystal?: GameSprites, gold?: GameSprites, silver?: GameSprites): GenerationIiGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIiGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationIiGameSprites;
}
export declare namespace GenerationIiGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIiiGameSprites {
    constructor(emerald: GameSprites, fireredLeafgreen: GameSprites, rubySapphire: GameSprites);
    get emerald(): GameSprites;
    get fireredLeafgreen(): GameSprites;
    get rubySapphire(): GameSprites;
    copy(emerald?: GameSprites, fireredLeafgreen?: GameSprites, rubySapphire?: GameSprites): GenerationIiiGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIiiGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationIiiGameSprites;
}
export declare namespace GenerationIiiGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIvGameSprites {
    constructor(diamondPearl: GameSprites, heartgoldSoulsilver: GameSprites, platinum: GameSprites);
    get diamondPearl(): GameSprites;
    get heartgoldSoulsilver(): GameSprites;
    get platinum(): GameSprites;
    copy(diamondPearl?: GameSprites, heartgoldSoulsilver?: GameSprites, platinum?: GameSprites): GenerationIvGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIvGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationIvGameSprites;
}
export declare namespace GenerationIvGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationVGameSprites {
    constructor(blackWhite: BlackWhiteSprites);
    get blackWhite(): BlackWhiteSprites;
    copy(blackWhite?: BlackWhiteSprites): GenerationVGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationVGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationVGameSprites;
}
export declare namespace GenerationVGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class BlackWhiteSprites {
    constructor(animated: GameSprites, backDefault?: Nullable<string>, backFemale?: Nullable<string>, backShiny?: Nullable<string>, backShinyFemale?: Nullable<string>, frontDefault?: Nullable<string>, frontFemale?: Nullable<string>, frontShiny?: Nullable<string>, frontShinyFemale?: Nullable<string>);
    get animated(): GameSprites;
    get backDefault(): Nullable<string>;
    get backFemale(): Nullable<string>;
    get backShiny(): Nullable<string>;
    get backShinyFemale(): Nullable<string>;
    get frontDefault(): Nullable<string>;
    get frontFemale(): Nullable<string>;
    get frontShiny(): Nullable<string>;
    get frontShinyFemale(): Nullable<string>;
    copy(animated?: GameSprites, backDefault?: Nullable<string>, backFemale?: Nullable<string>, backShiny?: Nullable<string>, backShinyFemale?: Nullable<string>, frontDefault?: Nullable<string>, frontFemale?: Nullable<string>, frontShiny?: Nullable<string>, frontShinyFemale?: Nullable<string>): BlackWhiteSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BlackWhiteSprites.$metadata$ {
    const constructor: abstract new () => BlackWhiteSprites;
}
export declare namespace BlackWhiteSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViGameSprites {
    constructor(omegaRubyAlphaSapphire: GameSprites, xY: GameSprites);
    get omegaRubyAlphaSapphire(): GameSprites;
    get xY(): GameSprites;
    copy(omegaRubyAlphaSapphire?: GameSprites, xY?: GameSprites): GenerationViGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationViGameSprites;
}
export declare namespace GenerationViGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViiGameSprites {
    constructor(icons: GameSprites, ultraSunUltraMoon: GameSprites);
    get icons(): GameSprites;
    get ultraSunUltraMoon(): GameSprites;
    copy(icons?: GameSprites, ultraSunUltraMoon?: GameSprites): GenerationViiGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViiGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationViiGameSprites;
}
export declare namespace GenerationViiGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViiiGameSprites {
    constructor(icons: GameSprites);
    get icons(): GameSprites;
    copy(icons?: GameSprites): GenerationViiiGameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViiiGameSprites.$metadata$ {
    const constructor: abstract new () => GenerationViiiGameSprites;
}
export declare namespace GenerationViiiGameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GameSprites {
    constructor(animated?: Nullable<GameSprites>, backDefault?: Nullable<string>, backGray?: Nullable<string>, backTransparent?: Nullable<string>, backFemale?: Nullable<string>, backShiny?: Nullable<string>, backShinyTransparent?: Nullable<string>, backShinyFemale?: Nullable<string>, frontDefault?: Nullable<string>, frontGray?: Nullable<string>, frontTransparent?: Nullable<string>, frontFemale?: Nullable<string>, frontShiny?: Nullable<string>, frontShinyTransparent?: Nullable<string>, frontShinyFemale?: Nullable<string>);
    get animated(): Nullable<GameSprites>;
    get backDefault(): Nullable<string>;
    get backGray(): Nullable<string>;
    get backTransparent(): Nullable<string>;
    get backFemale(): Nullable<string>;
    get backShiny(): Nullable<string>;
    get backShinyTransparent(): Nullable<string>;
    get backShinyFemale(): Nullable<string>;
    get frontDefault(): Nullable<string>;
    get frontGray(): Nullable<string>;
    get frontTransparent(): Nullable<string>;
    get frontFemale(): Nullable<string>;
    get frontShiny(): Nullable<string>;
    get frontShinyTransparent(): Nullable<string>;
    get frontShinyFemale(): Nullable<string>;
    copy(animated?: Nullable<GameSprites>, backDefault?: Nullable<string>, backGray?: Nullable<string>, backTransparent?: Nullable<string>, backFemale?: Nullable<string>, backShiny?: Nullable<string>, backShinyTransparent?: Nullable<string>, backShinyFemale?: Nullable<string>, frontDefault?: Nullable<string>, frontGray?: Nullable<string>, frontTransparent?: Nullable<string>, frontFemale?: Nullable<string>, frontShiny?: Nullable<string>, frontShinyTransparent?: Nullable<string>, frontShinyFemale?: Nullable<string>): GameSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GameSprites.$metadata$ {
    const constructor: abstract new () => GameSprites;
}
export declare namespace GameSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonAbility {
    constructor(isHidden: boolean, slot: number, ability: Nullable<Handle.Named<Ability>>);
    get isHidden(): boolean;
    get slot(): number;
    get ability(): Nullable<Handle.Named<Ability>>;
    copy(isHidden?: boolean, slot?: number, ability?: Nullable<Handle.Named<Ability>>): PokemonAbility;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonAbility.$metadata$ {
    const constructor: abstract new () => PokemonAbility;
}
export declare namespace PokemonAbility {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonHeldItem {
    constructor(item: Handle.Named<Item>, versionDetails: KtList<PokemonHeldItemVersion>);
    get item(): Handle.Named<Item>;
    get versionDetails(): KtList<PokemonHeldItemVersion>;
    copy(item?: Handle.Named<Item>, versionDetails?: KtList<PokemonHeldItemVersion>): PokemonHeldItem;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonHeldItem.$metadata$ {
    const constructor: abstract new () => PokemonHeldItem;
}
export declare namespace PokemonHeldItem {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonHeldItemVersion {
    constructor(version: Handle.Named<Version>, rarity: number);
    get version(): Handle.Named<Version>;
    get rarity(): number;
    copy(version?: Handle.Named<Version>, rarity?: number): PokemonHeldItemVersion;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonHeldItemVersion.$metadata$ {
    const constructor: abstract new () => PokemonHeldItemVersion;
}
export declare namespace PokemonHeldItemVersion {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonMove {
    constructor(move: Handle.Named<Move>, versionGroupDetails: KtList<PokemonMoveVersion>);
    get move(): Handle.Named<Move>;
    get versionGroupDetails(): KtList<PokemonMoveVersion>;
    copy(move?: Handle.Named<Move>, versionGroupDetails?: KtList<PokemonMoveVersion>): PokemonMove;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonMove.$metadata$ {
    const constructor: abstract new () => PokemonMove;
}
export declare namespace PokemonMove {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonMoveVersion {
    constructor(moveLearnMethod: Handle.Named<MoveLearnMethod>, versionGroup: Handle.Named<VersionGroup>, levelLearnedAt: number, order: Nullable<number>);
    get moveLearnMethod(): Handle.Named<MoveLearnMethod>;
    get versionGroup(): Handle.Named<VersionGroup>;
    get levelLearnedAt(): number;
    get order(): Nullable<number>;
    copy(moveLearnMethod?: Handle.Named<MoveLearnMethod>, versionGroup?: Handle.Named<VersionGroup>, levelLearnedAt?: number, order?: Nullable<number>): PokemonMoveVersion;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonMoveVersion.$metadata$ {
    const constructor: abstract new () => PokemonMoveVersion;
}
export declare namespace PokemonMoveVersion {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonStat {
    constructor(stat: Handle.Named<Stat>, effort: number, baseStat: number);
    get stat(): Handle.Named<Stat>;
    get effort(): number;
    get baseStat(): number;
    copy(stat?: Handle.Named<Stat>, effort?: number, baseStat?: number): PokemonStat;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonStat.$metadata$ {
    const constructor: abstract new () => PokemonStat;
}
export declare namespace PokemonStat {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonType {
    constructor(slot: number, type: Handle.Named<Type>);
    get slot(): number;
    get type(): Handle.Named<Type>;
    copy(slot?: number, type?: Handle.Named<Type>): PokemonType;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonType.$metadata$ {
    const constructor: abstract new () => PokemonType;
}
export declare namespace PokemonType {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonPastType {
    constructor(generation: Handle.Named<Generation>, types: KtList<PokemonType>);
    get generation(): Handle.Named<Generation>;
    get types(): KtList<PokemonType>;
    copy(generation?: Handle.Named<Generation>, types?: KtList<PokemonType>): PokemonPastType;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonPastType.$metadata$ {
    const constructor: abstract new () => PokemonPastType;
}
export declare namespace PokemonPastType {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonPastAbility {
    constructor(generation: Handle.Named<Generation>, abilities: KtList<PokemonAbility>);
    get generation(): Handle.Named<Generation>;
    get abilities(): KtList<PokemonAbility>;
    copy(generation?: Handle.Named<Generation>, abilities?: KtList<PokemonAbility>): PokemonPastAbility;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonPastAbility.$metadata$ {
    const constructor: abstract new () => PokemonPastAbility;
}
export declare namespace PokemonPastAbility {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonCries {
    constructor(latest: string, legacy: Nullable<string>);
    get latest(): string;
    get legacy(): Nullable<string>;
    copy(latest?: string, legacy?: Nullable<string>): PokemonCries;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonCries.$metadata$ {
    const constructor: abstract new () => PokemonCries;
}
export declare namespace PokemonCries {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class LocationAreaEncounter {
    constructor(locationArea: Handle.Named<LocationArea>, versionDetails: KtList<VersionEncounterDetail>);
    get locationArea(): Handle.Named<LocationArea>;
    get versionDetails(): KtList<VersionEncounterDetail>;
    copy(locationArea?: Handle.Named<LocationArea>, versionDetails?: KtList<VersionEncounterDetail>): LocationAreaEncounter;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LocationAreaEncounter.$metadata$ {
    const constructor: abstract new () => LocationAreaEncounter;
}
export declare namespace LocationAreaEncounter {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonColor implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, names?: KtList<Name>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): PokemonColor;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonColor.$metadata$ {
    const constructor: abstract new () => PokemonColor;
}
export declare namespace PokemonColor {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonForm implements NamedModel {
    constructor(id: number, name: string, order: number, formOrder: number, isDefault: boolean, isBattleOnly: boolean, isMega: boolean, formName: string, pokemon: Handle.Named<PokemonVariety>, types: KtList<PokemonType>, sprites: PokemonFormSprites, versionGroup: Handle.Named<VersionGroup>, names: KtList<Name>, formNames: KtList<Name>);
    get id(): number;
    get name(): string;
    get order(): number;
    get formOrder(): number;
    get isDefault(): boolean;
    get isBattleOnly(): boolean;
    get isMega(): boolean;
    get formName(): string;
    get pokemon(): Handle.Named<PokemonVariety>;
    get types(): KtList<PokemonType>;
    get sprites(): PokemonFormSprites;
    get versionGroup(): Handle.Named<VersionGroup>;
    get names(): KtList<Name>;
    get formNames(): KtList<Name>;
    copy(id?: number, name?: string, order?: number, formOrder?: number, isDefault?: boolean, isBattleOnly?: boolean, isMega?: boolean, formName?: string, pokemon?: Handle.Named<PokemonVariety>, types?: KtList<PokemonType>, sprites?: PokemonFormSprites, versionGroup?: Handle.Named<VersionGroup>, names?: KtList<Name>, formNames?: KtList<Name>): PokemonForm;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonForm.$metadata$ {
    const constructor: abstract new () => PokemonForm;
}
export declare namespace PokemonForm {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonFormSprites {
    constructor(backDefault: Nullable<string>, backFemale: Nullable<string>, backShiny: Nullable<string>, backShinyFemale: Nullable<string>, frontDefault: Nullable<string>, frontFemale: Nullable<string>, frontShiny: Nullable<string>, frontShinyFemale: Nullable<string>);
    get backDefault(): Nullable<string>;
    get backFemale(): Nullable<string>;
    get backShiny(): Nullable<string>;
    get backShinyFemale(): Nullable<string>;
    get frontDefault(): Nullable<string>;
    get frontFemale(): Nullable<string>;
    get frontShiny(): Nullable<string>;
    get frontShinyFemale(): Nullable<string>;
    copy(backDefault?: Nullable<string>, backFemale?: Nullable<string>, backShiny?: Nullable<string>, backShinyFemale?: Nullable<string>, frontDefault?: Nullable<string>, frontFemale?: Nullable<string>, frontShiny?: Nullable<string>, frontShinyFemale?: Nullable<string>): PokemonFormSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonFormSprites.$metadata$ {
    const constructor: abstract new () => PokemonFormSprites;
}
export declare namespace PokemonFormSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonHabitat implements NamedModel {
    constructor(id: number, name: string, names: KtList<Name>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get names(): KtList<Name>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, names?: KtList<Name>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): PokemonHabitat;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonHabitat.$metadata$ {
    const constructor: abstract new () => PokemonHabitat;
}
export declare namespace PokemonHabitat {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonShape implements NamedModel {
    constructor(id: number, name: string, awesomeNames: KtList<AwesomeName>, names: KtList<Name>, pokemonSpecies: KtList<Handle.Named<PokemonSpecies>>);
    get id(): number;
    get name(): string;
    get awesomeNames(): KtList<AwesomeName>;
    get names(): KtList<Name>;
    get pokemonSpecies(): KtList<Handle.Named<PokemonSpecies>>;
    copy(id?: number, name?: string, awesomeNames?: KtList<AwesomeName>, names?: KtList<Name>, pokemonSpecies?: KtList<Handle.Named<PokemonSpecies>>): PokemonShape;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonShape.$metadata$ {
    const constructor: abstract new () => PokemonShape;
}
export declare namespace PokemonShape {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class AwesomeName {
    constructor(awesomeName: string, language: Handle.Named<Language>);
    get awesomeName(): string;
    get language(): Handle.Named<Language>;
    copy(awesomeName?: string, language?: Handle.Named<Language>): AwesomeName;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AwesomeName.$metadata$ {
    const constructor: abstract new () => AwesomeName;
}
export declare namespace AwesomeName {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSpecies implements NamedModel {
    constructor(id: number, name: string, order: number, genderRate: number, captureRate: number, baseHappiness: number, isBaby: boolean, isLegendary: Nullable<boolean> | undefined, isMythical: Nullable<boolean> | undefined, hatchCounter: number, hasGenderDifferences: boolean, formsSwitchable: boolean, growthRate: Handle.Named<GrowthRate>, pokedexNumbers: KtList<PokemonSpeciesDexEntry>, eggGroups: KtList<Handle.Named<EggGroup>>, color: Handle.Named<PokemonColor>, shape: Handle.Named<PokemonShape>, evolvesFromSpecies: Nullable<Handle.Named<PokemonSpecies>>, evolutionChain: Handle.Unnamed<EvolutionChain>, habitat: Nullable<Handle.Named<PokemonHabitat>>, generation: Handle.Named<Generation>, names: KtList<Name>, palParkEncounters: KtList<PalParkEncounterArea>, formDescriptions: KtList<Description>, genera: KtList<Genus>, varieties: KtList<PokemonSpeciesVariety>, flavorTextEntries: KtList<PokemonSpeciesFlavorText>);
    get id(): number;
    get name(): string;
    get order(): number;
    get genderRate(): number;
    get captureRate(): number;
    get baseHappiness(): number;
    get isBaby(): boolean;
    get isLegendary(): Nullable<boolean>;
    get isMythical(): Nullable<boolean>;
    get hatchCounter(): number;
    get hasGenderDifferences(): boolean;
    get formsSwitchable(): boolean;
    get growthRate(): Handle.Named<GrowthRate>;
    get pokedexNumbers(): KtList<PokemonSpeciesDexEntry>;
    get eggGroups(): KtList<Handle.Named<EggGroup>>;
    get color(): Handle.Named<PokemonColor>;
    get shape(): Handle.Named<PokemonShape>;
    get evolvesFromSpecies(): Nullable<Handle.Named<PokemonSpecies>>;
    get evolutionChain(): Handle.Unnamed<EvolutionChain>;
    get habitat(): Nullable<Handle.Named<PokemonHabitat>>;
    get generation(): Handle.Named<Generation>;
    get names(): KtList<Name>;
    get palParkEncounters(): KtList<PalParkEncounterArea>;
    get formDescriptions(): KtList<Description>;
    get genera(): KtList<Genus>;
    get varieties(): KtList<PokemonSpeciesVariety>;
    get flavorTextEntries(): KtList<PokemonSpeciesFlavorText>;
    copy(id?: number, name?: string, order?: number, genderRate?: number, captureRate?: number, baseHappiness?: number, isBaby?: boolean, isLegendary?: Nullable<boolean>, isMythical?: Nullable<boolean>, hatchCounter?: number, hasGenderDifferences?: boolean, formsSwitchable?: boolean, growthRate?: Handle.Named<GrowthRate>, pokedexNumbers?: KtList<PokemonSpeciesDexEntry>, eggGroups?: KtList<Handle.Named<EggGroup>>, color?: Handle.Named<PokemonColor>, shape?: Handle.Named<PokemonShape>, evolvesFromSpecies?: Nullable<Handle.Named<PokemonSpecies>>, evolutionChain?: Handle.Unnamed<EvolutionChain>, habitat?: Nullable<Handle.Named<PokemonHabitat>>, generation?: Handle.Named<Generation>, names?: KtList<Name>, palParkEncounters?: KtList<PalParkEncounterArea>, formDescriptions?: KtList<Description>, genera?: KtList<Genus>, varieties?: KtList<PokemonSpeciesVariety>, flavorTextEntries?: KtList<PokemonSpeciesFlavorText>): PokemonSpecies;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSpecies.$metadata$ {
    const constructor: abstract new () => PokemonSpecies;
}
export declare namespace PokemonSpecies {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSpeciesFlavorText {
    constructor(flavorText: string, language: Handle.Named<Language>, version: Handle.Named<Version>);
    get flavorText(): string;
    get language(): Handle.Named<Language>;
    get version(): Handle.Named<Version>;
    copy(flavorText?: string, language?: Handle.Named<Language>, version?: Handle.Named<Version>): PokemonSpeciesFlavorText;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSpeciesFlavorText.$metadata$ {
    const constructor: abstract new () => PokemonSpeciesFlavorText;
}
export declare namespace PokemonSpeciesFlavorText {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Genus {
    constructor(genus: string, language: Handle.Named<Language>);
    get genus(): string;
    get language(): Handle.Named<Language>;
    copy(genus?: string, language?: Handle.Named<Language>): Genus;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Genus.$metadata$ {
    const constructor: abstract new () => Genus;
}
export declare namespace Genus {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSpeciesDexEntry {
    constructor(entryNumber: number, pokedex: Handle.Named<Pokedex>);
    get entryNumber(): number;
    get pokedex(): Handle.Named<Pokedex>;
    copy(entryNumber?: number, pokedex?: Handle.Named<Pokedex>): PokemonSpeciesDexEntry;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSpeciesDexEntry.$metadata$ {
    const constructor: abstract new () => PokemonSpeciesDexEntry;
}
export declare namespace PokemonSpeciesDexEntry {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PalParkEncounterArea {
    constructor(baseScore: number, rate: number, area: Handle.Named<PalParkArea>);
    get baseScore(): number;
    get rate(): number;
    get area(): Handle.Named<PalParkArea>;
    copy(baseScore?: number, rate?: number, area?: Handle.Named<PalParkArea>): PalParkEncounterArea;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PalParkEncounterArea.$metadata$ {
    const constructor: abstract new () => PalParkEncounterArea;
}
export declare namespace PalParkEncounterArea {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PokemonSpeciesVariety {
    constructor(isDefault: boolean, variety: Handle.Named<PokemonVariety>);
    get isDefault(): boolean;
    get variety(): Handle.Named<PokemonVariety>;
    copy(isDefault?: boolean, variety?: Handle.Named<PokemonVariety>): PokemonSpeciesVariety;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PokemonSpeciesVariety.$metadata$ {
    const constructor: abstract new () => PokemonSpeciesVariety;
}
export declare namespace PokemonSpeciesVariety {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Stat implements NamedModel {
    constructor(id: number, name: string, gameIndex: number, isBattleOnly: boolean, affectingMoves: MoveStatAffectSets, affectingNatures: NatureStatAffectSets, characteristics: KtList<Handle.Unnamed<Characteristic>>, moveDamageClass: Nullable<Handle.Named<MoveDamageClass>>, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get gameIndex(): number;
    get isBattleOnly(): boolean;
    get affectingMoves(): MoveStatAffectSets;
    get affectingNatures(): NatureStatAffectSets;
    get characteristics(): KtList<Handle.Unnamed<Characteristic>>;
    get moveDamageClass(): Nullable<Handle.Named<MoveDamageClass>>;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, gameIndex?: number, isBattleOnly?: boolean, affectingMoves?: MoveStatAffectSets, affectingNatures?: NatureStatAffectSets, characteristics?: KtList<Handle.Unnamed<Characteristic>>, moveDamageClass?: Nullable<Handle.Named<MoveDamageClass>>, names?: KtList<Name>): Stat;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Stat.$metadata$ {
    const constructor: abstract new () => Stat;
}
export declare namespace Stat {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveStatAffectSets {
    constructor(increase: KtList<MoveStatAffect>, decrease: KtList<MoveStatAffect>);
    get increase(): KtList<MoveStatAffect>;
    get decrease(): KtList<MoveStatAffect>;
    copy(increase?: KtList<MoveStatAffect>, decrease?: KtList<MoveStatAffect>): MoveStatAffectSets;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveStatAffectSets.$metadata$ {
    const constructor: abstract new () => MoveStatAffectSets;
}
export declare namespace MoveStatAffectSets {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MoveStatAffect {
    constructor(change: number, move: Handle.Named<Move>);
    get change(): number;
    get move(): Handle.Named<Move>;
    copy(change?: number, move?: Handle.Named<Move>): MoveStatAffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MoveStatAffect.$metadata$ {
    const constructor: abstract new () => MoveStatAffect;
}
export declare namespace MoveStatAffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class NatureStatAffectSets {
    constructor(increase: KtList<Handle.Named<Nature>>, decrease: KtList<Handle.Named<Nature>>);
    get increase(): KtList<Handle.Named<Nature>>;
    get decrease(): KtList<Handle.Named<Nature>>;
    copy(increase?: KtList<Handle.Named<Nature>>, decrease?: KtList<Handle.Named<Nature>>): NatureStatAffectSets;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NatureStatAffectSets.$metadata$ {
    const constructor: abstract new () => NatureStatAffectSets;
}
export declare namespace NatureStatAffectSets {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Type implements NamedModel {
    constructor(id: number, name: string, damageRelations: TypeRelations, pastDamageRelations: KtList<TypePastDamageRelation>, gameIndices: KtList<GenerationGameIndex>, generation: Handle.Named<Generation>, moveDamageClass: Nullable<Handle.Named<MoveDamageClass>>, names: KtList<Name>, pokemon: KtList<TypePokemon>, moves: KtList<Handle.Named<Move>>, sprites: VersionTypeSprites);
    get id(): number;
    get name(): string;
    get damageRelations(): TypeRelations;
    get pastDamageRelations(): KtList<TypePastDamageRelation>;
    get gameIndices(): KtList<GenerationGameIndex>;
    get generation(): Handle.Named<Generation>;
    get moveDamageClass(): Nullable<Handle.Named<MoveDamageClass>>;
    get names(): KtList<Name>;
    get pokemon(): KtList<TypePokemon>;
    get moves(): KtList<Handle.Named<Move>>;
    get sprites(): VersionTypeSprites;
    copy(id?: number, name?: string, damageRelations?: TypeRelations, pastDamageRelations?: KtList<TypePastDamageRelation>, gameIndices?: KtList<GenerationGameIndex>, generation?: Handle.Named<Generation>, moveDamageClass?: Nullable<Handle.Named<MoveDamageClass>>, names?: KtList<Name>, pokemon?: KtList<TypePokemon>, moves?: KtList<Handle.Named<Move>>, sprites?: VersionTypeSprites): Type;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Type.$metadata$ {
    const constructor: abstract new () => Type;
}
export declare namespace Type {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionTypeSprites {
    constructor(generationIii: GenerationIiiTypeSprites, generationIv: GenerationIvTypeSprites, generationV: GenerationVTypeSprites, generationVi: GenerationViTypeSprites, generationVii: GenerationViiTypeSprites, generationViii: GenerationViiiTypeSprites, generationIx: GenerationIxTypeSprites);
    get generationIii(): GenerationIiiTypeSprites;
    get generationIv(): GenerationIvTypeSprites;
    get generationV(): GenerationVTypeSprites;
    get generationVi(): GenerationViTypeSprites;
    get generationVii(): GenerationViiTypeSprites;
    get generationViii(): GenerationViiiTypeSprites;
    get generationIx(): GenerationIxTypeSprites;
    copy(generationIii?: GenerationIiiTypeSprites, generationIv?: GenerationIvTypeSprites, generationV?: GenerationVTypeSprites, generationVi?: GenerationViTypeSprites, generationVii?: GenerationViiTypeSprites, generationViii?: GenerationViiiTypeSprites, generationIx?: GenerationIxTypeSprites): VersionTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionTypeSprites.$metadata$ {
    const constructor: abstract new () => VersionTypeSprites;
}
export declare namespace VersionTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIiiTypeSprites {
    constructor(colosseum: TypeSprites, emerald: TypeSprites, fireredLeafgreen: TypeSprites, rubySaphire: TypeSprites, xd: TypeSprites);
    get colosseum(): TypeSprites;
    get emerald(): TypeSprites;
    get fireredLeafgreen(): TypeSprites;
    get rubySaphire(): TypeSprites;
    get xd(): TypeSprites;
    copy(colosseum?: TypeSprites, emerald?: TypeSprites, fireredLeafgreen?: TypeSprites, rubySaphire?: TypeSprites, xd?: TypeSprites): GenerationIiiTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIiiTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationIiiTypeSprites;
}
export declare namespace GenerationIiiTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIvTypeSprites {
    constructor(diamondPearl: TypeSprites, heartgoldSoulsilver: TypeSprites, platinum: TypeSprites);
    get diamondPearl(): TypeSprites;
    get heartgoldSoulsilver(): TypeSprites;
    get platinum(): TypeSprites;
    copy(diamondPearl?: TypeSprites, heartgoldSoulsilver?: TypeSprites, platinum?: TypeSprites): GenerationIvTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIvTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationIvTypeSprites;
}
export declare namespace GenerationIvTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationVTypeSprites {
    constructor(black2White2: TypeSprites, blackWhite: TypeSprites);
    get black2White2(): TypeSprites;
    get blackWhite(): TypeSprites;
    copy(black2White2?: TypeSprites, blackWhite?: TypeSprites): GenerationVTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationVTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationVTypeSprites;
}
export declare namespace GenerationVTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViTypeSprites {
    constructor(omegaRubyAlphaSapphire: TypeSprites, xY: TypeSprites);
    get omegaRubyAlphaSapphire(): TypeSprites;
    get xY(): TypeSprites;
    copy(omegaRubyAlphaSapphire?: TypeSprites, xY?: TypeSprites): GenerationViTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationViTypeSprites;
}
export declare namespace GenerationViTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViiTypeSprites {
    constructor(letsGoPikachuLetsGoEevee: TypeSprites, sunMoon: TypeSprites, ultraSunUltraMoon: TypeSprites);
    get letsGoPikachuLetsGoEevee(): TypeSprites;
    get sunMoon(): TypeSprites;
    get ultraSunUltraMoon(): TypeSprites;
    copy(letsGoPikachuLetsGoEevee?: TypeSprites, sunMoon?: TypeSprites, ultraSunUltraMoon?: TypeSprites): GenerationViiTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViiTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationViiTypeSprites;
}
export declare namespace GenerationViiTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationViiiTypeSprites {
    constructor(brilliantDiamondAndShiningPearl: TypeSprites, legendsArceus: TypeSprites, swordShield: TypeSprites);
    get brilliantDiamondAndShiningPearl(): TypeSprites;
    get legendsArceus(): TypeSprites;
    get swordShield(): TypeSprites;
    copy(brilliantDiamondAndShiningPearl?: TypeSprites, legendsArceus?: TypeSprites, swordShield?: TypeSprites): GenerationViiiTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationViiiTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationViiiTypeSprites;
}
export declare namespace GenerationViiiTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationIxTypeSprites {
    constructor(scarletViolet: TypeSprites);
    get scarletViolet(): TypeSprites;
    copy(scarletViolet?: TypeSprites): GenerationIxTypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationIxTypeSprites.$metadata$ {
    const constructor: abstract new () => GenerationIxTypeSprites;
}
export declare namespace GenerationIxTypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class TypeSprites {
    constructor(nameIcon: Nullable<string>);
    get nameIcon(): Nullable<string>;
    copy(nameIcon?: Nullable<string>): TypeSprites;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeSprites.$metadata$ {
    const constructor: abstract new () => TypeSprites;
}
export declare namespace TypeSprites {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class TypePokemon {
    constructor(slot: number, pokemon: Handle.Named<PokemonVariety>);
    get slot(): number;
    get pokemon(): Handle.Named<PokemonVariety>;
    copy(slot?: number, pokemon?: Handle.Named<PokemonVariety>): TypePokemon;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypePokemon.$metadata$ {
    const constructor: abstract new () => TypePokemon;
}
export declare namespace TypePokemon {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class TypeRelations {
    constructor(noDamageTo: KtList<Handle.Named<Type>>, halfDamageTo: KtList<Handle.Named<Type>>, doubleDamageTo: KtList<Handle.Named<Type>>, noDamageFrom: KtList<Handle.Named<Type>>, halfDamageFrom: KtList<Handle.Named<Type>>, doubleDamageFrom: KtList<Handle.Named<Type>>);
    get noDamageTo(): KtList<Handle.Named<Type>>;
    get halfDamageTo(): KtList<Handle.Named<Type>>;
    get doubleDamageTo(): KtList<Handle.Named<Type>>;
    get noDamageFrom(): KtList<Handle.Named<Type>>;
    get halfDamageFrom(): KtList<Handle.Named<Type>>;
    get doubleDamageFrom(): KtList<Handle.Named<Type>>;
    copy(noDamageTo?: KtList<Handle.Named<Type>>, halfDamageTo?: KtList<Handle.Named<Type>>, doubleDamageTo?: KtList<Handle.Named<Type>>, noDamageFrom?: KtList<Handle.Named<Type>>, halfDamageFrom?: KtList<Handle.Named<Type>>, doubleDamageFrom?: KtList<Handle.Named<Type>>): TypeRelations;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeRelations.$metadata$ {
    const constructor: abstract new () => TypeRelations;
}
export declare namespace TypeRelations {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class TypePastDamageRelation {
    constructor(generation: Handle.Named<Generation>, damageRelations: TypeRelations);
    get generation(): Handle.Named<Generation>;
    get damageRelations(): TypeRelations;
    copy(generation?: Handle.Named<Generation>, damageRelations?: TypeRelations): TypePastDamageRelation;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypePastDamageRelation.$metadata$ {
    const constructor: abstract new () => TypePastDamageRelation;
}
export declare namespace TypePastDamageRelation {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare abstract class Handle<T extends Model> {
    protected constructor();
    get id(): number;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Handle.$metadata$ {
    const constructor: abstract new <T extends Model>() => Handle<T>;
}
export declare namespace Handle {
    class Unnamed<T extends Model> extends Handle.$metadata$.constructor<T> {
        private constructor();
        copy$default(url?: string): Handle.Unnamed<T>;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Unnamed.$metadata$ {
        const constructor: abstract new <T extends Model>() => Unnamed<T>;
    }
    namespace Unnamed {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor /* implements SerializerFactory */ {
                private constructor();
            }
        }
    }
    class Named<T extends NamedModel> extends Handle.$metadata$.constructor<T> {
        private constructor();
        get name(): string;
        copy$default(url?: string, name?: string): Handle.Named<T>;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Named.$metadata$ {
        const constructor: abstract new <T extends NamedModel>() => Named<T>;
    }
    namespace Named {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor /* implements SerializerFactory */ {
                private constructor();
            }
        }
    }
}
export declare abstract class PaginatedList<T extends Model> {
    protected constructor();
    abstract get count(): number;
    abstract get next(): Nullable<string>;
    abstract get previous(): Nullable<string>;
    abstract get results(): KtList<Handle<T>>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PaginatedList.$metadata$ {
    const constructor: abstract new <T extends Model>() => PaginatedList<T>;
}
export declare namespace PaginatedList {
    class Unnamed<T extends Model> extends PaginatedList.$metadata$.constructor<T> {
        private constructor();
        get count(): number;
        get next(): Nullable<string>;
        get previous(): Nullable<string>;
        get results(): KtList<Handle.Unnamed<T>>;
        copy$default(count?: number, next?: Nullable<string>, previous?: Nullable<string>, results?: KtList<Handle.Unnamed<T>>): PaginatedList.Unnamed<T>;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Unnamed.$metadata$ {
        const constructor: abstract new <T extends Model>() => Unnamed<T>;
    }
    namespace Unnamed {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor /* implements SerializerFactory */ {
                get $cachedDescriptor(): any/* SerialDescriptor */;
                private constructor();
            }
        }
    }
    class Named<T extends NamedModel> extends PaginatedList.$metadata$.constructor<T> {
        private constructor();
        get count(): number;
        get next(): Nullable<string>;
        get previous(): Nullable<string>;
        get results(): KtList<Handle.Named<T>>;
        copy$default(count?: number, next?: Nullable<string>, previous?: Nullable<string>, results?: KtList<Handle.Named<T>>): PaginatedList.Named<T>;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Named.$metadata$ {
        const constructor: abstract new <T extends NamedModel>() => Named<T>;
    }
    namespace Named {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor /* implements SerializerFactory */ {
                get $cachedDescriptor(): any/* SerialDescriptor */;
                private constructor();
            }
        }
    }
}
export declare class Language implements NamedModel {
    constructor(id: number, name: string, official: boolean, iso639: string, iso3166: string, names: KtList<Name>);
    get id(): number;
    get name(): string;
    get official(): boolean;
    get iso639(): string;
    get iso3166(): string;
    get names(): KtList<Name>;
    copy(id?: number, name?: string, official?: boolean, iso639?: string, iso3166?: string, names?: KtList<Name>): Language;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: NamedModel["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Language.$metadata$ {
    const constructor: abstract new () => Language;
}
export declare namespace Language {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Description {
    constructor(description: string, language: Handle.Named<Language>);
    get description(): string;
    get language(): Handle.Named<Language>;
    copy(description?: string, language?: Handle.Named<Language>): Description;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Description.$metadata$ {
    const constructor: abstract new () => Description;
}
export declare namespace Description {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Effect {
    constructor(effect: string, language: Handle.Named<Language>);
    get effect(): string;
    get language(): Handle.Named<Language>;
    copy(effect?: string, language?: Handle.Named<Language>): Effect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Effect.$metadata$ {
    const constructor: abstract new () => Effect;
}
export declare namespace Effect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Encounter {
    constructor(minLevel: number, maxLevel: number, conditionValues: KtList<Handle.Named<EncounterConditionValue>>, chance: number, method: Handle.Named<EncounterMethod>);
    get minLevel(): number;
    get maxLevel(): number;
    get conditionValues(): KtList<Handle.Named<EncounterConditionValue>>;
    get chance(): number;
    get method(): Handle.Named<EncounterMethod>;
    copy(minLevel?: number, maxLevel?: number, conditionValues?: KtList<Handle.Named<EncounterConditionValue>>, chance?: number, method?: Handle.Named<EncounterMethod>): Encounter;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Encounter.$metadata$ {
    const constructor: abstract new () => Encounter;
}
export declare namespace Encounter {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class FlavorText {
    constructor(flavorText: string, language: Handle.Named<Language>);
    get flavorText(): string;
    get language(): Handle.Named<Language>;
    copy(flavorText?: string, language?: Handle.Named<Language>): FlavorText;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FlavorText.$metadata$ {
    const constructor: abstract new () => FlavorText;
}
export declare namespace FlavorText {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class GenerationGameIndex {
    constructor(gameIndex: number, generation: Handle.Named<Generation>);
    get gameIndex(): number;
    get generation(): Handle.Named<Generation>;
    copy(gameIndex?: number, generation?: Handle.Named<Generation>): GenerationGameIndex;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GenerationGameIndex.$metadata$ {
    const constructor: abstract new () => GenerationGameIndex;
}
export declare namespace GenerationGameIndex {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class MachineVersionDetail {
    constructor(machine: Handle.Unnamed<Machine>, versionGroup: Handle.Named<VersionGroup>);
    get machine(): Handle.Unnamed<Machine>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(machine?: Handle.Unnamed<Machine>, versionGroup?: Handle.Named<VersionGroup>): MachineVersionDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MachineVersionDetail.$metadata$ {
    const constructor: abstract new () => MachineVersionDetail;
}
export declare namespace MachineVersionDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class Name {
    constructor(name: string, language: Handle.Named<Language>);
    get name(): string;
    get language(): Handle.Named<Language>;
    copy(name?: string, language?: Handle.Named<Language>): Name;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Name.$metadata$ {
    const constructor: abstract new () => Name;
}
export declare namespace Name {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VerboseEffect {
    constructor(effect: string, shortEffect: string, language: Handle.Named<Language>);
    get effect(): string;
    get shortEffect(): string;
    get language(): Handle.Named<Language>;
    copy(effect?: string, shortEffect?: string, language?: Handle.Named<Language>): VerboseEffect;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VerboseEffect.$metadata$ {
    const constructor: abstract new () => VerboseEffect;
}
export declare namespace VerboseEffect {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionEncounterDetail {
    constructor(version: Handle.Named<Version>, maxChance: number, encounterDetails: KtList<Encounter>);
    get version(): Handle.Named<Version>;
    get maxChance(): number;
    get encounterDetails(): KtList<Encounter>;
    copy(version?: Handle.Named<Version>, maxChance?: number, encounterDetails?: KtList<Encounter>): VersionEncounterDetail;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionEncounterDetail.$metadata$ {
    const constructor: abstract new () => VersionEncounterDetail;
}
export declare namespace VersionEncounterDetail {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionGameIndex {
    constructor(gameIndex: number, version: Handle.Named<Version>);
    get gameIndex(): number;
    get version(): Handle.Named<Version>;
    copy(gameIndex?: number, version?: Handle.Named<Version>): VersionGameIndex;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionGameIndex.$metadata$ {
    const constructor: abstract new () => VersionGameIndex;
}
export declare namespace VersionGameIndex {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class VersionGroupFlavorText {
    constructor(text: string, language: Handle.Named<Language>, versionGroup: Handle.Named<VersionGroup>);
    get text(): string;
    get language(): Handle.Named<Language>;
    get versionGroup(): Handle.Named<VersionGroup>;
    copy(text?: string, language?: Handle.Named<Language>, versionGroup?: Handle.Named<VersionGroup>): VersionGroupFlavorText;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VersionGroupFlavorText.$metadata$ {
    const constructor: abstract new () => VersionGroupFlavorText;
}
export declare namespace VersionGroupFlavorText {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}