import { Token, ToriiClient, TokenContract, TokenBalance } from '@dojoengine/torii-wasm/types';
import { BigNumberish, constants, RpcProvider } from 'starknet';
import { SchemaType as SchemaType$1, ParsedEntity, SDK, ToriiQueryBuilder } from '@dojoengine/sdk';

interface Account {
    id: BigNumberish;
    controllers: BigNumberish;
    name: BigNumberish;
    username: BigNumberish;
    socials: string;
    credits: BigNumberish;
}
interface Controller {
    account_id: BigNumberish;
    id: BigNumberish;
    signers: BigNumberish;
    address: BigNumberish;
    network: BigNumberish;
    constructor_calldata: string;
}
interface Signer {
    account_id: BigNumberish;
    controller_id: BigNumberish;
    method: BigNumberish;
    metadata: string;
}
interface Book {
    id: BigNumberish;
    version: BigNumberish;
    paused: boolean;
    royalties: boolean;
    counter: BigNumberish;
    fee_num: BigNumberish;
    fee_receiver: BigNumberish;
}
interface MetadataAttribute {
    identity: string;
    collection: BigNumberish;
    token_id: BigNumberish;
    index: BigNumberish;
    trait_type: string;
    value: string;
}
interface Moderator {
    address: BigNumberish;
    role: BigNumberish;
}
interface Order$1 {
    id: BigNumberish;
    collection: BigNumberish;
    token_id: BigNumberish;
    royalties: boolean;
    category: BigNumberish;
    status: BigNumberish;
    expiration: BigNumberish;
    quantity: BigNumberish;
    price: BigNumberish;
    currency: BigNumberish;
    owner: BigNumberish;
}
interface Deployment {
    service: BigNumberish;
    project: BigNumberish;
    status: BigNumberish;
    tier: BigNumberish;
    config: string;
}
interface Factory {
    id: BigNumberish;
    version: BigNumberish;
    default_version: BigNumberish;
}
interface Team {
    id: BigNumberish;
    deployment_count: BigNumberish;
    time: BigNumberish;
    name: BigNumberish;
    description: string;
}
interface Teammate {
    team_id: BigNumberish;
    time: BigNumberish;
    account_id: BigNumberish;
    role: BigNumberish;
}
interface Access {
    address: BigNumberish;
    role: BigNumberish;
}
interface Collection$1 {
    id: BigNumberish;
    uuid: BigNumberish;
    contract_address: string;
}
interface CollectionEdition {
    collection: BigNumberish;
    edition: BigNumberish;
    active: boolean;
}
interface Edition {
    id: BigNumberish;
    world_address: BigNumberish;
    namespace: BigNumberish;
    published: boolean;
    whitelisted: boolean;
    priority: BigNumberish;
    game_id: BigNumberish;
    config: string;
    color: string;
    image: string;
    image_data: string;
    external_url: string;
    description: string;
    name: string;
    animation_url: string;
    youtube_url: string;
    attributes: string;
    properties: string;
    socials: string;
}
interface Game {
    id: BigNumberish;
    published: boolean;
    whitelisted: boolean;
    color: string;
    image: string;
    image_data: string;
    external_url: string;
    description: string;
    name: string;
    animation_url: string;
    youtube_url: string;
    attributes: string;
    properties: string;
    socials: string;
}
interface Unicity {
    world_address: BigNumberish;
    namespace: BigNumberish;
    token_id: BigNumberish;
}
interface Alliance {
    id: BigNumberish;
    open: boolean;
    free: boolean;
    guild_count: BigNumberish;
    metadata: string;
    socials: string;
}
interface Guild {
    id: BigNumberish;
    open: boolean;
    free: boolean;
    role: BigNumberish;
    member_count: BigNumberish;
    alliance_id: BigNumberish;
    pending_alliance_id: BigNumberish;
    metadata: string;
    socials: string;
}
interface Member {
    id: BigNumberish;
    role: BigNumberish;
    guild_id: BigNumberish;
    pending_guild_id: BigNumberish;
}
interface TrophyPinning {
    player_id: BigNumberish;
    achievement_id: BigNumberish;
    time: BigNumberish;
}
interface Listing {
    order_id: BigNumberish;
    order: Order$1;
    time: BigNumberish;
}
interface Offer {
    order_id: BigNumberish;
    order: Order$1;
    time: BigNumberish;
}
interface Sale {
    order_id: BigNumberish;
    order: Order$1;
    from: BigNumberish;
    to: BigNumberish;
    time: BigNumberish;
}
interface Follow {
    follower: BigNumberish;
    followed: BigNumberish;
    time: BigNumberish;
}
interface SchemaType extends SchemaType$1 {
    arcade: {
        Account: Account;
        Controller: Controller;
        Signer: Signer;
        Book: Book;
        MetadataAttribute: MetadataAttribute;
        Moderator: Moderator;
        Order: Order$1;
        Deployment: Deployment;
        Factory: Factory;
        Team: Team;
        Teammate: Teammate;
        Access: Access;
        Collection: Collection$1;
        CollectionEdition: CollectionEdition;
        Edition: Edition;
        Game: Game;
        Unicity: Unicity;
        Alliance: Alliance;
        Guild: Guild;
        Member: Member;
        TrophyPinning: TrophyPinning;
        Listing: Listing;
        Offer: Offer;
        Sale: Sale;
        Follow: Follow;
    };
}

declare enum CategoryType {
    None = "None",
    Buy = "Buy",
    Sell = "Sell"
}
declare class Category {
    value: CategoryType;
    constructor(value: CategoryType);
    into(): number;
    static from(index: number): Category;
}

declare enum StatusType {
    None = "None",
    Placed = "Placed",
    Canceled = "Canceled",
    Executed = "Executed"
}
declare class Status {
    value: StatusType;
    constructor(value: StatusType);
    into(): number;
    static from(index: number): Status;
}

declare enum RoleType {
    None = "None",
    Member = "Member",
    Admin = "Admin",
    Owner = "Owner"
}
declare class Role {
    value: RoleType;
    constructor(value: RoleType);
    into(): number;
    static from(index: number): Role;
}

interface ModeratorInterface {
    address: string;
    role: number;
}
declare class ModeratorModel {
    identifier: string;
    address: string;
    role: Role;
    type: string;
    constructor(identifier: string, address: string, role: Role);
    static from(identifier: string, model: ModeratorInterface): ModeratorModel;
    static default(identifier: string): ModeratorModel;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): ModeratorModel;
}

interface BookInterface {
    id: number;
    version: number;
    paused: boolean;
    counter: number;
    fee_num: number;
    fee_receiver: string;
}
declare class BookModel {
    identifier: string;
    id: number;
    version: number;
    paused: boolean;
    counter: number;
    fee_num: number;
    fee_receiver: string;
    type: string;
    constructor(identifier: string, id: number, version: number, paused: boolean, counter: number, fee_num: number, fee_receiver: string);
    static from(identifier: string, model: BookInterface): BookModel;
    static default(identifier: string): BookModel;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): BookModel;
}

interface OrderInterface {
    id: number;
    category: number;
    status: number;
    expiration: number;
    collection: string;
    token_id: number;
    quantity: number;
    price: number;
    currency: string;
    owner: string;
}
declare class OrderModel {
    identifier: string;
    id: number;
    category: Category;
    status: Status;
    expiration: number;
    collection: string;
    tokenId: number;
    quantity: number;
    price: number;
    currency: string;
    owner: string;
    type: string;
    constructor(identifier: string, id: number, category: Category, status: Status, expiration: number, collection: string, tokenId: number, quantity: number, price: number, currency: string, owner: string);
    static from(identifier: string, model: OrderInterface): OrderModel;
    static default(identifier: string): OrderModel;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): OrderModel;
}
declare const Order: {
    parse: (entity: ParsedEntity<SchemaType>) => OrderModel;
    getModelName: () => string;
    getMethods: () => {
        name: string;
        entrypoint: string;
        description: string;
    }[];
};

interface ListingInterface {
    order_id: number;
    order: OrderInterface;
    time: number;
}
declare class ListingEvent {
    identifier: string;
    id: number;
    order: OrderModel;
    time: number;
    type: string;
    constructor(identifier: string, id: number, order: OrderModel, time: number);
    static from(identifier: string, model: ListingInterface): ListingEvent;
    static default(identifier: string): ListingEvent;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): ListingEvent;
}

interface OfferInterface {
    order_id: number;
    order: OrderInterface;
    time: number;
}
declare class OfferEvent {
    identifier: string;
    id: number;
    order: OrderModel;
    time: number;
    type: string;
    constructor(identifier: string, id: number, order: OrderModel, time: number);
    static from(identifier: string, model: OfferInterface): OfferEvent;
    static default(identifier: string): OfferEvent;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): OfferEvent;
}

interface SaleInterface {
    order_id: number;
    order: OrderInterface;
    from: string;
    to: string;
    time: number;
}
declare class SaleEvent {
    identifier: string;
    id: number;
    order: OrderModel;
    from: string;
    to: string;
    time: number;
    type: string;
    constructor(identifier: string, id: number, order: OrderModel, from: string, to: string, time: number);
    static from(identifier: string, model: SaleInterface): SaleEvent;
    static default(identifier: string): SaleEvent;
    static isType(model: MarketplaceModel): boolean;
    exists(): boolean;
    clone(): SaleEvent;
}

type MarketplaceOptions = {
    access?: boolean;
    book?: boolean;
    order?: boolean;
    listing?: boolean;
    offer?: boolean;
    sale?: boolean;
};

type MarketplaceModel = ModeratorModel | BookModel | OrderModel | ListingEvent | OfferEvent | SaleEvent;

type WithCount<T> = T & {
    count: number;
};
type Collection = Record<string, WithCount<Token>>;
type Collections = Record<string, Collection>;
declare const Marketplace: {
    sdk: SDK<SchemaType> | undefined;
    unsubEntities: (() => void) | undefined;
    init: (chainId: constants.StarknetChainId) => Promise<void>;
    isEntityQueryable(options: MarketplaceOptions): boolean | undefined;
    isEventQueryable(options: MarketplaceOptions): boolean | undefined;
    getEntityQuery: (options?: MarketplaceOptions) => ToriiQueryBuilder<SchemaType>;
    getEventQuery: (options?: MarketplaceOptions) => ToriiQueryBuilder<SchemaType>;
    fetchEntities: (callback: (models: MarketplaceModel[]) => void, options: MarketplaceOptions) => Promise<void>;
    fetchEvents: (callback: (models: MarketplaceModel[]) => void, options: MarketplaceOptions) => Promise<void>;
    subEntities: (callback: (models: MarketplaceModel[]) => void, options: MarketplaceOptions) => Promise<void>;
    subEvents: (callback: (models: MarketplaceModel[]) => void, options: MarketplaceOptions) => Promise<void>;
    fetch: (callback: (models: MarketplaceModel[]) => void, options?: MarketplaceOptions) => Promise<void>;
    sub: (callback: (models: MarketplaceModel[]) => void, options?: MarketplaceOptions) => Promise<void>;
    unsub: () => void;
    fetchCollections: (clients: {
        [key: string]: ToriiClient;
    }, limit?: number) => Promise<Collections>;
};

type MarketplaceRuntimeMode = "dojo" | "edge" | "auto";
type ResolvedMarketplaceRuntimeMode = Exclude<MarketplaceRuntimeMode, "auto">;
interface ToriiTransport {
    getToriiUrl: (projectId: string) => string;
}
interface MarketplaceReadRuntime {
    mode: ResolvedMarketplaceRuntimeMode;
    transport?: ToriiTransport;
}
declare const resolveMarketplaceRuntimeMode: (mode?: MarketplaceRuntimeMode) => ResolvedMarketplaceRuntimeMode;
declare const getMarketplaceClientRuntimeMode: (mode?: MarketplaceRuntimeMode) => ResolvedMarketplaceRuntimeMode;

type AttributeFilterInputValue = string | number | bigint | Iterable<string | number | bigint>;
type AttributeFilterInput = Record<string, AttributeFilterInputValue | null | undefined>;
type ResolveTokenImage = (token: Token, context: {
    projectId: string;
}) => Promise<string | undefined> | string | undefined;
type ResolveContractImage = (contract: TokenContract, context: {
    projectId: string;
}) => Promise<string | undefined> | string | undefined;
interface NormalizedToken extends Token {
    contract_address: string;
    metadata: any;
    image?: string;
}
interface CollectionTokensPage {
    tokens: NormalizedToken[];
    nextCursor: string | null;
}
interface CollectionTokensError {
    error: Error;
}
interface FetchCollectionTokensOptions {
    address: string;
    project?: string;
    cursor?: string | null | undefined;
    attributeFilters?: AttributeFilterInput;
    tokenIds?: string[];
    limit?: number;
    fetchImages?: boolean;
    resolveTokenImage?: ResolveTokenImage;
    defaultProjectId?: string;
}
interface FetchCollectionTokensResult {
    page: CollectionTokensPage | null;
    error: CollectionTokensError | null;
}
interface NormalizedCollection {
    projectId: string;
    address: string;
    contractType: string;
    metadata: any;
    totalSupply: bigint;
    tokenIdSample?: string | null;
    image?: string;
    raw: TokenContract;
}
interface CollectionSummaryOptions {
    projectId?: string;
    address: string;
    fetchImages?: boolean;
}
interface CollectionOrdersOptions {
    collection: string;
    tokenId?: string;
    status?: OrderModel["status"]["value"];
    category?: OrderModel["category"]["value"];
    limit?: number;
    orderIds?: number[];
}
interface CollectionListingsOptions {
    collection: string;
    tokenId?: string;
    limit?: number;
    verifyOwnership?: boolean;
    projectId?: string;
}
interface TokenDetailsOptions {
    collection: string;
    tokenId: string;
    projectId?: string;
    fetchImages?: boolean;
    orderLimit?: number;
    /** Cross-check on-chain ownership for listings. Defaults to true. */
    verifyOwnership?: boolean;
}
interface TokenDetails {
    projectId: string;
    token: NormalizedToken;
    orders: OrderModel[];
    listings: OrderModel[];
}
interface MarketplaceClientConfig {
    chainId: constants.StarknetChainId;
    defaultProject?: string;
    resolveTokenImage?: ResolveTokenImage;
    resolveContractImage?: ResolveContractImage;
    provider?: RpcProvider;
    runtime?: MarketplaceRuntimeMode;
}
interface MarketplaceFees {
    feeNum: number;
    feeReceiver: string;
    feeDenominator: number;
}
interface RoyaltyFeeOptions {
    collection: string;
    tokenId: string;
    amount: bigint;
}
interface RoyaltyFee {
    receiver: string;
    amount: bigint;
}
interface MarketplaceClient {
    getCollection(options: CollectionSummaryOptions): Promise<NormalizedCollection | null>;
    listCollectionTokens(options: FetchCollectionTokensOptions): Promise<FetchCollectionTokensResult>;
    getCollectionOrders(options: CollectionOrdersOptions): Promise<OrderModel[]>;
    listCollectionListings(options: CollectionListingsOptions): Promise<OrderModel[]>;
    getToken(options: TokenDetailsOptions): Promise<TokenDetails | null>;
    getFees(): Promise<MarketplaceFees | null>;
    getRoyaltyFee(options: RoyaltyFeeOptions): Promise<RoyaltyFee | null>;
}
interface TokenBalancesPage {
    balances: TokenBalance[];
    nextCursor: string | null;
}
interface TokenBalancesError {
    error: Error;
}
interface FetchTokenBalancesOptions {
    project?: string;
    contractAddresses?: string[];
    accountAddresses?: string[];
    tokenIds?: string[];
    cursor?: string | null | undefined;
    limit?: number;
    defaultProjectId?: string;
}
interface FetchTokenBalancesResult {
    page: TokenBalancesPage | null;
    error: TokenBalancesError | null;
}

export { type CollectionTokensError as $, type ListingInterface as A, BookModel as B, type CollectionOrdersOptions as C, type OfferInterface as D, type SaleInterface as E, type FetchCollectionTokensOptions as F, type MarketplaceModel as G, type Collection as H, type Collections as I, Marketplace as J, Category as K, ListingEvent as L, type MarketplaceClientConfig as M, type NormalizedCollection as N, OrderModel as O, Status as P, RoleType as Q, type ResolvedMarketplaceRuntimeMode as R, StatusType as S, type ToriiTransport as T, type AttributeFilterInputValue as U, type AttributeFilterInput as V, type WithCount as W, type ResolveTokenImage as X, type ResolveContractImage as Y, type NormalizedToken as Z, type CollectionTokensPage as _, type MarketplaceClient as a, type TokenBalancesPage as a0, type TokenBalancesError as a1, type MarketplaceRuntimeMode as b, type MarketplaceReadRuntime as c, CategoryType as d, type CollectionListingsOptions as e, type TokenDetailsOptions as f, getMarketplaceClientRuntimeMode as g, type RoyaltyFeeOptions as h, type FetchTokenBalancesOptions as i, type CollectionSummaryOptions as j, type FetchCollectionTokensResult as k, type TokenDetails as l, type FetchTokenBalancesResult as m, type MarketplaceFees as n, type RoyaltyFee as o, type SchemaType as p, Role as q, resolveMarketplaceRuntimeMode as r, type MarketplaceOptions as s, ModeratorModel as t, Order as u, OfferEvent as v, SaleEvent as w, type ModeratorInterface as x, type BookInterface as y, type OrderInterface as z };