import Ajv from 'ajv';
import type { Emitter } from 'mitt';
import { ErrorObject } from 'ajv';
import { FuncKeywordDefinition } from 'ajv';
import { JSONSchemaType } from 'ajv';
import { KeywordDefinition } from 'ajv';

/**
 * Common structure to use types as values in TS.
 * @public
 */
export declare type AbstractTypedSchema<T> = {
    schema: JSONSchema<T>;
    validate: ValidateFunction<T>;
};

export declare type Account = {
    id: string;
    address: string;
    sales: number;
    purchases: number;
    spent: string;
    earned: string;
    royalties: string;
    collections: number;
};

export declare namespace Account {
    const schema: JSONSchema<Account>;
    const validate: ValidateFunction<Account>;
}

export declare type AccountFilters = {
    first?: number;
    skip?: number;
    sortBy?: AccountSortBy;
    id?: string;
    address?: string[];
    network?: Network;
};

export declare enum AccountSortBy {
    MOST_SALES = "most_sales",
    MOST_PURCHASES = "most_purchases",
    MOST_SPENT = "most_spent",
    MOST_EARNED = "most_earned",
    MOST_ROYALTIES = "most_royalties",
    MOST_COLLECTIONS = "most_collections"
}

/** @public */
declare type Actions = typeof SCENE_UPDATE | typeof UPDATE;

export declare class AddMappingError extends Error {
    existingMapping: Mapping;
    conflictingMapping: Mapping;
    constructor(message: string, existingMapping: Mapping, conflictingMapping: Mapping);
}

export { Ajv }

export declare type AlignmentFieldType = 'Left' | 'Center' | 'Right';

export declare type AnalyticsDayData = {
    id: string;
    date: number;
    sales: number;
    volume: string;
    creatorsEarnings: string;
    daoEarnings: string;
};

export declare type AnalyticsDayDataFilters = {
    from?: number;
    network?: Network;
};

export declare enum AnalyticsDayDataSortBy {
    DATE = "date",
    MOST_SALES = "most_sales"
}

/**
 * AnyMapping
 * @alpha
 */
export declare type AnyMapping = {
    type: MappingType.ANY;
};

/**
 * AnyMapping
 * @alpha
 */
export declare namespace AnyMapping {
    const schema: JSONSchema<AnyMapping>;
    const validate: ValidateFunction<Mapping>;
}

export declare enum ArmatureId {
    Armature = "Armature",
    Armature_Prop = "Armature_Prop",
    Armature_Other = "Armature_Other"
}

export declare namespace ArmatureId {
    const schema: JSONSchema<ArmatureId>;
    const validate: ValidateFunction<ArmatureId>;
}

export declare type AssetBundleConversionFinishedEvent = BaseEvent & {
    type: Events.Type.ASSET_BUNDLE;
    subType: Events.SubType.AssetBundle.CONVERTED;
    metadata: {
        entityId: string;
        platform: 'windows' | 'mac' | 'webgl';
        statusCode: number;
        isLods: boolean;
        isWorld: boolean;
        version: string;
    };
};

export declare namespace AssetBundleConversionFinishedEvent {
    const schema: JSONSchema<AssetBundleConversionFinishedEvent>;
    const validate: ValidateFunction<AssetBundleConversionFinishedEvent>;
}

export declare type AssetBundleConversionManuallyQueuedEvent = BaseEvent & {
    type: Events.Type.ASSET_BUNDLE;
    subType: Events.SubType.AssetBundle.MANUALLY_QUEUED;
    metadata: {
        entityId: string;
        platform: 'windows' | 'mac' | 'webgl';
        isLods: boolean;
        isPriority: boolean;
        version: string;
    };
};

export declare namespace AssetBundleConversionManuallyQueuedEvent {
    const schema: JSONSchema<AssetBundleConversionManuallyQueuedEvent>;
    const validate: ValidateFunction<AssetBundleConversionManuallyQueuedEvent>;
}

declare type AssetFields = {
    title: LocalizedField<string>;
    description: LocalizedField<string>;
    file: LocalizedField<FileType>;
};

declare type Audience = {
    addressesToNotify: EthAddress[];
};

/**
 * AuthChain is an array of elements used to create and verify signatures
 * and ephemeral keys.
 *
 * @public
 */
export declare type AuthChain = AuthLink[];

/** @public */
export declare namespace AuthChain {
    const schema: JSONSchema<AuthChain>;
    const validate: ValidateFunction<AuthChain>;
}

export declare type AuthIdentifyEvent = BaseEvent & {
    type: Events.Type.WEB;
    subType: Events.SubType.Web.AUTH_IDENTIFY;
    metadata: WebBaseMetadata & {
        ethAddress: EthAddress;
    };
};

/**
 * @public
 */
export declare type AuthLink = {
    type: AuthLinkType;
    payload: string;
    signature?: string;
};

/**
 * @public
 */
export declare namespace AuthLink {
    const schema: JSONSchema<AuthLink>;
    const validate: ValidateFunction<AuthLink>;
}

/**
 * @public
 */
export declare enum AuthLinkType {
    'SIGNER' = "SIGNER",
    'ECDSA_PERSONAL_EPHEMERAL' = "ECDSA_EPHEMERAL",
    'ECDSA_PERSONAL_SIGNED_ENTITY' = "ECDSA_SIGNED_ENTITY",
    /**
     * See https://github.com/ethereum/EIPs/issues/1654
     */
    'ECDSA_EIP_1654_EPHEMERAL' = "ECDSA_EIP_1654_EPHEMERAL",
    /**
     * See https://github.com/ethereum/EIPs/issues/1654
     */
    'ECDSA_EIP_1654_SIGNED_ENTITY' = "ECDSA_EIP_1654_SIGNED_ENTITY"
}

/**
 * Avatar represents a profile avatar. Used both for comms, internal state of the
 * explorer and the deployed profiles.
 * @alpha
 */
export declare type Avatar = {
    userId: string;
    name: string;
    nameColor?: Color3;
    description: string;
    links?: Link[];
    country?: string;
    employmentStatus?: string;
    gender?: string;
    pronouns?: string;
    relationshipStatus?: string;
    sexualOrientation?: string;
    language?: string;
    profession?: string;
    birthdate?: number;
    realName?: string;
    hobbies?: string;
    ethAddress: EthAddress;
    version: number;
    tutorialStep: number;
    email?: string;
    blocked?: string[];
    muted?: string[];
    interests?: string[];
    hasClaimedName: boolean;
    avatar: AvatarInfo;
    /**
     * Whether the player has connected web3 wallet or is a guest user.
     * This is always true for deployed profiles.
     */
    hasConnectedWeb3?: boolean;
};

/**
 * Avatar
 * @alpha
 */
export declare namespace Avatar {
    const schema: JSONSchema<Avatar>;
    const validate: ValidateFunction<Avatar>;
}

/**
 * AvatarInfo
 * @alpha
 */
export declare type AvatarInfo = {
    bodyShape: WearableId;
    eyes: {
        color: Color3;
    };
    hair: {
        color: Color3;
    };
    skin: {
        color: Color3;
    };
    wearables: WearableId[];
    forceRender?: WearableCategory[];
    emotes?: {
        slot: number;
        urn: string;
    }[];
    snapshots?: Snapshots;
};

/**
 * AvatarInfo
 * @alpha
 */
export declare namespace AvatarInfo {
    const schema: JSONSchema<AvatarInfo>;
    const validate: ValidateFunction<AvatarInfo>;
}

export declare type BadgeGrantedEvent = BaseEvent & {
    type: Events.Type.BADGE;
    subType: Events.SubType.Badge.GRANTED;
    metadata: {
        badgeId: string;
        badgeName: string;
        badgeTierName?: string;
        badgeImageUrl: string;
        address: string;
    };
};

export declare namespace BadgeGrantedEvent {
    const schema: JSONSchema<BadgeGrantedEvent>;
    const validate: ValidateFunction<BadgeGrantedEvent>;
}

export declare type BannerFields = {
    desktopTitle: LocalizedField<string>;
    desktopTitleAlignment: LocalizedField<AlignmentFieldType>;
    mobileTitle: LocalizedField<string>;
    mobileTitleAlignment: LocalizedField<AlignmentFieldType>;
    desktopText: LocalizedField<any>;
    desktopTextAlignment: LocalizedField<AlignmentFieldType>;
    mobileText: LocalizedField<any>;
    mobileTextAlignment: LocalizedField<AlignmentFieldType>;
    showButton: LocalizedField<boolean>;
    buttonLink?: LocalizedField<string>;
    buttonsText?: LocalizedField<string>;
    desktopButtonAlignment: LocalizedField<AlignmentFieldType>;
    mobileButtonAlignment: LocalizedField<AlignmentFieldType>;
    fullSizeBackground: LocalizedField<SysLink<'Asset'>>;
    mobileBackground: LocalizedField<SysLink<'Asset'>>;
    logo?: LocalizedField<SysLink<'Asset'>>;
};

export declare type BaseBid = {
    id: string;
    bidder: string;
    /**
     * When the bid is on an item, this is the address of the creator of the collection
     * When the bid is on an NFT, this is the address of the owner of the NFT
     */
    seller: string;
    price: string;
    status: ListingStatus;
    /** expiration date in milliseconds */
    expiresAt: number;
    /** creation date in milliseconds */
    createdAt: number;
    /** updated date in milliseconds */
    updatedAt: number;
    contractAddress: string;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
    fingerprint: string;
};

export declare type BaseEvent = {
    type: Events.Type;
    subType: Events.SubType.Blockchain | Events.SubType.CatalystDeployment | Events.SubType.Client | Events.SubType.Marketplace | Events.SubType.Rewards | Events.SubType.Badge | Events.SubType.AssetBundle | Events.SubType.SocialService | Events.SubType.CreditsService | Events.SubType.Streaming | Events.SubType.Comms | Events.SubType.Referral | Events.SubType.Community | Events.SubType.Camera | Events.SubType.Web | Events.SubType.Event | Events.SubType.Governance | Events.SubType.Worlds | Events.SubType.Moderation;
    key: string;
    timestamp: number;
};

declare type BaseEventMetadata = {
    title: string;
    description: string;
    link?: string;
};

/**
 * @public
 *
 * Describes common properties to an item of a collection.
 */
declare type BaseItem = DisplayableDeployment & {
    id: string;
    name: string;
    description: string;
    i18n: I18N[];
    thumbnail: string;
    image: string;
    metrics?: Metrics;
};

export declare type BaseTradeAsset = {
    assetType: TradeAssetType;
    contractAddress: string;
    extra: string;
};

export declare type Bid = LegacyBid | BidTrade;

export declare namespace Bid {
    const schema: JSONSchema<Bid>;
    const validate: ValidateFunction<Bid>;
}

export declare type BidAcceptedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.BID_ACCEPTED;
    metadata: BidEventMetadata;
};

export declare namespace BidAcceptedEvent {
    const schema: JSONSchema<BidAcceptedEvent>;
    const validate: ValidateFunction<BidAcceptedEvent>;
}

export declare type BidEventMetadata = {
    address: string;
    image: string;
    seller: string;
    category: string;
    rarity?: string;
    link: string;
    nftName?: string;
    price: string;
    title: string;
    description: string;
    network: string;
};

export declare type BidFilters = {
    first?: number;
    skip?: number;
    sortBy?: BidSortBy;
    bidAddress?: string;
    bidder?: string;
    seller?: string;
    contractAddress?: string;
    tokenId?: string;
    status?: ListingStatus;
    network?: Network;
};

export declare type BidReceivedEvent = BaseEvent & {
    type: Events.Type.MARKETPLACE;
    subType: Events.SubType.Marketplace.BID_RECEIVED;
    metadata: BidEventMetadata;
};

export declare namespace BidReceivedEvent {
    const schema: JSONSchema<BidReceivedEvent>;
    const validate: ValidateFunction<BidReceivedEvent>;
}

export declare enum BidSortBy {
    RECENTLY_OFFERED = "recently_offered",
    RECENTLY_UPDATED = "recently_updated",
    MOST_EXPENSIVE = "most_expensive"
}

export declare type BidTrade = NFTBid | ItemBid;

export declare enum BodyPartCategory {
    HEAD = "head",
    HANDS = "hands"
}

export declare namespace BodyPartCategory {
    const schema: JSONSchema<BodyPartCategory>;
    const validate: ValidateFunction<BodyPartCategory>;
}

/** @alpha */
export declare enum BodyShape {
    MALE = "urn:decentraland:off-chain:base-avatars:BaseMale",
    FEMALE = "urn:decentraland:off-chain:base-avatars:BaseFemale"
}

/** @alpha */
export declare namespace BodyShape {
    const schema: JSONSchema<BodyShape>;
    const validate: ValidateFunction<BodyShape>;
}

export declare type CampaignFields = {
    name: LocalizedField<string>;
    mainTag?: LocalizedField<string>;
    marketplaceTabName?: LocalizedField<string>;
    additionalTags?: LocalizedField<string[]>;
};

export declare type CampaignGasPriceHigherThanExpectedEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.CAMPAIGN_GAS_PRICE_HIGHER_THAN_EXPECTED;
    metadata: CampaignWellKnownIssueEventMetadata;
};

export declare namespace CampaignGasPriceHigherThanExpectedEvent {
    const schema: JSONSchema<CampaignGasPriceHigherThanExpectedEvent>;
    const validate: ValidateFunction<CampaignGasPriceHigherThanExpectedEvent>;
}

export declare type CampaignOutOfFundsEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.CAMPAIGN_OUT_OF_FUNDS;
    metadata: CampaignWellKnownIssueEventMetadata;
};

export declare namespace CampaignOutOfFundsEvent {
    const schema: JSONSchema<CampaignOutOfFundsEvent>;
    const validate: ValidateFunction<CampaignOutOfFundsEvent>;
}

export declare type CampaignOutOfStockEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.CAMPAIGN_OUT_OF_STOCK;
    metadata: CampaignWellKnownIssueEventMetadata;
};

export declare namespace CampaignOutOfStockEvent {
    const schema: JSONSchema<CampaignOutOfStockEvent>;
    const validate: ValidateFunction<CampaignOutOfStockEvent>;
}

export declare type CampaignWellKnownIssueEventMetadata = BaseEventMetadata & {
    owner: EthAddress;
    campaignId: string;
    campaignName: string;
};

/**
 * All the possible Marketplace's catalog filters.
 * @public
 */
export declare type CatalogFilters = Pick<ItemFilters, 'ids' | 'first' | 'skip' | 'category' | 'creator' | 'isSoldOut' | 'isOnSale' | 'search' | 'isWearableHead' | 'isWearableSmart' | 'isWearableAccessory' | 'isWearableAccessory' | 'wearableCategory' | 'rarities' | 'wearableGenders' | 'emoteCategory' | 'emoteGenders' | 'emotePlayMode' | 'contractAddresses' | 'itemId' | 'network' | 'minPrice' | 'maxPrice' | 'urns' | 'emoteHasGeometry' | 'emoteHasSound' | 'emoteOutcomeType'> & {
    onlyMinting?: boolean;
    onlyListing?: boolean;
    sortBy?: CatalogSortBy;
    sortDirection?: CatalogSortDirection;
    limit?: number;
    offset?: number;
};

/**
 * All the possible sort options for the Marketplace's catalog.
 * @public
 */
export declare enum CatalogSortBy {
    NEWEST = "newest",
    RECENTLY_SOLD = "recently_sold",
    CHEAPEST = "cheapest",
    MOST_EXPENSIVE = "most_expensive",
    RECENTLY_LISTED = "recently_listed"
}

/**
 * All the possible sort directions.
 * @public
 */
export declare enum CatalogSortDirection {
    ASC = "asc",
    DESC = "desc"
}

export declare type CatalystDeploymentEvent = BaseEvent & {
    type: Events.Type.CATALYST_DEPLOYMENT;
    subType: Events.SubType.CatalystDeployment;
    entity: Entity;
    authChain: AuthChain;
};

export declare namespace CatalystDeploymentEvent {
    const schema: JSONSchema<CatalystDeploymentEvent>;
    const validate: ValidateFunction<CatalystDeploymentEvent>;
}

/**
 * Different supported chain ids
 * @alpha
 */
export declare enum ChainId {
    ETHEREUM_MAINNET = 1,
    ETHEREUM_ROPSTEN = 3,
    ETHEREUM_RINKEBY = 4,
    ETHEREUM_GOERLI = 5,
    ETHEREUM_KOVAN = 42,
    ETHEREUM_SEPOLIA = 11155111,
    MATIC_MAINNET = 137,
    MATIC_MUMBAI = 80001,
    MATIC_AMOY = 80002,
    BSC_MAINNET = 56,
    OPTIMISM_MAINNET = 10,
    ARBITRUM_MAINNET = 42161,
    FANTOM_MAINNET = 250,
    AVALANCHE_MAINNET = 43114
}

/**
 * @alpha
 */
export declare namespace ChainId {
    const schema: JSONSchema<ChainId>;
    const validate: ValidateFunction<ChainId>;
}

/**
 * Different supported chain names
 * @alpha
 */
export declare enum ChainName {
    ETHEREUM_MAINNET = "Ethereum Mainnet",
    ETHEREUM_ROPSTEN = "Ropsten",
    ETHEREUM_RINKEBY = "Rinkeby",
    ETHEREUM_GOERLI = "Goerli",
    ETHEREUM_KOVAN = "Kovan",
    ETHEREUM_SEPOLIA = "Sepolia",
    MATIC_MAINNET = "Polygon",
    MATIC_MUMBAI = "Mumbai",
    MATIC_AMOY = "Amoy",
    AVALANCHE_MAINNET = "Avalanche",
    BINANCE_MAINNET = "Binance Smart Chain",
    ARBITRUM_MAINNET = "Arbitrum",
    OPTIMISM_MAINNET = "Optimism",
    FANTOM_MAINNET = "Fantom"
}

/**
 * @alpha
 */
export declare namespace ChainName {
    const schema: JSONSchema<ChainName>;
    const validate: ValidateFunction<ChainName>;
}

declare type ClientBaseMetadata = {
    authChain: AuthChain;
    /** @deprecated Use timestamps.reportedAt or timestamps.receivedAt instead */
    timestamp: number;
    timestamps: {
        /**
         * Timestamp when the event was reported by the client
         *
         * @type {number}
         */
        reportedAt: number;
        /**
         * Timestamp when the event was received by the tracking system (e.g. Segment)
         *
         * @type {number}
         */
        receivedAt: number;
    };
    userAddress: EthAddress;
    sessionId: string;
    anonymousId: string;
    realm: string;
};

export declare type Collection = {
    urn: string;
    name: string;
    creator: string;
    contractAddress: string;
    isOnSale: boolean;
    size: number;
    createdAt: number;
    updatedAt: number;
    reviewedAt: number;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
    /** The timestamp in seconds since epoch when the collection was listed for sale for the first time */
    firstListedAt: number | null;
};

export declare namespace Collection {
    const schema: JSONSchema<Collection>;
    const validate: ValidateFunction<Collection>;
}

export declare type CollectionCreatedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.COLLECTION_CREATED;
    metadata: {
        creator: string;
        name: string;
    };
};

export declare namespace CollectionCreatedEvent {
    const schema: JSONSchema<CollectionCreatedEvent>;
    const validate: ValidateFunction<CollectionCreatedEvent>;
}

export declare type CollectionFilters = {
    first?: number;
    skip?: number;
    sortBy?: CollectionSortBy;
    name?: string;
    search?: string;
    creator?: string;
    contractAddress?: string;
    urn?: string;
    isOnSale?: boolean;
    network?: Network;
};

export declare type CollectionItemTradeAsset = BaseTradeAsset & {
    assetType: TradeAssetType.COLLECTION_ITEM;
    itemId: string;
};

export declare enum CollectionSortBy {
    NEWEST = "newest",
    NAME = "name",
    RECENTLY_REVIEWED = "recently_reviewed",
    RECENTLY_LISTED = "recently_listed",
    SIZE = "size"
}

/**
 * Color3 is a data type that describes a color using R, G and B components
 * @alpha
 */
export declare type Color3 = {
    r: number;
    g: number;
    b: number;
};

/**
 * Color3
 * @alpha
 */
export declare namespace Color3 {
    const schema: JSONSchema<Color3>;
    const validate: ValidateFunction<Color3>;
}

export declare type CommunityDeletedContentViolationEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.DELETED_CONTENT_VIOLATION;
    metadata: {
        id: string;
        name: string;
        ownerAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityDeletedContentViolationEvent {
    const schema: JSONSchema<CommunityDeletedContentViolationEvent>;
    const validate: ValidateFunction<CommunityDeletedContentViolationEvent>;
}

export declare type CommunityDeletedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.DELETED;
    metadata: {
        id: string;
        name: string;
        memberAddresses: EthAddress[];
        thumbnailUrl: string;
    };
};

export declare namespace CommunityDeletedEvent {
    const schema: JSONSchema<CommunityDeletedEvent>;
    const validate: ValidateFunction<CommunityDeletedEvent>;
}

export declare type CommunityInviteReceivedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.INVITE_RECEIVED;
    metadata: {
        communityId: string;
        communityName: string;
        memberAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityInviteReceivedEvent {
    const schema: JSONSchema<CommunityInviteReceivedEvent>;
    const validate: ValidateFunction<CommunityInviteReceivedEvent>;
}

export declare type CommunityMemberBannedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.MEMBER_BANNED;
    metadata: {
        id: string;
        name: string;
        memberAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityMemberBannedEvent {
    const schema: JSONSchema<CommunityMemberBannedEvent>;
    const validate: ValidateFunction<CommunityMemberBannedEvent>;
}

export declare type CommunityMemberLeftEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.MEMBER_LEFT;
    metadata: {
        id: string;
        memberAddress: EthAddress;
    };
};

export declare namespace CommunityMemberLeftEvent {
    const schema: JSONSchema<CommunityMemberLeftEvent>;
    const validate: ValidateFunction<CommunityMemberLeftEvent>;
}

export declare type CommunityMemberRemovedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.MEMBER_REMOVED;
    metadata: {
        id: string;
        name: string;
        memberAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityMemberRemovedEvent {
    const schema: JSONSchema<CommunityMemberRemovedEvent>;
    const validate: ValidateFunction<CommunityMemberRemovedEvent>;
}

export declare type CommunityOwnershipTransferredEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.OWNERSHIP_TRANSFERRED;
    metadata: {
        communityId: string;
        communityName: string;
        oldOwnerAddress: EthAddress;
        newOwnerAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityOwnershipTransferredEvent {
    const schema: JSONSchema<CommunityOwnershipTransferredEvent>;
    const validate: ValidateFunction<CommunityOwnershipTransferredEvent>;
}

export declare type CommunityPostAddedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.POST_ADDED;
    metadata: Audience & {
        communityId: string;
        communityName: string;
        thumbnailUrl: string;
        postId: string;
        authorAddress: EthAddress;
    };
};

export declare namespace CommunityPostAddedEvent {
    const schema: JSONSchema<CommunityPostAddedEvent>;
    const validate: ValidateFunction<CommunityPostAddedEvent>;
}

export declare type CommunityRenamedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.RENAMED;
    metadata: {
        id: string;
        oldName: string;
        newName: string;
        memberAddresses: EthAddress[];
        thumbnailUrl: string;
    };
};

export declare namespace CommunityRenamedEvent {
    const schema: JSONSchema<CommunityRenamedEvent>;
    const validate: ValidateFunction<CommunityRenamedEvent>;
}

export declare type CommunityRequestToJoinAcceptedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.REQUEST_TO_JOIN_ACCEPTED;
    metadata: {
        communityId: string;
        communityName: string;
        memberAddress: EthAddress;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityRequestToJoinAcceptedEvent {
    const schema: JSONSchema<CommunityRequestToJoinAcceptedEvent>;
    const validate: ValidateFunction<CommunityRequestToJoinAcceptedEvent>;
}

export declare type CommunityRequestToJoinReceivedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.REQUEST_TO_JOIN_RECEIVED;
    metadata: Audience & {
        communityId: string;
        communityName: string;
        memberAddress: EthAddress;
        memberName: string;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityRequestToJoinReceivedEvent {
    const schema: JSONSchema<CommunityRequestToJoinReceivedEvent>;
    const validate: ValidateFunction<CommunityRequestToJoinReceivedEvent>;
}

export declare type CommunityStreamingEndedEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.COMMUNITY_STREAMING_ENDED;
    metadata: {
        communityId: string;
        totalParticipants: number;
    };
};

export declare namespace CommunityStreamingEndedEvent {
    const schema: JSONSchema<CommunityStreamingEndedEvent>;
    const validate: ValidateFunction<CommunityStreamingEndedEvent>;
}

export declare type CommunityVoiceChatStartedEvent = BaseEvent & {
    type: Events.Type.COMMUNITY;
    subType: Events.SubType.Community.VOICE_CHAT_STARTED;
    metadata: Audience & {
        communityId: string;
        communityName: string;
        thumbnailUrl: string;
    };
};

export declare namespace CommunityVoiceChatStartedEvent {
    const schema: JSONSchema<CommunityVoiceChatStartedEvent>;
    const validate: ValidateFunction<CommunityVoiceChatStartedEvent>;
}

export declare type ContentfulAsset = ContentfulContent<'Asset', AssetFields>;

declare type ContentfulContent<X extends 'Asset' | 'Entry', T extends LocalizedFields> = {
    metadata: {
        tags: string[];
        concepts: string[];
    };
    sys: {
        space: SysLink<'Space'>;
        id: string;
        type: X;
        createdAt: string;
        updatedAt: string;
        environment: SysLink<'Environment'>;
        publishedVersion: number;
        revision: number;
    } & (X extends 'Entry' ? {
        contentType: SysLink<'ContentType'>;
    } : {});
    fields: T;
};

export declare type ContentfulEntry<T extends LocalizedFields> = ContentfulContent<'Entry', T>;

export declare enum ContentfulLocale {
    enUS = "en-US",
    es = "es",
    zh = "zh"
}

export declare type ContentfulResponse<T extends LocalizedFields> = {
    items: Array<ContentfulEntry<T>>;
    includes: {
        Asset?: ContentfulAsset[];
        Entry?: ContentfulEntry<LocalizedFields>[];
    };
};

/**
 * Represents a content mapping. The Decentraland file system is
 * case-insensitive. `file` must be lower cased.
 *
 * Duplicated files will throw a validation error.
 *
 * .file is a relative path
 * .hash is a valid IPFS hash.
 *
 * @public
 */
export declare type ContentMapping = {
    file: string;
    hash: IPFSv1 | IPFSv2;
};

/** @public */
export declare namespace ContentMapping {
    const schema: JSONSchema<ContentMapping>;
    const validate: ValidateFunction<ContentMapping>;
}

export declare type Contract = {
    name: string;
    address: string;
    category: NFTCategory;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
};

export declare namespace Contract {
    const schema: JSONSchema<Contract>;
    const validate: ValidateFunction<Contract>;
}

/**
 * ContractAddress
 * @alpha
 */
export declare type ContractAddress = string;

export declare type ContractFilters = {
    category?: NFTCategory;
    network?: Network;
};

/**
 * Network
 * @alpha
 */
export declare enum ContractNetwork {
    MAINNET = "mainnet",
    BASE_MAINNET = "base_mainnet",
    BASE_SEPOLIA = "base_sepolia",
    MONAD_MAINNET = "monad_mainnet",
    MONAD_TESTNET = "monad_testnet",
    APE_MAINNET = "ape_mainnet",
    APE_CALDERA = "ape_caldera",
    MATIC = "matic",
    SEPOLIA = "sepolia",
    AMOY = "amoy"
}

export declare enum ContractSortBy {
    NAME = "name"
}

export declare function createMappingsHelper(initial?: Mappings): MappingsHelper;

export declare type CreditsClaimReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.CLAIM_CREDITS_REMINDER;
    metadata: {
        address: EthAddress;
        seasonId: number;
        weekNumber: number;
    };
};

export declare namespace CreditsClaimReminderEvent {
    const schema: JSONSchema<CreditsClaimReminderEvent>;
    const validate: ValidateFunction<CreditsClaimReminderEvent>;
}

export declare type CreditsCompleteGoalsReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.COMPLETE_GOALS_REMINDER;
    metadata: {
        address: EthAddress;
        seasonId: number;
        weekNumber: number;
        pendingGoalIds: string[];
    };
};

export declare namespace CreditsCompleteGoalsReminderEvent {
    const schema: JSONSchema<CreditsCompleteGoalsReminderEvent>;
    const validate: ValidateFunction<CreditsCompleteGoalsReminderEvent>;
}

export declare type CreditsDoNotMissOutReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.DO_NOT_MISS_OUT_REMINDER;
    metadata: {
        address: EthAddress;
    };
};

export declare namespace CreditsDoNotMissOutReminderEvent {
    const schema: JSONSchema<CreditsDoNotMissOutReminderEvent>;
    const validate: ValidateFunction<CreditsDoNotMissOutReminderEvent>;
}

export declare type CreditsGoalCompletedEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.CREDITS_GOAL_COMPLETED;
    metadata: {
        goalId: string;
        creditsObtained: number;
        seasonId: number;
        weekNumber: number;
        address: EthAddress;
    };
};

export declare namespace CreditsGoalCompletedEvent {
    const schema: JSONSchema<CreditsGoalCompletedEvent>;
    const validate: ValidateFunction<CreditsGoalCompletedEvent>;
}

export declare type CreditsNewSeasonReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.NEW_SEASON_REMINDER;
    metadata: {
        addresses: EthAddress[];
        seasonName: string;
        startDate: string;
        endDate: string;
    };
};

export declare namespace CreditsNewSeasonReminderEvent {
    const schema: JSONSchema<CreditsNewSeasonReminderEvent>;
    const validate: ValidateFunction<CreditsNewSeasonReminderEvent>;
}

export declare type CreditsOnDemandEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.ON_DEMAND_CREDITS_GRANTED;
    metadata: {
        creditsGranted: number;
        address: EthAddress;
        granterAddress: EthAddress;
    };
};

export declare namespace CreditsOnDemandEvent {
    const schema: JSONSchema<CreditsOnDemandEvent>;
    const validate: ValidateFunction<CreditsOnDemandEvent>;
}

export declare type CreditsUsage24HoursReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.USAGE_24_HOURS_REMINDER;
    metadata: {
        address: EthAddress;
        creditsAmount: number;
        expirationDate: string;
    };
};

export declare namespace CreditsUsage24HoursReminderEvent {
    const schema: JSONSchema<CreditsUsage24HoursReminderEvent>;
    const validate: ValidateFunction<CreditsUsage24HoursReminderEvent>;
}

export declare type CreditsUsageReminderEvent = BaseEvent & {
    type: Events.Type.CREDITS_SERVICE;
    subType: Events.SubType.CreditsService.USAGE_REMINDER;
    metadata: {
        address: EthAddress;
        creditsAmount: number;
        expirationDate: string;
        expirationDay: string;
    };
};

export declare namespace CreditsUsageReminderEvent {
    const schema: JSONSchema<CreditsUsageReminderEvent>;
    const validate: ValidateFunction<CreditsUsageReminderEvent>;
}

/**
 * This type describes the minimum deployment + AuthChain needed to synchronize
 * a deployed entity across catalysts.
 * @public @deprecated
 */
export declare type DeploymentWithAuthChain = {
    entityId: string;
    entityType: string;
    pointers: string[];
    localTimestamp: number;
    authChain: AuthChain;
};

/**
 * @public
 * @deprecated use SyncDeployment instead
 */
export declare namespace DeploymentWithAuthChain {
    const schema: JSONSchema<DeploymentWithAuthChain>;
    const validate: ValidateFunction<DeploymentWithAuthChain>;
}

/**
 * @public
 *
 * Describes common properties to display deployments.
 */
export declare type DisplayableDeployment = {
    /** Name of the file used as icon for the MenuBar */
    menuBarIcon?: string;
};

/**
 /**
 * Email is a data type that describes an email address
 * @public
 */
export declare type Email = string;

/**
 * Email
 * @public
 */
export declare namespace Email {
    const schema: JSONSchema<Email>;
    const validate: ValidateFunction<Email>;
}

/** @alpha */
export declare type Emote = EmoteADR74;

/** @alpha */
export declare namespace Emote {
    const schema: JSONSchema<Emote>;
    const validate: ValidateFunction<EmoteADR74>;
}

export declare type EmoteADR74 = BaseItem & (StandardProps | ThirdPartyProps) & {
    emoteDataADR74: EmoteDataADR74;
};

export declare enum EmoteCategory {
    DANCE = "dance",
    STUNT = "stunt",
    GREETINGS = "greetings",
    FUN = "fun",
    POSES = "poses",
    REACTIONS = "reactions",
    HORROR = "horror",
    MISCELLANEOUS = "miscellaneous"
}

export declare namespace EmoteCategory {
    const schema: JSONSchema<EmoteCategory>;
    const validate: ValidateFunction<EmoteCategory>;
}

export declare type EmoteClip = {
    animation: string;
};

export declare namespace EmoteClip {
    const schema: JSONSchema<EmoteClip>;
    const validate: ValidateFunction<EmoteClip>;
}

export declare type EmoteDataADR74 = {
    category: EmoteCategory;
    representations: EmoteRepresentationADR74[];
    tags: string[];
    loop: boolean;
    startAnimation?: StartAnimation;
    randomizeOutcomes?: boolean;
    outcomes?: OutcomeGroup[];
};

export declare namespace EmoteDataADR74 {
    const schema: JSONSchema<EmoteDataADR74>;
    const validate: ValidateFunction<EmoteDataADR74>;
}

export declare type EmoteDefinition = Omit<Emote, 'emoteDataADR74'> & {
    emoteDataADR74: Omit<Emote['emoteDataADR74'], 'representations'> & {
        representations: EmoteRepresentationDefinition[];
    };
};

declare type EmoteEventPayload<T extends PreviewEmoteEventType> = T extends PreviewEmoteEventType.ANIMATION_PLAYING ? {
    length: number;
} : undefined;

export declare type EmoteEvents = {
    [PreviewEmoteEventType.ANIMATION_PLAY]: void;
    [PreviewEmoteEventType.ANIMATION_PAUSE]: void;
    [PreviewEmoteEventType.ANIMATION_LOOP]: void;
    [PreviewEmoteEventType.ANIMATION_END]: void;
    [PreviewEmoteEventType.ANIMATION_PLAYING]: {
        length: number;
    };
};

export declare enum EmoteOutcomeType {
    SIMPLE_OUTCOME = "so",
    MULTIPLE_OUTCOME = "mo",
    RANDOM_OUTCOME = "ro"
}

export declare namespace EmoteOutcomeType {
    const schema: JSONSchema<EmoteOutcomeType>;
    const validate: ValidateFunction<EmoteOutcomeType>;
}

export declare enum EmotePlayMode {
    SIMPLE = "simple",
    LOOP = "loop"
}

export declare namespace EmotePlayMode {
    const schema: JSONSchema<EmotePlayMode>;
    const validate: ValidateFunction<EmotePlayMode>;
}

/** @alpha */
export declare type EmoteRepresentationADR74 = {
    bodyShapes: BodyShape[];
    mainFile: string;
    contents: string[];
};

/** @alpha */
export declare namespace EmoteRepresentationADR74 {
    const schema: JSONSchema<EmoteRepresentationADR74>;
    const validate: ValidateFunction<EmoteRepresentationADR74>;
}

/** @alpha */
export declare type EmoteRepresentationDefinition = Omit<EmoteRepresentationADR74, 'contents'> & {
    contents: {
        key: string;
        url: string;
    }[];
};

/** @alpha */
export declare type EmoteRepresentationWithBlobs = Omit<EmoteRepresentationDefinition, 'contents'> & {
    contents: {
        key: string;
        blob: any;
    }[];
};

/** @alpha */
export declare type EmoteWithBlobs = Omit<EmoteDefinition, 'emoteDataADR74'> & {
    emoteDataADR74: Omit<EmoteDefinition['emoteDataADR74'], 'representations'> & {
        representations: EmoteRepresentationWithBlobs[];
    };
};

declare type EnabledDisabled = 'enabled' | 'disabled';

/**
 * Internal representation of an entity in the catalyst.
 *
 * This Entity's content mappings adhere to ADR45.
 *
 * @public
 */
export declare type Entity = {
    /** @deprecated ADR45 removed entity versions. */
    version: string;
    id: IPFSv1 | IPFSv2;
    type: EntityType;
    pointers: string[];
    timestamp: number;
    content: ContentMapping[];
    metadata?: any;
};

/** @public */
export declare namespace Entity {
    const schema: JSONSchema<Entity>;
    const validate: ValidateFunction<Entity>;
}

/**
 * Non-exhaustive list of EntityTypes.
 * @public
 */
export declare enum EntityType {
    SCENE = "scene",
    PROFILE = "profile",
    WEARABLE = "wearable",
    STORE = "store",
    EMOTE = "emote",
    OUTFITS = "outfits"
}

export declare type ERC20TradeAsset = BaseTradeAsset & {
    assetType: TradeAssetType.ERC20;
    amount: string;
};

export declare type ERC721TradeAsset = BaseTradeAsset & {
    assetType: TradeAssetType.ERC721;
    tokenId: string;
};

/**
 * EthAddress is a data type that describes an Ethereum address
 * @public
 */
export declare type EthAddress = string;

/**
 * EthAddress
 * @public
 */
export declare namespace EthAddress {
    const schema: JSONSchema<EthAddress>;
    const validate: ValidateFunction<EthAddress>;
}

declare type Event_2 = BadgeGrantedEvent | BidAcceptedEvent | BidReceivedEvent | CampaignGasPriceHigherThanExpectedEvent | CampaignOutOfFundsEvent | CampaignOutOfStockEvent | CatalystDeploymentEvent | CollectionCreatedEvent | FriendshipRequestEvent | FriendshipAcceptedEvent | ItemPublishedEvent | ItemSoldEvent | LoggedInEvent | LoggedInCachedEvent | MoveToParcelEvent | PassportOpenedEvent | RentalEndedEvent | RentalStartedEvent | RewardAssignedEvent | RewardDelayedEvent | RewardInProgressEvent | RoyaltiesEarnedEvent | UsedEmoteEvent | VerticalHeightReachedEvent | WalkedDistanceEvent | CreditsGoalCompletedEvent | CreditsOnDemandEvent | StreamingKeyResetEvent | StreamingKeyRevokeEvent | StreamingKeyExpiredEvent | StreamingTimeExceededEvent | StreamingPlaceUpdatedEvent | CommunityStreamingEndedEvent | UserJoinedRoomEvent | UserLeftRoomEvent | UserBannedFromSceneEvent | UserUnbannedFromSceneEvent | CreditsCompleteGoalsReminderEvent | CreditsUsageReminderEvent | CreditsUsage24HoursReminderEvent | CreditsDoNotMissOutReminderEvent | CreditsClaimReminderEvent | CreditsNewSeasonReminderEvent | ReferralInvitedUsersAcceptedEvent | ReferralNewTierReachedEvent | CommunityDeletedEvent | CommunityDeletedContentViolationEvent | CommunityRenamedEvent | CommunityMemberBannedEvent | CommunityMemberLeftEvent | CommunityMemberRemovedEvent | CommunityRequestToJoinReceivedEvent | CommunityRequestToJoinAcceptedEvent | CommunityInviteReceivedEvent | CommunityOwnershipTransferredEvent | CommunityPostAddedEvent | CommunityVoiceChatStartedEvent | PhotoTakenEvent | PhotoPrivacyChangedEvent | AuthIdentifyEvent | EventCreatedEvent | EventStartedEvent | EventStartsSoonEvent | EventEndedEvent | EventApprovedEvent | EventRejectedEvent | GovernanceProposalEnactedEvent | GovernanceCoauthorRequestedEvent | GovernancePitchPassedEvent | GovernanceTenderPassedEvent | GovernanceAuthoredProposalFinishedEvent | GovernanceVotingEndedVoterEvent | GovernanceNewCommentOnProposalEvent | GovernanceNewCommentOnProjectUpdatedEvent | GovernanceWhaleVoteEvent | GovernanceVotedOnBehalfEvent | GovernanceCliffEndedEvent | WorldsPermissionGrantedEvent | WorldsPermissionRevokedEvent | WorldsAccessRestoredEvent | WorldsAccessRestrictedEvent | WorldsMissingResourcesEvent | TransferReceivedEvent | TipReceivedEvent | UserBanCreatedEvent | UserBanLiftedEvent | UserWarningCreatedEvent;
export { Event_2 as Event }

export declare type EventApprovedEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_APPROVED;
    metadata: {
        host: string;
        title: string;
        description: string;
        image: string;
        link: string;
    };
};

export declare namespace EventApprovedEvent {
    const schema: JSONSchema<EventApprovedEvent>;
    const validate: ValidateFunction<EventApprovedEvent>;
}

export declare type EventCreatedEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_CREATED;
    metadata: {
        title: string;
        description: string;
        name: string;
        image: string;
        communityId: string;
        communityName: string;
        communityThumbnail?: string;
        attendee: string;
    };
};

export declare namespace EventCreatedEvent {
    const schema: JSONSchema<EventCreatedEvent>;
    const validate: ValidateFunction<EventCreatedEvent>;
}

export declare type EventEndedEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_ENDED;
    metadata: {
        communityId?: string;
        totalAttendees: number;
    };
};

export declare namespace EventEndedEvent {
    const schema: JSONSchema<EventEndedEvent>;
    const validate: ValidateFunction<EventEndedEvent>;
}

export declare type EventRejectedEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_REJECTED;
    metadata: {
        host: string;
        title: string;
        description: string;
        image: string;
        reason: string;
    };
};

export declare namespace EventRejectedEvent {
    const schema: JSONSchema<EventRejectedEvent>;
    const validate: ValidateFunction<EventRejectedEvent>;
}

export declare namespace Events {
    export enum Type {
        BLOCKCHAIN = "blockchain",
        CATALYST_DEPLOYMENT = "catalyst-deployment",
        WORLD = "world",
        CLIENT = "client",
        WEB = "web",
        MARKETPLACE = "marketplace",
        REWARDS = "rewards",
        BADGE = "badge",
        ASSET_BUNDLE = "asset-bundle",
        SOCIAL_SERVICE = "social-service",
        CREDITS_SERVICE = "credits-service",
        STREAMING = "streaming",
        COMMS = "comms",
        REFERRAL = "referral",
        COMMUNITY = "community",
        CAMERA = "camera",
        EVENT = "event",
        GOVERNANCE = "governance",
        MODERATION = "moderation"
    }
    export namespace SubType {
        export enum Blockchain {
            BID_ACCEPTED = "bid-accepted",
            ITEM_SOLD = "item-sold",
            RENTAL_ENDED = "land-rental-ended",
            RENTAL_STARTED = "land-rental-started",
            ROYALTIES_EARNED = "royalties-earned",
            COLLECTION_CREATED = "collection-created",
            ITEM_PUBLISHED = "item-published",
            TRANSFER_RECEIVED = "transfer-received",
            TIP_RECEIVED = "tip-received"
        }
        export enum Marketplace {
            BID_RECEIVED = "bid-received"
        }
        export enum CatalystDeployment {
            SCENE = "scene",
            PROFILE = "profile",
            WEARABLE = "wearable",
            STORE = "store",
            EMOTE = "emote",
            OUTFITS = "outfits"
        }
        export enum Worlds {
            DEPLOYMENT = "deployment",
            WORLD_SETTINGS_CHANGED = "world_settings_changed",
            WORLD_SCENES_UNDEPLOYMENT = "world_scenes_undeployment",
            WORLD_UNDEPLOYMENT = "world_undeployment",
            WORLD_SPAWN_COORDINATE_SET = "world_spawn_coordinate_set",
            WORLDS_PERMISSION_GRANTED = "worlds_permission_granted",
            WORLDS_PERMISSION_REVOKED = "worlds_permission_revoked",
            WORLDS_ACCESS_RESTORED = "worlds_access_restored",
            WORLDS_ACCESS_RESTRICTED = "worlds_access_restricted",
            WORLDS_MISSING_RESOURCES = "worlds_missing_resources"
        }
        export enum Client {
            LOGGED_IN = "logged-in",
            LOGGED_IN_CACHED = "logged-in-cached",
            MOVE_TO_PARCEL = "move-to-parcel",
            USED_EMOTE = "used-emote",
            PASSPORT_OPENED = "passport-opened",
            WALKED_DISTANCE = "walked-distance",
            VERTICAL_HEIGHT_REACHED = "vertical-height-reached"
        }
        export enum Web {
            AUTH_IDENTIFY = "auth-identify"
        }
        export enum Rewards {
            REWARD_IN_PROGRESS = "reward-in-progress",
            REWARD_ASSIGNED = "reward-assigned",
            CAMPAIGN_OUT_OF_FUNDS = "campaign-out-of-funds",
            CAMPAIGN_GAS_PRICE_HIGHER_THAN_EXPECTED = "campaign-gas-price-higher-than-expected",
            CAMPAIGN_OUT_OF_STOCK = "campaign-out-of-stock",
            REWARD_DELAYED = "reward-delayed"
        }
        export enum Badge {
            GRANTED = "badge-granted"
        }
        export enum AssetBundle {
            CONVERTED = "converted",
            MANUALLY_QUEUED = "manually-queued"
        }
        export enum SocialService {
            FRIENDSHIP_REQUEST = "friendship-request",
            FRIENDSHIP_ACCEPTED = "friendship-accepted"
        }
        export enum CreditsService {
            CREDITS_GOAL_COMPLETED = "credits-goal-completed",
            COMPLETE_GOALS_REMINDER = "complete-goals-reminder",
            CLAIM_CREDITS_REMINDER = "claim-credits-reminder",
            DO_NOT_MISS_OUT_REMINDER = "do-not-miss-out-reminder",
            USAGE_REMINDER = "usage-reminder",
            USAGE_24_HOURS_REMINDER = "usage-24-hours-reminder",
            ON_DEMAND_CREDITS_GRANTED = "on-demand-credits-granted",
            NEW_SEASON_REMINDER = "new-season-reminder"
        }
        export enum Streaming {
            STREAMING_KEY_RESET = "streaming-key-reset",
            STREAMING_KEY_REVOKE = "streaming-key-revoke",
            STREAMING_KEY_EXPIRED = "streaming-key-expired",
            STREAMING_TIME_EXCEEDED = "streaming-time-exceeded",
            STREAMING_PLACE_UPDATED = "streaming-place-updated",
            COMMUNITY_STREAMING_ENDED = "community-streaming-ended"
        }
        export enum Comms {
            USER_JOINED_ROOM = "user-joined-room",
            USER_LEFT_ROOM = "user-left-room",
            USER_BANNED_FROM_SCENE = "user-banned-from-scene",
            USER_UNBANNED_FROM_SCENE = "user-unbanned-from-scene"
        }
        export enum Referral {
            REFERRAL_INVITED_USERS_ACCEPTED = "referral-invited-users-accepted",
            REFERRAL_NEW_TIER_REACHED = "referral-new-tier-reached"
        }
        export enum Community {
            DELETED = "community-deleted",
            DELETED_CONTENT_VIOLATION = "community-deleted-content-violation",
            RENAMED = "community-renamed",
            MEMBER_BANNED = "community-member-banned",
            MEMBER_LEFT = "community-member-left",
            MEMBER_REMOVED = "community-member-removed",
            REQUEST_TO_JOIN_RECEIVED = "community-request-to-join-received",
            REQUEST_TO_JOIN_ACCEPTED = "community-request-to-join-accepted",
            INVITE_RECEIVED = "community-invite-received",
            OWNERSHIP_TRANSFERRED = "community-ownership-transferred",
            POST_ADDED = "community-post-added",
            VOICE_CHAT_STARTED = "community-voice-chat-started"
        }
        export enum Camera {
            PHOTO_TAKEN = "photo-taken",
            PHOTO_PRIVACY_CHANGED = "photo-privacy-changed"
        }
        export enum Event {
            EVENT_CREATED = "event-created",
            EVENT_STARTS_SOON = "event-starts-soon",
            EVENT_STARTED = "event-started",
            EVENT_ENDED = "event-ended",
            EVENT_APPROVED = "event-approved",
            EVENT_REJECTED = "event-rejected"
        }
        export enum Governance {
            PROPOSAL_ENACTED = "governance_proposal_enacted",
            COAUTHOR_REQUESTED = "governance_coauthor_requested",
            PITCH_PASSED = "governance_pitch_passed",
            TENDER_PASSED = "governance_tender_passed",
            AUTHORED_PROPOSAL_FINISHED = "governance_authored_proposal_finished",
            VOTING_ENDED_VOTER = "governance_voting_ended_voter",
            NEW_COMMENT_ON_PROPOSAL = "governance_new_comment_on_proposal",
            NEW_COMMENT_ON_PROJECT_UPDATED = "governance_new_comment_on_project_update",
            WHALE_VOTE = "governance_whale_vote",
            VOTED_ON_BEHALF = "governance_voted_on_behalf",
            CLIFF_ENDED = "governance_cliff_ended"
        }
        export enum Moderation {
            USER_BAN_CREATED = "user-ban-created",
            USER_BAN_LIFTED = "user-ban-lifted",
            USER_WARNING_CREATED = "user-warning-created"
        }
    }
}

export declare type EventStartedEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_STARTED;
    metadata: {
        name: string;
        image: string;
        link: string;
        communityId: string;
        communityThumbnail?: string;
        title: string;
        description: string;
        attendee: string;
    };
};

export declare namespace EventStartedEvent {
    const schema: JSONSchema<EventStartedEvent>;
    const validate: ValidateFunction<EventStartedEvent>;
}

export declare type EventStartsSoonEvent = BaseEvent & {
    type: Events.Type.EVENT;
    subType: Events.SubType.Event.EVENT_STARTS_SOON;
    metadata: {
        name: string;
        image: string;
        link: string;
        startsAt: string;
        endsAt: string;
        title: string;
        description: string;
        attendee: string;
    };
};

export declare namespace EventStartsSoonEvent {
    const schema: JSONSchema<EventStartsSoonEvent>;
    const validate: ValidateFunction<EventStartsSoonEvent>;
}

/** @alpha */
export declare type FeatureToggles = {
    voiceChat?: EnabledDisabled;
    portableExperiences?: EnabledDisabled | PortableExperiencesToggles;
    nearbyVoiceChat?: EnabledDisabled;
};

/** @alpha */
export declare namespace FeatureToggles {
    const schema: JSONSchema<FeatureToggles>;
    const validate: ValidateFunction<FeatureToggles>;
}

export declare type FileType = {
    url: string;
    details: {
        size: number;
        image?: {
            width: number;
            height: number;
        };
    };
    fileName: string;
    contentType: string;
};

export declare type FriendshipAcceptedEvent = BaseEvent & {
    type: Events.Type.SOCIAL_SERVICE;
    subType: Events.SubType.SocialService.FRIENDSHIP_ACCEPTED;
    metadata: {
        requestId: string;
        sender: {
            address: string;
            name: string;
            profileImageUrl: string;
            hasClaimedName: boolean;
        };
        receiver: {
            address: string;
            name: string;
            profileImageUrl: string;
            hasClaimedName: boolean;
        };
    };
};

export declare namespace FriendshipAcceptedEvent {
    const schema: JSONSchema<FriendshipAcceptedEvent>;
    const validate: ValidateFunction<FriendshipAcceptedEvent>;
}

export declare type FriendshipRequestEvent = BaseEvent & {
    type: Events.Type.SOCIAL_SERVICE;
    subType: Events.SubType.SocialService.FRIENDSHIP_REQUEST;
    metadata: {
        requestId: string;
        sender: {
            address: string;
            name: string;
            profileImageUrl: string;
            hasClaimedName: boolean;
        };
        receiver: {
            address: string;
            name: string;
            profileImageUrl: string;
            hasClaimedName: boolean;
        };
        message?: string;
    };
};

export declare namespace FriendshipRequestEvent {
    const schema: JSONSchema<FriendshipRequestEvent>;
    const validate: ValidateFunction<FriendshipRequestEvent>;
}

export declare enum GenderFilterOption {
    MALE = "male",
    FEMALE = "female",
    UNISEX = "unisex"
}

/**
 * Generates a validator for a specific JSON schema of a type T
 * @public
 */
export declare function generateLazyValidator<T>(schema: JSONSchema<T>, keywordDefinitions?: KeywordDefinition[]): ValidateFunction<T>;

export declare type GetBidsParameters = PaginatedParameters & {
    bidder?: string;
    seller?: string;
    sortBy?: BidSortBy;
    contractAddress?: string;
    tokenId?: string;
    status?: ListingStatus;
    network?: Network;
    itemId?: string;
    bidAddress?: string;
};

/**
 * Get chain id by chain name
 * @alpha
 */
export declare function getChainId(chainName: ChainName): ChainId | null;

/**
 * Get the chain name by chain id
 * @alpha
 */
export declare function getChainName(chainId: ChainId): ChainName | null;

/**
 * Get the chain name by chain id
 * @alpha
 */
export declare function getURNProtocol(chainId: ChainId): string;

/**
 * Get World
 * @alpha
 */
export declare function getWorld(): World;

export declare type GovernanceAuthoredProposalFinishedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.AUTHORED_PROPOSAL_FINISHED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceAuthoredProposalFinishedEvent {
    const schema: JSONSchema<GovernanceAuthoredProposalFinishedEvent>;
    const validate: ValidateFunction<GovernanceAuthoredProposalFinishedEvent>;
}

export declare type GovernanceCliffEndedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.CLIFF_ENDED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceCliffEndedEvent {
    const schema: JSONSchema<GovernanceCliffEndedEvent>;
    const validate: ValidateFunction<GovernanceCliffEndedEvent>;
}

export declare type GovernanceCoauthorRequestedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.COAUTHOR_REQUESTED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceCoauthorRequestedEvent {
    const schema: JSONSchema<GovernanceCoauthorRequestedEvent>;
    const validate: ValidateFunction<GovernanceCoauthorRequestedEvent>;
}

export declare type GovernanceNewCommentOnProjectUpdatedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.NEW_COMMENT_ON_PROJECT_UPDATED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceNewCommentOnProjectUpdatedEvent {
    const schema: JSONSchema<GovernanceNewCommentOnProjectUpdatedEvent>;
    const validate: ValidateFunction<GovernanceNewCommentOnProjectUpdatedEvent>;
}

export declare type GovernanceNewCommentOnProposalEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.NEW_COMMENT_ON_PROPOSAL;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceNewCommentOnProposalEvent {
    const schema: JSONSchema<GovernanceNewCommentOnProposalEvent>;
    const validate: ValidateFunction<GovernanceNewCommentOnProposalEvent>;
}

export declare type GovernancePitchPassedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.PITCH_PASSED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernancePitchPassedEvent {
    const schema: JSONSchema<GovernancePitchPassedEvent>;
    const validate: ValidateFunction<GovernancePitchPassedEvent>;
}

export declare type GovernanceProposalEnactedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.PROPOSAL_ENACTED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceProposalEnactedEvent {
    const schema: JSONSchema<GovernanceProposalEnactedEvent>;
    const validate: ValidateFunction<GovernanceProposalEnactedEvent>;
}

export declare type GovernanceTenderPassedEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.TENDER_PASSED;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceTenderPassedEvent {
    const schema: JSONSchema<GovernanceTenderPassedEvent>;
    const validate: ValidateFunction<GovernanceTenderPassedEvent>;
}

export declare type GovernanceVotedOnBehalfEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.VOTED_ON_BEHALF;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceVotedOnBehalfEvent {
    const schema: JSONSchema<GovernanceVotedOnBehalfEvent>;
    const validate: ValidateFunction<GovernanceVotedOnBehalfEvent>;
}

export declare type GovernanceVotingEndedVoterEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.VOTING_ENDED_VOTER;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceVotingEndedVoterEvent {
    const schema: JSONSchema<GovernanceVotingEndedVoterEvent>;
    const validate: ValidateFunction<GovernanceVotingEndedVoterEvent>;
}

export declare type GovernanceWhaleVoteEvent = BaseEvent & {
    type: Events.Type.GOVERNANCE;
    subType: Events.SubType.Governance.WHALE_VOTE;
    metadata: {
        proposalId: string;
        proposalTitle: string;
        title: string;
        description: string;
        link: string;
        address: string;
    };
};

export declare namespace GovernanceWhaleVoteEvent {
    const schema: JSONSchema<GovernanceWhaleVoteEvent>;
    const validate: ValidateFunction<GovernanceWhaleVoteEvent>;
}

export declare type HideableWearableCategory = WearableCategory | BodyPartCategory;

export declare namespace HideableWearableCategory {
    const schema: JSONSchema<BodyPartCategory>;
    const validate: ValidateFunction<BodyPartCategory>;
}

/** @alpha */
export declare type I18N = {
    code: Locale;
    text: string;
};

/** @alpha */
export declare namespace I18N {
    const schema: JSONSchema<I18N>;
    const validate: ValidateFunction<I18N>;
}

export declare interface IEmoteController {
    getLength(): Promise<number>;
    isPlaying(): Promise<boolean>;
    goTo(seconds: number): Promise<void>;
    play(): Promise<void>;
    pause(): Promise<void>;
    stop(): Promise<void>;
    enableSound(): Promise<void>;
    disableSound(): Promise<void>;
    hasSound(): Promise<boolean>;
    isSocialEmote(): Promise<boolean>;
    getSocialEmoteAnimations: () => Promise<SocialEmoteAnimation[] | null>;
    getPlayingSocialEmoteAnimation: () => Promise<SocialEmoteAnimation | null>;
    emote: EmoteDefinition | null;
    events: Emitter<EmoteEvents>;
}

/**
 * @public
 */
export declare type IPFSv1 = string;

/**
 * IPFSv1
 * @public
 */
export declare namespace IPFSv1 {
    const schema: JSONSchema<IPFSv1>;
    const validate: ValidateFunction<IPFSv1>;
}

/**
 * IPFSv2 is a data type that describes an IPFS v2 hash
 * @public
 */
export declare type IPFSv2 = string;

/**
 * IPFSv2
 * @public
 */
export declare namespace IPFSv2 {
    const schema: JSONSchema<IPFSv2>;
    const validate: ValidateFunction<IPFSv2>;
}

export declare interface IPhysicsController {
    setSpringBonesParams(itemId: string, params: Record<string, SpringBoneParams>): Promise<void>;
}

export declare interface IPreviewController {
    scene: ISceneController;
    emote: IEmoteController;
    physics: IPhysicsController;
}

export declare interface ISceneController {
    getScreenshot(width: number, height: number): Promise<string>;
    getMetrics(): Promise<Metrics>;
    changeZoom(zoom: number): Promise<void>;
    panCamera(offset: {
        x?: number;
        y?: number;
        z?: number;
    }): Promise<void>;
    changeCameraPosition(position: {
        alpha?: number;
        beta?: number;
        radius?: number;
    }): Promise<void>;
    setUsername(username: string): Promise<void>;
    cleanup(): Promise<void>;
}

/**
 * Known exceptions of parcels that are outside the standard limits
 * but are valid in Decentraland
 * @internal
 */
/**
 * Checks if a coordinate is in any exception block
 * @param x X coordinate of the parcel
 * @param y Y coordinate of the parcel
 * @returns true if the parcel is in any exception block
 */
export declare function isInExceptionBlock(x: number, y: number): boolean;

/**
 * Check if is inside World Limits
 * @alpha
 */
export declare function isInsideWorldLimits(x: number, y: number): boolean;

export declare function isStandard<T extends BaseItem>(item: T): item is T & StandardProps;

export declare const isSysLink: (link: any) => link is SysLink<any>;

export declare function isThirdParty<T extends BaseItem>(item: T): item is T & ThirdPartyProps;

export declare type Item = {
    id: string;
    name: string;
    thumbnail: string;
    url: string;
    category: NFTCategory;
    contractAddress: string;
    itemId: string;
    rarity: Rarity;
    price: string;
    available: number;
    isOnSale: boolean;
    creator: string;
    beneficiary: string | null;
    createdAt: number;
    updatedAt: number;
    reviewedAt: number;
    soldAt: number;
    data: NFT['data'];
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
    urn: string;
    /** The timestamp in seconds since epoch when the item was listed for sale for the first time */
    firstListedAt: number | null;
    picks?: {
        pickedByUser?: boolean;
        count: number;
    };
    /** The following fields are for the items for the Marketplace's catalog */
    minPrice?: string;
    minListingPrice?: string | null;
    maxListingPrice?: string | null;
    listings?: number | null;
    owners?: number | null;
    /** A description of the utility the item has in the explorer */
    utility?: string;
    tradeId?: string;
    tradeExpiresAt?: number;
    tradeContractAddress?: string;
};

export declare namespace Item {
    const schema: JSONSchema<Item>;
    const validate: ValidateFunction<Item>;
}

export declare type ItemBid = BaseBid & {
    tradeId: string;
    tradeContractAddress: string;
    itemId: string;
};

export declare type ItemFilters = {
    first?: number;
    skip?: number;
    sortBy?: ItemSortBy;
    category?: NFTCategory;
    /** The address or the addresses of the creators to filter for */
    creator?: string | string[];
    rarities?: Rarity[];
    isSoldOut?: boolean;
    isOnSale?: boolean;
    search?: string;
    isWearableHead?: boolean;
    isWearableAccessory?: boolean;
    isWearableSmart?: boolean;
    wearableCategory?: WearableCategory;
    wearableGenders?: (WearableGender | GenderFilterOption)[];
    emoteCategory?: EmoteCategory;
    emoteGenders?: (WearableGender | GenderFilterOption)[];
    emotePlayMode?: EmotePlayMode | EmotePlayMode[];
    ids?: string[];
    contractAddresses?: string[];
    itemId?: string;
    network?: Network;
    /**
     * Returns items whose price is greater or equal to this value
     */
    minPrice?: string;
    /**
     * Returns items whose price is smaller or equal to this value
     */
    maxPrice?: string;
    urns?: string[];
    /**
     * Returns emotes that have sound
     */
    emoteHasSound?: boolean;
    /**
     * Returns emotes that have additional geomtry
     */
    emoteHasGeometry?: boolean;
    /**
     * Returns emotes that have an outcome type
     */
    emoteOutcomeType?: EmoteOutcomeType;
};

export declare type ItemPublishedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.ITEM_PUBLISHED;
    metadata: {
        creator: string;
        category: string;
        itemId: string;
        urn: string;
        network: string;
        rarity?: string;
    };
};

export declare namespace ItemPublishedEvent {
    const schema: JSONSchema<ItemPublishedEvent>;
    const validate: ValidateFunction<ItemPublishedEvent>;
}

export declare type ItemSoldEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.ITEM_SOLD;
    metadata: {
        address: string;
        image: string;
        buyer: string;
        seller: string;
        category: string;
        rarity?: string;
        link: string;
        nftName?: string;
        tokenId: string;
        network: string;
        title: string;
        description: string;
    };
};

export declare namespace ItemSoldEvent {
    const schema: JSONSchema<ItemSoldEvent>;
    const validate: ValidateFunction<ItemSoldEvent>;
}

export declare enum ItemSortBy {
    NAME = "name",
    NEWEST = "newest",
    RECENTLY_REVIEWED = "recently_reviewed",
    RECENTLY_SOLD = "recently_sold",
    RECENTLY_LISTED = "recently_listed",
    CHEAPEST = "cheapest"
}

/**
 * This type alias exist only to avoid accidental refactors involving names of ajv
 * @public
 */
export declare type JSONSchema<T> = JSONSchemaType<T>;

export declare type LegacyBid = BaseBid & {
    bidAddress: string;
    blockchainId: string;
    blockNumber: string;
    tokenId: string;
};

/**
 * Link
 * @alpha
 */
export declare type Link = {
    title: string;
    url: LinkUrl;
};

/**
 * Link
 * @alpha
 */
export declare namespace Link {
    const schema: JSONSchema<Link>;
}

/**
 * Represents a Linker-Server Authorization.
 *
 * @public
 */
export declare type LinkerAuthorization = {
    name: string;
    desc: string;
    startDate?: string;
    endDate?: string;
    contactInfo: {
        name: string;
        [key: string]: string;
    };
    onlyDev?: boolean;
    addresses: string[];
    plots: string[];
};

export declare namespace LinkerAuthorization {
    const schema: JSONSchema<LinkerAuthorization>;
    const validate: ValidateFunction<LinkerAuthorization>;
}

/**
 * LinkUrl
 * @alpha
 */
export declare type LinkUrl = string;

/**
 * LinkUrl
 * @alpha
 */
export declare namespace LinkUrl {
    const schema: JSONSchema<LinkUrl>;
    const validate: ValidateFunction<LinkUrl>;
}

export declare enum ListingStatus {
    OPEN = "open",
    SOLD = "sold",
    CANCELLED = "cancelled"
}

export declare namespace ListingStatus {
    const schema: JSONSchema<ListingStatus>;
    const validate: ValidateFunction<ListingStatus>;
}

/** @alpha */
export declare enum Locale {
    EN = "en",
    ES = "es"
}

/** @alpha */
export declare namespace Locale {
    const schema: JSONSchema<Locale>;
    const validate: ValidateFunction<Locale>;
}

export declare type LocalizedField<T> = {
    [ContentfulLocale.enUS]: T;
    [ContentfulLocale.es]?: T;
    [ContentfulLocale.zh]?: T;
};

export declare type LocalizedFields = Record<string, LocalizedField<LocalizedFieldType>>;

export declare type LocalizedFieldType = any;

export declare type LoggedInCachedEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.LOGGED_IN_CACHED;
    metadata: ClientBaseMetadata & {
        realm: string;
        contextRuntime: string;
    };
};

export declare type LoggedInEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.LOGGED_IN;
    metadata: ClientBaseMetadata & {
        realm: string;
        contextRuntime: string;
    };
};

/**
 * Mapping
 * @alpha
 */
export declare type Mapping = SingleMapping | AnyMapping | RangeMapping | MultipleMapping;

/**
 * Mapping
 * @alpha
 */
export declare namespace Mapping {
    const schema: JSONSchema<Mapping>;
    const validate: ValidateFunction<Mapping>;
}

/**
 * Mappings
 * @alpha
 */
export declare type Mappings = Partial<Record<ContractNetwork, Record<ContractAddress, Mapping[]>>>;

/**
 * Mappings
 * @alpha
 */
export declare namespace Mappings {
    const _isMappingsValid: FuncKeywordDefinition;
    const innerSchema: JSONSchema<Record<ContractAddress, Mapping[]>>;
    const schema: JSONSchema<Mappings>;
    const validate: ValidateFunction<Mappings>;
}

export declare type MappingsHelper = {
    getMappings(): Mappings;
    addMapping(network: ContractNetwork, contractAddress: ContractAddress, mapping: Mapping): void;
    includesNft(network: ContractNetwork, contractAddress: ContractAddress, tokenId: string): boolean;
};

/**
 * MappingType
 * @alpha
 */
export declare enum MappingType {
    SINGLE = "single",
    ANY = "any",
    MULTIPLE = "multiple",
    RANGE = "range"
}

export declare type MarketingAdminFields = {
    name: LocalizedField<string>;
    campaign?: LocalizedField<SysLink<'Entry'>>;
    marketplaceHomepageBanner?: LocalizedField<SysLink<'Entry'>>;
    marketplaceCollectiblesBanner?: LocalizedField<SysLink<'Entry'>>;
    marketplaceCampaignCollectiblesBanner?: LocalizedField<SysLink<'Entry'>>;
    builderCampaignBanner?: LocalizedField<SysLink<'Entry'>>;
};

/**
 * Merkle Proof
 * @alpha
 */
export declare type MerkleProof = {
    proof: string[];
    index: number;
    hashingKeys: string[];
    entityHash: string;
};

/**
 * Merkle Proof
 * @alpha
 */
export declare namespace MerkleProof {
    const schema: JSONSchema<MerkleProof>;
    const validate: ValidateFunction<MerkleProof>;
}

/** @public */
declare type Messages = SceneUpdate | Update;

/**
 * Meta-transaction to be relayed
 * @alpha
 */
export declare type MetaTransaction = {
    from: string;
    params: [string, string];
};

/**
 * @alpha
 */
export declare namespace MetaTransaction {
    const schema: JSONSchema<MetaTransaction>;
    const validate: ValidateFunction<MetaTransaction>;
}

/** @alpha */
export declare type Metrics = {
    triangles: number;
    materials: number;
    textures: number;
    meshes: number;
    bodies: number;
    entities: number;
};

/** @alpha */
export declare namespace Metrics {
    const schema: JSONSchema<Metrics>;
    const validate: ValidateFunction<Metrics>;
}

export declare type Mint = {
    id: string;
    creator: string;
    beneficiary: string;
    minter: string;
    itemId: string;
    tokenId: string;
    issuedId: string;
    contractAddress: string;
    price: string | null;
    timestamp: number;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
};

export declare namespace Mint {
    const schema: JSONSchema<Mint>;
    const validate: ValidateFunction<Mint>;
}

export declare type MintFilters = {
    first?: number;
    skip?: number;
    sortBy?: MintSortBy;
    creator?: string;
    beneficiary?: string;
    minter?: string;
    contractAddress?: string;
    itemId?: string;
    tokenId?: string;
    issuedId?: string;
    isSale?: boolean;
    network?: Network;
};

export declare enum MintSortBy {
    RECENTLY_MINTED = "recently_minted",
    MOST_EXPENSIVE = "most_expensive"
}

export declare type MoveToParcelEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.MOVE_TO_PARCEL;
    metadata: ClientBaseMetadata & {
        parcel: {
            isEmptyParcel: boolean;
            newParcel: string;
            oldParcel: string;
            sceneHash: string;
        };
    };
};

/**
 * MultipleMapping
 * @alpha
 */
export declare type MultipleMapping = {
    type: MappingType.MULTIPLE;
    ids: string[];
};

/**
 * MultipleMapping
 * @alpha
 */
export declare namespace MultipleMapping {
    const schema: JSONSchema<MultipleMapping>;
    const validate: ValidateFunction<Mapping>;
}

declare type MultiPosition = {
    x: number[];
    y: number[];
    z: number[];
};

/**
 * Different supported networks
 * @alpha
 */
export declare enum Network {
    ETHEREUM = "ETHEREUM",
    MATIC = "MATIC",
    AVALANCHE = "AVALANCHE",
    BSC = "BINANCE SMART CHAIN",
    OPTIMISM = "OPTIMISM",
    ARBITRUM = "ARBITRUM",
    FANTOM = "FANTOM"
}

/**
 * @alpha
 */
export declare namespace Network {
    const schema: JSONSchema<Network>;
    const validate: ValidateFunction<Network>;
}

export declare type NFT = {
    id: string;
    contractAddress: string;
    tokenId: string;
    activeOrderId: string | null;
    /** The ID of the open rental listing associated with the NFT */
    openRentalId: string | null;
    owner: string;
    name: string;
    category: NFTCategory;
    image: string;
    url: string;
    issuedId: string | null;
    itemId: string | null;
    data: {
        parcel?: {
            x: string;
            y: string;
            description: string | null;
            estate: {
                tokenId: string;
                name: string;
            } | null;
        };
        estate?: {
            size: number;
            parcels: {
                x: number;
                y: number;
            }[];
            description: string | null;
        };
        wearable?: {
            description: string;
            category: WearableCategory;
            rarity: Rarity;
            bodyShapes: BodyShape[];
            isSmart: boolean;
        };
        ens?: {
            subdomain: string;
        };
        emote?: {
            description: string;
            category: EmoteCategory;
            rarity: Rarity;
            bodyShapes: BodyShape[];
            loop: boolean;
            hasSound: boolean;
            hasGeometry: boolean;
            outcomeType: EmoteOutcomeType | null;
        };
    };
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
    createdAt: number;
    updatedAt: number;
    soldAt: number;
    urn?: string;
    /** A description of the utility the nft has in the explorer */
    utility?: string;
};

export declare namespace NFT {
    const schema: JSONSchema<NFT>;
    const validate: ValidateFunction<NFT>;
}

export declare type NFTBid = BaseBid & {
    tradeId: string;
    tradeContractAddress: string;
    tokenId: string;
};

export declare enum NFTCategory {
    PARCEL = "parcel",
    ESTATE = "estate",
    WEARABLE = "wearable",
    ENS = "ens",
    EMOTE = "emote"
}

export declare namespace NFTCategory {
    const schema: JSONSchema<NFTCategory>;
    const validate: ValidateFunction<NFTCategory>;
}

export declare type NFTFilters = {
    first?: number;
    skip?: number;
    sortBy?: NFTSortBy;
    category?: NFTCategory;
    owner?: string;
    isOnSale?: boolean;
    isOnRent?: boolean;
    search?: string;
    itemRarities?: Rarity[];
    isLand?: boolean;
    isWearableHead?: boolean;
    isWearableAccessory?: boolean;
    isWearableSmart?: boolean;
    wearableCategory?: WearableCategory;
    wearableGenders?: (WearableGender | GenderFilterOption)[];
    emoteCategory?: EmoteCategory;
    emoteGenders?: (WearableGender | GenderFilterOption)[];
    emotePlayMode?: EmotePlayMode | EmotePlayMode[];
    contractAddresses?: string[];
    creator?: string | string[];
    tokenId?: string;
    itemId?: string;
    network?: Network;
    rentalStatus?: RentalsListingsFilterBy['status'];
    ids?: string[];
    minPrice?: string;
    maxPrice?: string;
    /** Filter NFTs with a min estate size */
    minEstateSize?: number;
    /** Filter NFTs with a max estate size */
    maxEstateSize?: number;
    /** Filter NFTs with at least this distance to a plaza */
    minDistanceToPlaza?: number;
    /** Filter NFTs with at most this distance to a plaza */
    maxDistanceToPlaza?: number;
    /** Filter NFTs that are next to a road */
    adjacentToRoad?: boolean;
    /** Filter NFTs by rentals that have periods that include any of the rental days */
    rentalDays?: number[];
    /**
     * Returns emotes that have sound
     */
    emoteHasSound?: boolean;
    /**
     * Returns emotes that have additional geomtry
     */
    emoteHasGeometry?: boolean;
    /**
     * Returns emotes that have an outcome type
     */
    emoteOutcomeType?: EmoteOutcomeType;
} & Pick<RentalsListingsFilterBy, 'tenant'>;

export declare enum NFTSortBy {
    NAME = "name",
    NEWEST = "newest",
    RECENTLY_LISTED = "recently_listed",
    RECENTLY_SOLD = "recently_sold",
    CHEAPEST = "cheapest",
    RENTAL_LISTING_DATE = "rental_listing_date",
    RENTAL_DATE = "rented_date",
    MAX_RENTAL_PRICE = "max_rental_price",
    MIN_RENTAL_PRICE = "min_rental_price"
}

/**
 * The channel used for sending the notification
 * @alpha
 */
export declare type NotificationChannelType = {
    email: boolean;
    in_app: boolean;
};

/**
 * The scope of the notification opt out
 * @alpha
 */
export declare enum NotificationOptOutScope {
    COMMUNITY = "community"
}

/**
 * Notification Types (the keys as stored in the notifications DB)
 * @alpha
 */
export declare enum NotificationType {
    BADGE_GRANTED = "badge_granted",
    BID_ACCEPTED = "bid_accepted",
    BID_RECEIVED = "bid_received",
    EVENTS_STARTED = "events_started",
    EVENTS_STARTS_SOON = "events_starts_soon",
    EVENT_CREATED = "event_created",
    EVENT_APPROVED = "event_approved",
    EVENT_REJECTED = "event_rejected",
    GOVERNANCE_ANNOUNCEMENT = "governance_announcement",
    GOVERNANCE_AUTHORED_PROPOSAL_FINISHED = "governance_authored_proposal_finished",
    GOVERNANCE_COAUTHOR_REQUESTED = "governance_coauthor_requested",
    GOVERNANCE_CLIFF_ENDED = "governance_cliff_ended",
    GOVERNANCE_NEW_COMMENT_ON_PROJECT_UPDATE = "governance_new_comment_on_project_update",
    GOVERNANCE_NEW_COMMENT_ON_PROPOSAL = "governance_new_comment_on_proposal",
    GOVERNANCE_PROPOSAL_ENACTED = "governance_proposal_enacted",
    GOVERNANCE_VOTING_ENDED_VOTER = "governance_voting_ended_voter",
    GOVERNANCE_PITCH_PASSED = "governance_pitch_passed",
    GOVERNANCE_TENDER_PASSED = "governance_tender_passed",
    GOVERNANCE_WHALE_VOTE = "governance_whale_vote",
    GOVERNANCE_VOTED_ON_BEHALF = "governance_voted_on_behalf",
    ITEM_SOLD = "item_sold",
    ITEM_PUBLISHED = "item_published",
    LAND_RENTAL_ENDED = "rental_ended",
    LAND_RENTED = "rental_started",
    REWARD_ASSIGNED = "reward_assignment",
    REWARD_CAMPAIGN_OUT_OF_FUNDS = "reward_campaign_out_of_funds",
    REWARD_CAMPAIGN_GAS_PRICE_HIGHER_THAN_EXPECTED = "reward_campaign_gas_price_higher_than_expected",
    REWARD_CAMPAIGN_OUT_OF_STOCK = "reward_campaign_out_of_stock",
    REWARD_DELAYED = "reward_delayed",
    REWARD_IN_PROGRESS = "reward_in_progress",
    ROYALTIES_EARNED = "royalties_earned",
    SOCIAL_SERVICE_FRIENDSHIP_REQUEST = "social_service_friendship_request",
    SOCIAL_SERVICE_FRIENDSHIP_ACCEPTED = "social_service_friendship_accepted",
    WORLDS_ACCESS_RESTORED = "worlds_access_restored",
    WORLDS_ACCESS_RESTRICTED = "worlds_access_restricted",
    WORLDS_MISSING_RESOURCES = "worlds_missing_resources",
    WORLDS_PERMISSION_GRANTED = "worlds_permission_granted",
    WORLDS_PERMISSION_REVOKED = "worlds_permission_revoked",
    CREDITS_GOAL_COMPLETED = "credits_goal_completed",
    CREDITS_ON_DEMAND_GRANTED = "credits_on_demand_granted",
    STREAMING_KEY_RESET = "streaming_key_reset",
    STREAMING_KEY_REVOKE = "streaming_key_revoke",
    STREAMING_KEY_EXPIRED = "streaming_key_expired",
    STREAMING_TIME_EXCEEDED = "streaming_time_exceeded",
    STREAMING_PLACE_UPDATED = "streaming_place_updated",
    CREDITS_REMINDER_COMPLETE_GOALS = "credits_reminder_complete_goals",
    CREDITS_REMINDER_CLAIM_CREDITS = "credits_reminder_claim_credits",
    CREDITS_REMINDER_USAGE = "credits_reminder_usage",
    CREDITS_REMINDER_USAGE_24_HOURS = "credits_reminder_usage_24_hours",
    CREDITS_REMINDER_DO_NOT_MISS_OUT = "credits_reminder_do_not_miss_out",
    CREDITS_NEW_SEASON_REMINDER = "credits_new_season_reminder",
    REFERRAL_INVITED_USERS_ACCEPTED = "referral_invited_users_accepted",
    REFERRAL_NEW_TIER_REACHED = "referral_new_tier_reached",
    COMMUNITY_DELETED = "community_deleted",
    COMMUNITY_DELETED_CONTENT_VIOLATION = "community_deleted_content_violation",
    COMMUNITY_RENAMED = "community_renamed",
    COMMUNITY_MEMBER_BANNED = "community_member_banned",
    COMMUNITY_MEMBER_REMOVED = "community_member_removed",
    COMMUNITY_REQUEST_TO_JOIN_RECEIVED = "community_request_to_join_received",
    COMMUNITY_REQUEST_TO_JOIN_ACCEPTED = "community_request_to_join_accepted",
    COMMUNITY_INVITE_RECEIVED = "community_invite_received",
    COMMUNITY_OWNERSHIP_TRANSFERRED = "community_ownership_transferred",
    COMMUNITY_POST_ADDED = "community_post_added",
    COMMUNITY_VOICE_CHAT_STARTED = "community_voice_chat_started",
    USER_BANNED_FROM_SCENE = "user_banned_from_scene",
    USER_UNBANNED_FROM_SCENE = "user_unbanned_from_scene",
    TRANSFER_RECEIVED = "transfer_received",
    TIP_RECEIVED = "tip_received",
    BANNED = "banned",
    BAN_WARNING = "ban_warning",
    BAN_LIFTED = "ban_lifted"
}

export declare type OnChainTrade = {
    signer: string;
    signature: string;
    checks: TradeChecks & {
        allowedProof: string[];
    };
    sent: OnChainTradeAsset[];
    received: OnChainTradeAsset[];
};

export declare type OnChainTradeAsset = {
    assetType: TradeAssetType;
    contractAddress: string;
    value: string;
    extra: string;
    beneficiary: string;
};

export declare type Order = {
    id: string;
    marketplaceAddress: string;
    contractAddress: string;
    tokenId: string;
    owner: string;
    buyer: string | null;
    price: string;
    status: ListingStatus;
    expiresAt: number;
    createdAt: number;
    updatedAt: number;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
    issuedId: string;
    tradeId?: string;
};

export declare namespace Order {
    const schema: JSONSchema<Order>;
    const validate: ValidateFunction<Order>;
}

export declare type OrderFilters = {
    first?: number;
    skip?: number;
    sortBy?: OrderSortBy;
    marketplaceAddress?: string;
    owner?: string;
    buyer?: string;
    contractAddress?: string;
    tokenId?: string;
    status?: ListingStatus;
    network?: Network;
    itemId?: string;
    nftName?: string;
};

export declare enum OrderSortBy {
    RECENTLY_LISTED = "recently_listed",
    RECENTLY_UPDATED = "recently_updated",
    CHEAPEST = "cheapest",
    ISSUED_ID_ASC = "issued_id_asc",
    ISSUED_ID_DESC = "issued_id_desc",
    OLDEST = "oldest"
}

export declare type OutcomeGroup = {
    title: string;
    loop: boolean;
    clips: Partial<Record<ArmatureId, EmoteClip>>;
    audio?: string;
};

export declare namespace OutcomeGroup {
    const schema: JSONSchema<OutcomeGroup>;
    const validate: ValidateFunction<OutcomeGroup>;
}

/**
 * @alpha
 */
export declare type Outfit = {
    bodyShape: WearableId;
    eyes: {
        color: Color3;
    };
    hair: {
        color: Color3;
    };
    skin: {
        color: Color3;
    };
    wearables: WearableId[];
    forceRender?: WearableCategory[];
};

/**
 * Outfit
 * @alpha
 */
export declare namespace Outfit {
    const schema: JSONSchema<Outfit>;
    const validate: ValidateFunction<Outfit>;
}

/**
 * @alpha
 */
export declare type Outfits = {
    outfits: {
        slot: number;
        outfit: Outfit;
    }[];
    namesForExtraSlots: string[];
};

/**
 * Outfits
 * @alpha
 */
export declare namespace Outfits {
    const schema: JSONSchema<Outfits>;
    const validate: ValidateFunction<Outfits>;
}

export declare type PaginatedParameters = {
    limit?: number;
    offset?: number;
};

export declare type PaginatedResponse<T> = {
    results: T[];
    total: number;
    page: number;
    pages: number;
    limit: number;
};

/**
 * Represents a parcel with X and Y coordinates
 * @public
 */
export declare type Parcel = {
    x: number;
    y: number;
};

/**
 * Namespace with utilities to validate parcels
 * @public
 */
export declare namespace Parcel {
    /**
     * Custom validation to check if coordinates are within limits
     */
    const _isInLimits: KeywordDefinition;
    const schema: JSONSchema<Parcel>;
    const validate: ValidateFunction<Parcel>;
    export function parcelToString({ x, y }: Parcel): string;
    export function stringToParcel(position: string): Parcel | null;
    /**
     * Validates if a string in "x,y" format represents a valid parcel
     */
    export function isParcelStringValid(parcelString: string): boolean;
    /**
     * Checks if a parcel is within the standard bounds
     */
    export function isInStandardBounds(parcel: Parcel): boolean;
    /**
     * Checks if a parcel is a known exception
     */
    export function isExceptionParcel(parcel: Parcel): boolean;
    /**
     * Checks if a parcel is within bounds or is a valid exception
     */
    export function isInBounds(parcel: Parcel): boolean;
    /**
     * Validates if a parcel is valid (satisfies the schema and is within bounds or is an exception)
     */
    export function isValid(parcel: Parcel): boolean;
    /**
     * Validates if a parcel in string format is valid
     */
    export function isValidString(parcelString: string): boolean;
}

/**
 * Standard limits for parcels in Decentraland
 * @public
 */
export declare const PARCEL_LIMITS: {
    minX: number;
    maxX: number;
    minY: number;
    maxY: number;
};

export declare type PassportOpenedEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.PASSPORT_OPENED;
    metadata: ClientBaseMetadata & {
        passport: {
            receiver: EthAddress;
        };
    };
};

/**
 * The input that is required to create a rental listing period.
 */
export declare type PeriodCreation = {
    /** The minimum amount of days of the period */
    minDays: number;
    /** The maximum amount of days of the period */
    maxDays: number;
    /** The price per day */
    pricePerDay: string;
};

export declare namespace PeriodCreation {
    const schema: JSONSchemaType<PeriodCreation>;
    const validate: ValidateFunction<PeriodCreation>;
}

export declare type PhotoPrivacyChangedEvent = BaseEvent & {
    type: Events.Type.CAMERA;
    subType: Events.SubType.Camera.PHOTO_PRIVACY_CHANGED;
    metadata: {
        userAddress: string;
        photoId: string;
        isPublic: boolean;
    };
};

export declare namespace PhotoPrivacyChangedEvent {
    const schema: JSONSchema<PhotoPrivacyChangedEvent>;
    const validate: ValidateFunction<PhotoPrivacyChangedEvent>;
}

export declare type PhotoTakenEvent = BaseEvent & {
    type: Events.Type.CAMERA;
    subType: Events.SubType.Camera.PHOTO_TAKEN;
    metadata: {
        sceneId: string;
        realm: string;
        userAddress: string;
        isPublic: boolean;
        photoId: string;
        users: Array<{
            address: string;
            isEmoting: boolean;
        }>;
        placeId?: string;
    };
};

export declare namespace PhotoTakenEvent {
    const schema: JSONSchema<PhotoTakenEvent>;
    const validate: ValidateFunction<PhotoTakenEvent>;
}

/**
 * This type describes deployment + AuthChain needed to synchronize
 * a deployed entity across catalysts from the old snapshots and /pointer-changes endpoint.
 * @public
 */
export declare type PointerChangesSyncDeployment = SnapshotSyncDeployment & {
    localTimestamp: number;
};

/**
 * @public
 */
export declare namespace PointerChangesSyncDeployment {
    const schema: JSONSchema<PointerChangesSyncDeployment>;
    const validate: ValidateFunction<PointerChangesSyncDeployment>;
}

declare type PortableExperiencesToggles = EnabledDisabled | 'hideUi';

export declare enum PreviewCamera {
    STATIC = "static",
    INTERACTIVE = "interactive"
}

/** @alpha */
export declare namespace PreviewCamera {
    const schema: JSONSchema<PreviewCamera>;
    const validate: ValidateFunction<PreviewCamera>;
}

export declare type PreviewConfig = {
    item?: WearableDefinition | EmoteDefinition;
    wearables: WearableDefinition[];
    bodyShape: BodyShape;
    skin: string;
    hair: string;
    eyes: string;
    zoom: number;
    type: PreviewType;
    face: boolean;
    background: {
        image?: string;
        color: string;
        transparent: boolean;
    };
    emote: PreviewEmote | null;
    camera: PreviewCamera;
    projection: PreviewProjection;
    autoRotateSpeed: number;
    centerBoundingBox: boolean;
    fadeEffect: boolean;
    showSceneBoundaries?: boolean;
    showThumbnailBoundaries?: boolean;
    offsetX: number;
    offsetY: number;
    offsetZ: number;
    cameraX: number;
    cameraY: number;
    cameraZ: number;
    wheelZoom: number;
    wheelPrecision: number;
    wheelStart: number;
    panning: boolean;
    lockAlpha: boolean;
    lockBeta: boolean;
    lockRadius: boolean;
    forceRender?: Array<string>;
    unityMode?: PreviewUnityMode;
    unity?: boolean;
    disableLoader?: boolean;
    socialEmote?: SocialEmoteAnimation;
};

export declare enum PreviewEmote {
    IDLE = "idle",
    WALK = "walk",
    RUN = "run",
    JUMP = "jump",
    CLAP = "clap",
    DAB = "dab",
    DANCE = "dance",
    FASHION = "fashion",
    FASHION_2 = "fashion-2",
    FASHION_3 = "fashion-3",
    FASHION_4 = "fashion-4",
    LOVE = "love",
    MONEY = "money",
    FIST_PUMP = "fist-pump",
    HEAD_EXPLODE = "head-explode",
    WAVE = "wave"
}

/** @alpha */
export declare namespace PreviewEmote {
    const schema: JSONSchema<PreviewEmote>;
    const validate: ValidateFunction<PreviewEmote>;
}

export declare enum PreviewEmoteEventType {
    ANIMATION_PLAY = "animation_play",
    ANIMATION_PAUSE = "animation_pause",
    ANIMATION_LOOP = "animation_loop",
    ANIMATION_END = "animation_end",
    ANIMATION_PLAYING = "animation_playing"
}

/** @alpha */
export declare namespace PreviewEmoteEventType {
    const schema: JSONSchema<PreviewEmoteEventType>;
    const validate: ValidateFunction<PreviewEmoteEventType>;
}

export declare type PreviewMessagePayload<T extends PreviewMessageType> = T extends PreviewMessageType.READY ? null : T extends PreviewMessageType.LOAD ? {
    renderer: PreviewRenderer;
} | null : T extends PreviewMessageType.ERROR ? {
    message: string;
} : T extends PreviewMessageType.UPDATE ? {
    options: PreviewOptions;
} : T extends PreviewMessageType.CONTROLLER_REQUEST ? {
    id: string;
    namespace: 'scene' | 'emote' | 'physics';
    method: 'getScreenshot' | 'getMetrics' | 'changeZoom' | 'changeCameraPosition' | 'panCamera' | 'cleanup' | 'getLength' | 'isPlaying' | 'play' | 'pause' | 'stop' | 'goTo' | 'enableSound' | 'disableSound' | 'hasSound' | 'setUsername' | 'setSpringBonesParams';
    params: any[];
} : T extends PreviewMessageType.CONTROLLER_RESPONSE ? {
    id: string;
    ok: true;
    result: any;
} | {
    id: string;
    ok: false;
    error: string;
} : T extends PreviewMessageType.EMOTE_EVENT ? {
    type: PreviewEmoteEventType;
    payload: EmoteEventPayload<PreviewEmoteEventType>;
} : unknown;

export declare enum PreviewMessageType {
    READY = "ready",
    LOAD = "load",
    ERROR = "error",
    UPDATE = "update",
    CONTROLLER_REQUEST = "controller_request",
    CONTROLLER_RESPONSE = "controller_response",
    EMOTE_EVENT = "emote_event"
}

/** @alpha */
export declare namespace PreviewMessageType {
    const schema: JSONSchema<PreviewMessageType>;
    const validate: ValidateFunction<PreviewMessageType>;
}

/** @alpha */
export declare type PreviewOptions = {
    contractAddress?: string | null;
    tokenId?: string | null;
    itemId?: string | null;
    profile?: string | null;
    bodyShape?: BodyShape | null;
    type?: PreviewType | null;
    skin?: string | null;
    hair?: string | null;
    eyes?: string | null;
    urns?: string[] | null;
    urls?: string[] | null;
    base64s?: string[] | null;
    blob?: WearableWithBlobs | EmoteWithBlobs | null;
    zoom?: number | null;
    zoomScale?: number | null;
    emote?: PreviewEmote | null;
    camera?: PreviewCamera | null;
    projection?: PreviewProjection | null;
    autoRotateSpeed?: number | null;
    offsetX?: number | null;
    offsetY?: number | null;
    offsetZ?: number | null;
    cameraX?: number | null;
    cameraY?: number | null;
    cameraZ?: number | null;
    wheelZoom?: number | null;
    wheelPrecision?: number | null;
    wheelStart?: number | null;
    background?: string | null;
    disableBackground?: boolean | null;
    disableAutoCenter?: boolean | null;
    disableAutoRotate?: boolean | null;
    disableFace?: boolean | null;
    disableDefaultWearables?: boolean | null;
    disableDefaultEmotes?: boolean | null;
    disableFadeEffect?: boolean | null;
    showSceneBoundaries?: boolean;
    showThumbnailBoundaries?: boolean;
    peerUrl?: string | null;
    /** @deprecated Use marketplaceServerUrl instead.*/
    nftServerUrl?: string | null;
    marketplaceServerUrl?: string | null;
    panning?: boolean;
    lockAlpha?: boolean;
    lockBeta?: boolean;
    lockRadius?: boolean;
    username?: string | null;
    unityMode?: PreviewUnityMode | null;
    unity?: boolean | null;
    disableLoader?: boolean | null;
    socialEmote?: SocialEmoteAnimation | null;
};

export declare enum PreviewProjection {
    ORTHOGRAPHIC = "orthographic",
    PERSPECTIVE = "perspective"
}

export declare namespace PreviewProjection {
    const schema: JSONSchema<PreviewProjection>;
    const validate: ValidateFunction<PreviewProjection>;
}

export declare enum PreviewRenderer {
    BABYLON = "babylon",
    UNITY = "unity"
}

/** @alpha */
export declare enum PreviewType {
    TEXTURE = "texture",
    WEARABLE = "wearable",
    AVATAR = "avatar"
}

/** @alpha */
export declare namespace PreviewType {
    const schema: JSONSchema<PreviewType>;
    const validate: ValidateFunction<PreviewType>;
}

export declare enum PreviewUnityMode {
    AUTH = "authentication",
    BUILDER = "builder",
    MARKETPLACE = "marketplace",
    PROFILE = "profile",
    CONFIG = "configurator",
    JESUS = "jesus"
}

/**
 * Profile containing one or multiple avatars
 * @alpha
 */
export declare type Profile = {
    avatars: Avatar[];
};

/**
 * Profile
 * @alpha
 */
export declare namespace Profile {
    const schema: JSONSchema<Profile>;
    const validate: ValidateFunction<Profile>;
}

/** @public */
declare enum ProjectType {
    SCENE = "scene",
    SMART_ITEM = "smart-item",
    PORTABLE_EXPERIENCE = "portable-experience",
    LIBRARY = "library"
}

/** @public */
declare namespace ProjectType {
    const schema: JSONSchema<ProjectType>;
    const validate: ValidateFunction<ProjectType>;
}

/**
 * Different supported providers
 * @alpha
 */
export declare enum ProviderType {
    INJECTED = "injected",
    MAGIC = "magic",
    MAGIC_TEST = "magic_test",
    FORTMATIC = "formatic",
    NETWORK = "network",
    WALLET_CONNECT = "wallet_connect",
    WALLET_CONNECT_V2 = "wallet_connect_v2",
    WALLET_LINK = "wallet_link",
    METAMASK_MOBILE = "metamask_mobile",
    AUTH_SERVER = "auth_server",
    THIRDWEB = "thirdweb"
}

/**
 * @alpha
 */
export declare namespace ProviderType {
    const schema: JSONSchema<ProviderType>;
    const validate: ValidateFunction<ProviderType>;
}

/**
 * RangeMapping
 * @alpha
 */
export declare type RangeMapping = {
    type: MappingType.RANGE;
    from: string;
    to: string;
};

/**
 * RangeMapping
 * @alpha
 */
export declare namespace RangeMapping {
    const _fromLessThanOrEqualTo: KeywordDefinition;
    const schema: JSONSchema<RangeMapping>;
    const validate: ValidateFunction<Mapping>;
}

export declare enum Rarity {
    UNIQUE = "unique",
    MYTHIC = "mythic",
    EXOTIC = "exotic",
    LEGENDARY = "legendary",
    EPIC = "epic",
    RARE = "rare",
    UNCOMMON = "uncommon",
    COMMON = "common"
}

export declare namespace Rarity {
    const schema: JSONSchema<Rarity>;
    const validate: ValidateFunction<Rarity>;
    export function getMaxSupply(rarity: Rarity): number;
    export function getColor(rarity: Rarity): string;
    export function getRarities(): Rarity[];
    export function getGradient(rarity: Rarity): [string, string];
}

export declare type ReferralInvitedUsersAcceptedEvent = BaseEvent & {
    type: Events.Type.REFERRAL;
    subType: Events.SubType.Referral.REFERRAL_INVITED_USERS_ACCEPTED;
    metadata: ReferralMetadata;
};

export declare namespace ReferralInvitedUsersAcceptedEvent {
    const schema: JSONSchema<ReferralInvitedUsersAcceptedEvent>;
    const validate: ValidateFunction<ReferralInvitedUsersAcceptedEvent>;
}

declare type ReferralMetadata = {
    title: string;
    description: string;
    address: string;
    tier: number;
    url: string;
    image: string;
    invitedUserAddress: string;
    invitedUsers: number;
    rarity: string | null;
};

export declare type ReferralNewTierReachedEvent = BaseEvent & {
    type: Events.Type.REFERRAL;
    subType: Events.SubType.Referral.REFERRAL_NEW_TIER_REACHED;
    metadata: ReferralMetadata;
};

export declare namespace ReferralNewTierReachedEvent {
    const schema: JSONSchema<ReferralNewTierReachedEvent>;
    const validate: ValidateFunction<ReferralNewTierReachedEvent>;
}

export declare type RentalEndedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.RENTAL_ENDED;
    metadata: RentalMetadata;
};

export declare namespace RentalEndedEvent {
    const schema: JSONSchema<RentalEndedEvent>;
    const validate: ValidateFunction<RentalEndedEvent>;
}

/**
 * A rental listing.
 */
export declare type RentalListing = {
    /** The ID of the rental listing in the signature server */
    id: string;
    /** The NFT token ID */
    nftId: string;
    /** The category of the NFT being rented */
    category: NFTCategory;
    /** The blockchain search text of the NFT asset */
    searchText: string;
    /** The network where the asset being rented is on */
    network: Network.ETHEREUM;
    /** The chain id where the asset being rented is on */
    chainId: ChainId;
    /** UTC timestamp in milliseconds since epoch of the signature's expiration */
    expiration: number;
    /** A hex string representation of the rental signature */
    signature: string;
    /** A string representation of the nonces, the first nonce is the contract's nonce, the second one is the signer's nonce and the third is the asset's nonce */
    nonces: string[];
    /** The NFT token id */
    tokenId: string;
    /** The contract address of the NFT */
    contractAddress: string;
    /** The contract address of the rentals contract */
    rentalContractAddress: string;
    /** The address of the lessor */
    lessor: string | null;
    /** The address of the tenant */
    tenant: string | null;
    /** The status of the rental */
    status: RentalStatus;
    /** UTC timestamp in milliseconds since epoch of the time the signature was created */
    createdAt: number;
    /** UTC timestamp in milliseconds since epoch of the time the signature was updated */
    updatedAt: number;
    /** UTC timestamp in milliseconds since epoch of the time the rental started */
    startedAt: number | null;
    /** The periods of the rental */
    periods: RentalListingPeriod[];
    /** The target address that can use the signature. If no target is wanted, the zero address will be used  */
    target: string;
    /** The amount of days the land was rented for. NULL if it's in open or cancel status  */
    rentedDays: number | null;
};

/**
 * The input that is required to create a rental listing.
 */
export declare type RentalListingCreation = {
    /** The network where the asset being rented is on */
    network: Network.ETHEREUM;
    /** The chain id where the asset being rented is on */
    chainId: ChainId;
    /** UTC timestamp in milliseconds since epoch of the signature's expiration */
    expiration: number;
    /** A hex string representation of the rental signature */
    signature: string;
    /** The NFT token id */
    tokenId: string;
    /** The contract address of the NFT */
    contractAddress: string;
    /** The contract address of the rentals contract */
    rentalContractAddress: string;
    /** A string representation of the nonces, the first nonce is the contract's nonce, the second one is the signer's nonce and the third is the asset's nonce */
    nonces: string[];
    /** The periods of the rental */
    periods: PeriodCreation[];
    /** The target address that can use the signature. If no target is wanted, use the zero address  */
    target: string;
};

export declare namespace RentalListingCreation {
    const schema: JSONSchema<RentalListingCreation>;
    const validate: ValidateFunction<RentalListingCreation>;
}

/**
 * A period of a rental listing.
 */
export declare type RentalListingPeriod = {
    /** The minimum amount of days of the period */
    minDays: number;
    /** The maximum amount of days of the period */
    maxDays: number;
    /** The price per day */
    pricePerDay: string;
};

declare type RentalMetadata = {
    address: string;
    contract: string;
    land?: string;
    lessor: string;
    tenant: string;
    operator: string;
    startedAt: string;
    endedAt: string;
    tokenId: string;
    link: string;
    title: string;
    description?: string;
};

/**
 * All the possible parameters that a rental can be filtered for.
 */
export declare type RentalsListingsFilterBy = {
    /** The category of the NFT being rented */
    category?: RentalsListingsFilterByCategory;
    /** The blockchain search text of the NFT asset */
    text?: string;
    /** The listing status or statuses of the NFT asset rental */
    status?: RentalStatus | RentalStatus[];
    /** The periods of the rental listings the NFT assets where put for rent */
    periods?: RentalsListingsFilterByPeriod;
    /** The address of the lessor who put the NFT asset for rent */
    lessor?: string;
    /** The address of the tenant who rented the NFT asset */
    tenant?: string;
    /** The token id of the NFT asset that was put for rent */
    tokenId?: string;
    /** The contract address of the NFT asset that was put for rent  */
    contractAddresses?: string[];
    /** The network of the NFT that was put for rent */
    network?: Network;
    /** The NFT ids of the NFT assets that were put for rent */
    nftIds?: string[];
    /** The UTC timestamp in milliseconds since epoch to get the rentals that were updated after it */
    updatedAfter?: number;
    /** The target address of the rental. The default value is the address zero (everyone). */
    target?: string;
    /** The minimum price per day of the rental */
    minPricePerDay?: string;
    /** The maximun price per day of the rental */
    maxPricePerDay?: string;
    /** The minimum amount of parcels to a plaza */
    minDistanceToPlaza?: number;
    /**
     * The maxiumum amount of parcels to a plaza. If this value is more than 10, it will only bring those that
     * are less than 10 as those are the ones which distances were calculated
     */
    maxDistanceToPlaza?: number;
    /** The minimum amount of parcels in the estate */
    minEstateSize?: number;
    /** The maxiumum amount of parcels in the estate */
    maxEstateSize?: number;
    /** If true, it will fetch all parcels and estates that are next to a road */
    adjacentToRoad?: boolean;
    /** The days that a rental should be available */
    rentalDays?: number[];
};

/**
 * All the possible NFT categories of a rental listing.
 */
export declare enum RentalsListingsFilterByCategory {
    PARCEL = "parcel",
    ESTATE = "estate"
}

/**
 * All the possible parameters that a rental can be filtered for based on their periods.
 */
export declare type RentalsListingsFilterByPeriod = {
    /** The minimum amount of days of the period */
    minDays: number;
    /** The maximum amount of days of the period */
    maxDays: number;
    /** The price per day */
    pricePerDay?: number;
};

/**
 * All the possible sort directions.
 */
export declare enum RentalsListingSortDirection {
    ASC = "asc",
    DESC = "desc"
}

/**
 * All the possible parameters that a rental listing can be sorted by.
 */
export declare enum RentalsListingsSortBy {
    /** Order by created at of the listing's metadata */
    LAND_CREATION_DATE = "land_creation_date",
    /** Order by created at of the listing */
    RENTAL_LISTING_DATE = "rental_listing_date",
    /** Order by rented at of the listing */
    RENTAL_DATE = "rented_date",
    /** Order by search text of the listing's metadata */
    NAME = "name",
    /** Order by maximum rental price per day of the listing */
    MAX_RENTAL_PRICE = "max_rental_price",
    /** Order by minimum rental price per day of the listing */
    MIN_RENTAL_PRICE = "min_rental_price"
}

export declare type RentalStartedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.RENTAL_STARTED;
    metadata: RentalMetadata;
};

export declare namespace RentalStartedEvent {
    const schema: JSONSchema<RentalStartedEvent>;
    const validate: ValidateFunction<RentalStartedEvent>;
}

/**
 * All the possible rental statuses.
 * (This will be merged into ListingStatus eventually)
 */
export declare enum RentalStatus {
    OPEN = "open",
    CANCELLED = "cancelled",
    EXECUTED = "executed",
    CLAIMED = "claimed"
}

/** @alpha */
export declare enum RequiredPermission {
    ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE = "ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE",
    ALLOW_TO_TRIGGER_AVATAR_EMOTE = "ALLOW_TO_TRIGGER_AVATAR_EMOTE",
    ALLOW_MEDIA_HOSTNAMES = "ALLOW_MEDIA_HOSTNAMES",
    USE_WEB3_API = "USE_WEB3_API",
    USE_FETCH = "USE_FETCH",
    USE_WEBSOCKET = "USE_WEBSOCKET",
    OPEN_EXTERNAL_LINK = "OPEN_EXTERNAL_LINK"
}

export declare type RewardAssignedEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.REWARD_ASSIGNED;
    metadata: RewardEventMetadata;
};

export declare namespace RewardAssignedEvent {
    const schema: JSONSchema<RewardAssignedEvent>;
    const validate: ValidateFunction<RewardAssignedEvent>;
}

export declare type RewardDelayedEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.REWARD_DELAYED;
    metadata: RewardEventMetadata;
};

export declare namespace RewardDelayedEvent {
    const schema: JSONSchema<RewardDelayedEvent>;
    const validate: ValidateFunction<RewardDelayedEvent>;
}

export declare type RewardEventMetadata = BaseEventMetadata & {
    beneficiary: EthAddress;
    tokenName: string;
    tokenImage: string;
    tokenRarity?: string;
    tokenCategory?: string;
};

export declare type RewardInProgressEvent = BaseEvent & {
    type: Events.Type.REWARDS;
    subType: Events.SubType.Rewards.REWARD_IN_PROGRESS;
    metadata: RewardEventMetadata;
};

export declare namespace RewardInProgressEvent {
    const schema: JSONSchema<RewardInProgressEvent>;
    const validate: ValidateFunction<RewardInProgressEvent>;
}

export declare enum RoomType {
    PRIVATE_MESSAGE = "private-message",
    VOICE_CHAT = "voice-chat",
    COMMUNITY_VOICE_CHAT = "community-voice-chat",
    ISLAND = "island",
    SCENE = "scene",
    WORLD = "world",
    UNKNOWN = "unknown"
}

export declare type RoyaltiesEarnedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.ROYALTIES_EARNED;
    metadata: {
        address: string;
        image: string;
        category: string;
        rarity?: string;
        link: string;
        nftName?: string;
        royaltiesCut: string;
        royaltiesCollector: string;
        network: string;
        title: string;
        description?: string;
    };
};

export declare namespace RoyaltiesEarnedEvent {
    const schema: JSONSchema<RoyaltiesEarnedEvent>;
    const validate: ValidateFunction<RoyaltiesEarnedEvent>;
}

export declare type Sale = {
    id: string;
    type: SaleType;
    buyer: string;
    seller: string;
    itemId: string | null;
    tokenId: string;
    contractAddress: string;
    price: string;
    timestamp: number;
    txHash: string;
    network: Network.ETHEREUM | Network.MATIC;
    chainId: ChainId;
};

export declare namespace Sale {
    const schema: JSONSchema<Sale>;
    const validate: ValidateFunction<Sale>;
}

export declare type SaleFilters = {
    first?: number;
    skip?: number;
    sortBy?: SaleSortBy;
    type?: SaleType;
    categories?: NFTCategory[];
    buyer?: string;
    seller?: string;
    contractAddress?: string;
    itemId?: string;
    tokenId?: string;
    from?: number;
    to?: number;
    minPrice?: string;
    maxPrice?: string;
    network?: Network;
};

export declare enum SaleSortBy {
    RECENTLY_SOLD = "recently_sold",
    MOST_EXPENSIVE = "most_expensive"
}

export declare enum SaleType {
    ORDER = "order",
    BID = "bid",
    MINT = "mint"
}

export declare namespace SaleType {
    const schema: JSONSchema<SaleType>;
    const validate: ValidateFunction<SaleType>;
}

/** @alpha */
export declare type Scene = DisplayableDeployment & {
    isPortableExperience?: boolean;
    main: string;
    scene: SceneParcels;
    display?: {
        title?: string;
        /** @deprecated use menuBarIcon instead */
        favicon?: string;
        description?: string;
        navmapThumbnail?: string;
    };
    owner?: string;
    creator?: string;
    contact?: {
        name?: string;
        email?: string;
        im?: string;
        url?: string;
    };
    tags?: string[];
    source?: Source;
    spawnPoints?: SpawnPoint[];
    requiredPermissions?: RequiredPermission[];
    featureToggles?: FeatureToggles;
    worldConfiguration?: WorldConfiguration;
    allowedMediaHostnames?: string[];
};

/** @alpha */
export declare namespace Scene {
    const schema: JSONSchema<Scene>;
    const validate: ValidateFunction<Scene>;
}

/** @public */
declare const SCENE_UPDATE = "SCENE_UPDATE";

/** @alpha */
export declare type SceneParcels = {
    base: string;
    parcels: string[];
};

/** @alpha */
export declare namespace SceneParcels {
    const schema: JSONSchema<SceneParcels>;
    const schemaValidator: ValidateFunction<SceneParcels>;
    const validate: ValidateFunction<SceneParcels>;
}

/** @public */
declare type SceneUpdate = {
    type: typeof SCENE_UPDATE;
    payload: {
        sceneId: string;
        sceneType: string;
    };
};

/** @public */
declare namespace SceneUpdate {
    const schema: JSONSchema<SceneUpdate>;
    const validate: ValidateFunction<SceneUpdate>;
}

declare namespace sdk {
    export {
        Actions,
        Messages,
        SCENE_UPDATE,
        SceneUpdate,
        UPDATE,
        Update,
        ProjectType,
        WearableJson
    }
}
export { sdk }

export declare const sendMessage: <T extends PreviewMessageType>(window: {
    postMessage(event: any, targetOrigin: string): any;
}, type: T, payload: PreviewMessagePayload<T>, targetOrigin?: string) => void;

/**
 * SingleMapping
 * @alpha
 */
export declare type SingleMapping = {
    type: MappingType.SINGLE;
    id: string;
};

/**
 * SingleMapping
 * @alpha
 */
export declare namespace SingleMapping {
    const schema: JSONSchema<SingleMapping>;
    const validate: ValidateFunction<Mapping>;
}

declare type SinglePosition = {
    x: number;
    y: number;
    z: number;
};

/**
 * Snapshots
 * @alpha
 */
export declare type Snapshots = {
    face256: IPFSv2;
    body: IPFSv2;
};

/**
 * Snapshots
 * @alpha
 */
export declare namespace Snapshots {
    const schema: JSONSchema<Snapshots>;
    const validate: ValidateFunction<Snapshots>;
}

/**
 * This type describes deployment + AuthChain needed to synchronize
 * a deployed entity across catalysts from the snapshots.
 * @public
 */
export declare type SnapshotSyncDeployment = {
    entityId: IPFSv1 | IPFSv2;
    entityType: string;
    pointers: string[];
    authChain: AuthChain;
    entityTimestamp: number;
};

/**
 * @public
 */
export declare namespace SnapshotSyncDeployment {
    const schema: JSONSchema<SnapshotSyncDeployment>;
    const validate: ValidateFunction<SnapshotSyncDeployment>;
}

declare type SocialEmoteAnimation = {
    title: string;
    loop: boolean;
    audio?: string;
} & {
    [key in ArmatureId]?: EmoteClip;
};

/** @alpha */
export declare type Source = {
    version?: number;
    origin: string;
    projectId: string;
    point?: {
        x: number;
        y: number;
    };
    rotation?: 'north' | 'east' | 'south' | 'west';
    layout?: {
        rows: number;
        cols: number;
    };
    isEmpty?: boolean;
};

/** @alpha */
export declare namespace Source {
    const schema: JSONSchema<Source>;
    const validate: ValidateFunction<Source>;
}

/** @alpha */
export declare type SpawnPoint = {
    name?: string;
    position: SinglePosition | MultiPosition;
    default?: boolean;
    cameraTarget?: SinglePosition;
};

/** @alpha */
export declare namespace SpawnPoint {
    const schema: JSONSchema<SpawnPoint>;
    const validate: ValidateFunction<SpawnPoint>;
}

/** @alpha */
export declare type SpringBoneParams = {
    stiffness: number;
    gravityPower: number;
    gravityDir: [number, number, number];
    drag: number;
    center?: string;
    isRoot?: boolean;
};

/** @alpha */
export declare namespace SpringBoneParams {
    const schema: JSONSchema<SpringBoneParams>;
    const validate: ValidateFunction<SpringBoneParams>;
}

/**
 * Spring bone parameters for a wearable's GLB models.
 *
 * `models` is keyed by GLB content hash (the value found in WearableEntity.content[mainFile]).
 * Hash-keying means a single GLB shared across multiple body-shape representations resolves
 * to one entry, and entries are stable across path renames.
 *
 * - Outer key: GLB content hash.
 * - Inner key: spring bone name as it appears in the GLB.
 *
 * Example:
 * ```
 * {
 *   version: 1,
 *   models: {
 *     "bafkreialsvt77jvpy673cnugp5ggnxfaalfncufweayuk3jbxskh3pelkm": {
 *       "Hair_springBone_L": {
 *         stiffness: 2,
 *         gravityPower: 0.8,
 *         gravityDir: [0, -1, 0],
 *         drag: 0.3,
 *         center: "Avatar_Hips",
 *         isRoot: true
 *       }
 *     }
 *   }
 * }
 * ```
 * @alpha
 */
export declare type SpringBonesData = {
    version: number;
    models: Record<string, Record<string, SpringBoneParams>>;
};

/** @alpha */
export declare namespace SpringBonesData {
    const schema: JSONSchema<SpringBonesData>;
    const validate: ValidateFunction<SpringBonesData>;
}

export declare type StandardProps = {
    collectionAddress: string;
    rarity: Rarity;
};

export declare type StartAnimation = {
    loop: boolean;
    [ArmatureId.Armature]: EmoteClip;
    [ArmatureId.Armature_Prop]?: EmoteClip;
    audio?: string;
};

export declare namespace StartAnimation {
    const schema: JSONSchema<StartAnimation>;
    const validate: ValidateFunction<StartAnimation>;
}

export declare type Store = {
    id: string;
    owner: string;
    description: string;
    links: {
        name: string;
        url: string;
    }[];
    images: {
        name: string;
        file: string;
    }[];
    version: number;
};

export declare namespace Store {
    const schema: JSONSchema<Store>;
    const validate: ValidateFunction<Store>;
}

export declare type StreamingKeyExpiredEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.STREAMING_KEY_EXPIRED;
    metadata: StreamingMetadata;
};

export declare namespace StreamingKeyExpiredEvent {
    const schema: JSONSchema<StreamingKeyExpiredEvent>;
    const validate: ValidateFunction<StreamingKeyExpiredEvent>;
}

export declare type StreamingKeyResetEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.STREAMING_KEY_RESET;
    metadata: StreamingMetadata;
};

export declare namespace StreamingKeyResetEvent {
    const schema: JSONSchema<StreamingKeyResetEvent>;
    const validate: ValidateFunction<StreamingKeyResetEvent>;
}

export declare type StreamingKeyRevokeEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.STREAMING_KEY_REVOKE;
    metadata: StreamingMetadata;
};

export declare namespace StreamingKeyRevokeEvent {
    const schema: JSONSchema<StreamingKeyRevokeEvent>;
    const validate: ValidateFunction<StreamingKeyRevokeEvent>;
}

declare type StreamingMetadata = {
    title: string;
    description: string;
    position: string;
    worldName: string | null;
    isWorld: boolean;
    url: string;
    address: string;
    image: string;
};

export declare type StreamingPlaceUpdatedEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.STREAMING_PLACE_UPDATED;
    metadata: StreamingMetadata;
};

export declare namespace StreamingPlaceUpdatedEvent {
    const schema: JSONSchema<StreamingPlaceUpdatedEvent>;
    const validate: ValidateFunction<StreamingPlaceUpdatedEvent>;
}

export declare type StreamingTimeExceededEvent = BaseEvent & {
    type: Events.Type.STREAMING;
    subType: Events.SubType.Streaming.STREAMING_TIME_EXCEEDED;
    metadata: StreamingMetadata;
};

export declare namespace StreamingTimeExceededEvent {
    const schema: JSONSchema<StreamingTimeExceededEvent>;
    const validate: ValidateFunction<StreamingTimeExceededEvent>;
}

/**
 * Subscription returned by the notifications-workers
 * @alpha
 */
export declare type Subscription = {
    address: EthAddress;
    email: string | undefined;
    details: SubscriptionDetails;
};

/**
 * Subscription schema and validator function
 * @alpha
 */
export declare namespace Subscription {
    const schema: JSONSchema<Subscription>;
    const validate: ValidateFunction<Subscription>;
}

/**
 * Subscription details returned by the notifications-workers
 * @alpha
 */
export declare type SubscriptionDetails = {
    ignore_all_email: boolean;
    ignore_all_in_app: boolean;
    message_type: {
        [notificationType in NotificationType]: NotificationChannelType;
    };
};

/**
 * Subscription details
 * @alpha
 */
export declare namespace SubscriptionDetails {
    const schema: JSONSchema<SubscriptionDetails>;
    const validate: ValidateFunction<SubscriptionDetails>;
}

export declare type SyncDeployment = SnapshotSyncDeployment | PointerChangesSyncDeployment;

export declare type SysLink<T extends 'Entry' | 'Asset' | 'Environment' | 'ContentType' | 'Space'> = {
    sys: {
        type: 'Link';
        linkType: T;
        id: string;
    };
};

export declare type ThirdPartyProps = {
    merkleProof: MerkleProof;
    content: Record<string, string>;
    mappings?: Mappings;
};

export declare type TipReceivedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.TIP_RECEIVED;
    metadata: {
        senderAddress: string;
        receiverAddress: string;
        amount: string;
    };
};

export declare namespace TipReceivedEvent {
    const schema: JSONSchema<TipReceivedEvent>;
    const validate: ValidateFunction<TipReceivedEvent>;
}

export declare type Trade = {
    id: string;
    signature: string;
    signer: string;
    network: Network;
    chainId: ChainId;
    type: TradeType;
    checks: TradeChecks;
    createdAt: number;
    sent: TradeAsset[];
    received: TradeAssetWithBeneficiary[];
    contract: string;
};

export declare type TradeAsset = CollectionItemTradeAsset | ERC20TradeAsset | ERC721TradeAsset | USDPeggedManaTradeAsset;

export declare enum TradeAssetDirection {
    SENT = "sent",
    RECEIVED = "received"
}

export declare enum TradeAssetType {
    ERC20 = 1,
    USD_PEGGED_MANA = 2,
    ERC721 = 3,
    COLLECTION_ITEM = 4
}

export declare type TradeAssetWithBeneficiary = TradeAsset & {
    beneficiary: string;
};

export declare type TradeChecks = {
    uses: number;
    /** Expiration in milliseconds */
    expiration: number;
    /** Effective since date in milliseconds */
    effective: number;
    salt: string;
    contractSignatureIndex: number;
    signerSignatureIndex: number;
    allowedRoot: string;
    allowedProof?: string[];
    externalChecks: TradeExternalCheck[];
};

export declare type TradeCreation = {
    signer: string;
    signature: string;
    network: Network;
    chainId: ChainId;
    type: TradeType;
    checks: TradeChecks;
    sent: TradeAsset[];
    received: TradeAssetWithBeneficiary[];
};

export declare type TradeExternalCheck = {
    contractAddress: string;
    selector: string;
    value: string;
    required: boolean;
};

export declare enum TradeType {
    BID = "bid",
    PUBLIC_NFT_ORDER = "public_nft_order",
    PUBLIC_ITEM_ORDER = "public_item_order"
}

export declare type TransferReceivedEvent = BaseEvent & {
    type: Events.Type.BLOCKCHAIN;
    subType: Events.SubType.Blockchain.TRANSFER_RECEIVED;
    metadata: {
        senderAddress: string;
        receiverAddress: string;
        tokenUri?: string;
    };
};

export declare namespace TransferReceivedEvent {
    const schema: JSONSchema<TransferReceivedEvent>;
    const validate: ValidateFunction<TransferReceivedEvent>;
}

/** @public @deprecated */
declare const UPDATE = "update";

/** @public @deprecated */
declare type Update = {
    type: typeof UPDATE;
};

/** @public @deprecated */
declare namespace Update {
    const schema: JSONSchema<Update>;
    const validate: ValidateFunction<Update>;
}

/**
 * Configuration for URL validation
 * @public
 */
export declare interface UrlValidationConfig {
    /** Whether to allow localhost and private IPs (useful for development) */
    allowLocalhost?: boolean;
    /** Additional ports to allow beyond the default 80, 443 */
    allowedPorts?: string[];
}

export declare type USDPeggedManaTradeAsset = BaseTradeAsset & {
    assetType: TradeAssetType.USD_PEGGED_MANA;
    amount: string;
};

export declare type UsedEmoteEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.USED_EMOTE;
    metadata: ClientBaseMetadata & {
        emote: {
            emoteIndex: number;
            isBase: boolean;
            itemId: string;
            source: string;
        };
    };
};

export declare type UserBanCreatedEvent = BaseEvent & {
    type: Events.Type.MODERATION;
    subType: Events.SubType.Moderation.USER_BAN_CREATED;
    metadata: {
        id: string;
        bannedAddress: string;
        bannedBy: string;
        reason: string;
        /** Unix timestamp (ms) when the ban was created. */
        bannedAt: number;
        /** Unix timestamp (ms) when the ban expires. null means permanent ban. */
        expiresAt: number | null;
        customMessage?: string;
    };
};

export declare namespace UserBanCreatedEvent {
    const schema: JSONSchema<UserBanCreatedEvent>;
    const validate: ValidateFunction<UserBanCreatedEvent>;
}

export declare type UserBanLiftedEvent = BaseEvent & {
    type: Events.Type.MODERATION;
    subType: Events.SubType.Moderation.USER_BAN_LIFTED;
    metadata: {
        id: string;
        bannedAddress: string;
        liftedBy: string;
        /** Unix timestamp (ms) when the ban was lifted. */
        liftedAt: number;
    };
};

export declare namespace UserBanLiftedEvent {
    const schema: JSONSchema<UserBanLiftedEvent>;
    const validate: ValidateFunction<UserBanLiftedEvent>;
}

export declare type UserBannedFromSceneEvent = BaseEvent & {
    type: Events.Type.COMMS;
    subType: Events.SubType.Comms.USER_BANNED_FROM_SCENE;
    metadata: {
        placeTitle: string;
        userAddress: string;
    };
};

export declare namespace UserBannedFromSceneEvent {
    const schema: JSONSchema<UserBannedFromSceneEvent>;
    const validate: ValidateFunction<UserBannedFromSceneEvent>;
}

export declare type UserJoinedRoomEvent = BaseEvent & {
    type: Events.Type.COMMS;
    subType: Events.SubType.Comms.USER_JOINED_ROOM;
    metadata: {
        parcel: string;
        sceneId: string;
        userAddress: string;
        realmName: string;
        islandName?: string;
        communityId?: string;
        voiceChatId?: string;
        isWorld: boolean;
        roomType: RoomType;
    };
};

export declare namespace UserJoinedRoomEvent {
    const schema: JSONSchema<UserJoinedRoomEvent>;
    const validate: ValidateFunction<UserJoinedRoomEvent>;
}

export declare type UserLeftRoomEvent = BaseEvent & {
    type: Events.Type.COMMS;
    subType: Events.SubType.Comms.USER_LEFT_ROOM;
    metadata: {
        sceneId?: string;
        isWorld: boolean;
        userAddress: string;
        realmName: string;
        roomType: RoomType;
        islandName?: string;
        communityId?: string;
        voiceChatId?: string;
    };
};

export declare namespace UserLeftRoomEvent {
    const schema: JSONSchema<UserLeftRoomEvent>;
    const validate: ValidateFunction<UserLeftRoomEvent>;
}

export declare type UserUnbannedFromSceneEvent = BaseEvent & {
    type: Events.Type.COMMS;
    subType: Events.SubType.Comms.USER_UNBANNED_FROM_SCENE;
    metadata: {
        placeTitle: string;
        userAddress: string;
    };
};

export declare namespace UserUnbannedFromSceneEvent {
    const schema: JSONSchema<UserUnbannedFromSceneEvent>;
    const validate: ValidateFunction<UserUnbannedFromSceneEvent>;
}

export declare type UserWarningCreatedEvent = BaseEvent & {
    type: Events.Type.MODERATION;
    subType: Events.SubType.Moderation.USER_WARNING_CREATED;
    metadata: {
        id: string;
        warnedAddress: string;
        warnedBy: string;
        reason: string;
        /** Unix timestamp (ms) when the warning was created. */
        warnedAt: number;
    };
};

export declare namespace UserWarningCreatedEvent {
    const schema: JSONSchema<UserWarningCreatedEvent>;
    const validate: ValidateFunction<UserWarningCreatedEvent>;
}

/**
 * This type is a subset of AJV's ValidateFunction, it exists to make
 * .d.ts bundles smaller and to not expose all of AJV context to the
 * world.
 * @public
 */
export declare interface ValidateFunction<T = unknown> {
    (this: any, data: any, dataCxt?: any): data is T;
    errors?: null | ErrorObject[];
}

/**
 * Validates a type with a schema in a functional way.
 * @public
 */
export declare function validateType<T>(theType: Pick<AbstractTypedSchema<T>, 'validate'>, value: T): boolean;

/**
 * Validates if a URL string is safe
 * @param url - The URL string to validate
 * @param config - Validation configuration
 * @returns true if the URL is safe, false if it contains malicious content
 * @public
 */
export declare function validateUrl(url: string, config?: UrlValidationConfig): boolean;

/**
 * Validates if a URL instance is safe
 * @param url - The URL instance to validate
 * @param config - Validation configuration
 * @returns true if the URL is safe, false otherwise
 * @public
 */
export declare function validateUrlInstance(url: URL, config?: UrlValidationConfig): boolean;

/**
 * World Range
 * @alpha
 */
export declare type ValidWorldRange = {
    xMin: number;
    yMin: number;
    xMax: number;
    yMax: number;
};

export declare type VerticalHeightReachedEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.VERTICAL_HEIGHT_REACHED;
    metadata: ClientBaseMetadata & {
        height: number;
    };
};

export declare type WalkedDistanceEvent = BaseEvent & {
    type: Events.Type.CLIENT;
    subType: Events.SubType.Client.WALKED_DISTANCE;
    metadata: ClientBaseMetadata & {
        distance: number;
        stepCount: number;
    };
};

/** @alpha */
export declare type Wearable = BaseItem & {
    data: {
        replaces: HideableWearableCategory[];
        hides: HideableWearableCategory[];
        tags: string[];
        representations: WearableRepresentation[];
        category: WearableCategory;
        removesDefaultHiding?: HideableWearableCategory[];
        blockVrmExport?: boolean;
        outlineCompatible?: boolean;
        springBones?: SpringBonesData | null;
    };
} & (StandardProps | ThirdPartyProps);

/** @alpha */
export declare namespace Wearable {
    const schema: JSONSchema<Wearable>;
    /**
     * Validates that the wearable metadata complies with the standard or third party wearable, and doesn't have repeated locales.
     * Some fields are defined as optional but those are validated to be present as standard XOR third party:
     *  Standard Wearables should contain:
     *    - collectionAddress
     *    - rarity
     *  Third Party Wearables should contain:
     *    - merkleProof
     *    - content
     */
    const validate: ValidateFunction<Wearable>;
}

export declare enum WearableCategory {
    EYEBROWS = "eyebrows",
    EYES = "eyes",
    FACIAL_HAIR = "facial_hair",
    HAIR = "hair",
    BODY_SHAPE = "body_shape",
    MOUTH = "mouth",
    UPPER_BODY = "upper_body",
    LOWER_BODY = "lower_body",
    FEET = "feet",
    EARRING = "earring",
    EYEWEAR = "eyewear",
    HAT = "hat",
    HELMET = "helmet",
    MASK = "mask",
    TIARA = "tiara",
    TOP_HEAD = "top_head",
    SKIN = "skin",
    HANDS_WEAR = "hands_wear"
}

export declare namespace WearableCategory {
    const schema: JSONSchema<WearableCategory>;
    const validate: ValidateFunction<WearableCategory>;
}

/** @alpha */
export declare type WearableDefinition = Omit<Wearable, 'data'> & {
    data: Omit<Wearable['data'], 'representations'> & {
        representations: WearableRepresentationDefinition[];
    };
};

export declare enum WearableGender {
    MALE = "male",
    FEMALE = "female"
}

export declare namespace WearableGender {
    const schema: JSONSchema<WearableGender>;
    const validate: ValidateFunction<WearableGender>;
}

/**
 * @alpha
 */
export declare type WearableId = string;

/**
 * @alpha
 */
declare type WearableJson = Pick<Wearable, 'data' | 'name' | 'description'> & {
    rarity: Rarity;
};

/**
 * @alpha
 */
declare namespace WearableJson {
    const schema: JSONSchema<WearableJson>;
    const validate: ValidateFunction<WearableJson>;
}

/** @alpha */
export declare type WearableRepresentation = {
    bodyShapes: BodyShape[];
    mainFile: string;
    contents: string[];
    overrideHides: HideableWearableCategory[];
    overrideReplaces: HideableWearableCategory[];
};

/** @alpha */
export declare namespace WearableRepresentation {
    const schema: JSONSchema<WearableRepresentation>;
    const validate: ValidateFunction<WearableRepresentation>;
}

/** @alpha */
export declare type WearableRepresentationDefinition = Omit<WearableRepresentation, 'contents'> & {
    contents: {
        key: string;
        url: string;
    }[];
};

/** @alpha */
export declare type WearableRepresentationWithBlobs = Omit<WearableRepresentationDefinition, 'contents'> & {
    contents: {
        key: string;
        blob: any;
    }[];
};

/** @alpha */
export declare type WearableWithBlobs = Omit<WearableDefinition, 'data'> & {
    data: Omit<WearableDefinition['data'], 'representations'> & {
        representations: WearableRepresentationWithBlobs[];
    };
};

export declare type WebBaseMetadata = {
    userAgent: string;
    ip: string;
    pagePath: string;
    pageUrl: string;
    locale: string;
    anonymousId: string;
    userId?: EthAddress | null;
    timestamps: {
        /**
         * Timestamp when the event was reported by the client
         *
         * @type {number}
         */
        reportedAt: number;
        /**
         * Timestamp when the event was received by the tracking system (e.g. Segment)
         *
         * @type {number}
         */
        receivedAt: number;
    };
};

/**
 * World
 * @alpha
 */
export declare type World = {
    validWorldRanges: Array<ValidWorldRange>;
};

/**
 * @alpha
 */
export declare namespace World {
    const schema: JSONSchema<World>;
    const validate: ValidateFunction<World>;
}

/** @alpha */
export declare type WorldConfiguration = {
    name?: string;
    /** @public @deprecated Use `skyboxConfig.fixedTime` instead */
    skybox?: number;
    /** @public @deprecated Use `miniMapConfig.visible` instead */
    minimapVisible?: boolean;
    miniMapConfig?: {
        visible?: boolean;
        dataImage?: string;
        estateImage?: string;
    };
    skyboxConfig?: {
        fixedTime?: number;
        textures?: string[];
    };
    fixedAdapter?: string;
    placesConfig?: {
        optOut?: boolean;
    };
};

/** @alpha */
export declare namespace WorldConfiguration {
    const schema: JSONSchema<WorldConfiguration>;
    const validate: ValidateFunction<WorldConfiguration>;
}

export declare type WorldDeploymentEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.DEPLOYMENT;
    entity: {
        entityId: string;
        authChain: AuthChain;
    };
    contentServerUrls?: string[];
    force?: boolean;
    animation?: string;
    lods?: string[];
};

export declare namespace WorldDeploymentEvent {
    const schema: JSONSchema<WorldDeploymentEvent>;
    const validate: ValidateFunction<WorldDeploymentEvent>;
}

export declare type WorldsAccessRestoredEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLDS_ACCESS_RESTORED;
    metadata: {
        title: string;
        description: string;
        url: string;
        attendee: string;
    };
};

export declare namespace WorldsAccessRestoredEvent {
    const schema: JSONSchema<WorldsAccessRestoredEvent>;
    const validate: ValidateFunction<WorldsAccessRestoredEvent>;
}

export declare type WorldsAccessRestrictedEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLDS_ACCESS_RESTRICTED;
    metadata: {
        title: string;
        description: string;
        when: number;
        address: string;
    };
};

export declare namespace WorldsAccessRestrictedEvent {
    const schema: JSONSchema<WorldsAccessRestrictedEvent>;
    const validate: ValidateFunction<WorldsAccessRestrictedEvent>;
}

export declare type WorldScenesUndeploymentEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLD_SCENES_UNDEPLOYMENT;
    metadata: {
        worldName: string;
        scenes: Array<{
            entityId: string;
            baseParcel: string;
        }>;
    };
};

export declare namespace WorldScenesUndeploymentEvent {
    const schema: JSONSchema<WorldScenesUndeploymentEvent>;
    const validate: ValidateFunction<WorldScenesUndeploymentEvent>;
}

export declare type WorldSettingsChangedEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLD_SETTINGS_CHANGED;
    metadata: {
        worldName: string;
        title?: string;
        description?: string;
        contentRating?: string;
        skyboxTime?: number | null;
        categories?: string[];
        singlePlayer?: boolean;
        showInPlaces?: boolean;
        thumbnailUrl?: string;
        accessType?: string;
    };
};

export declare namespace WorldSettingsChangedEvent {
    const schema: JSONSchema<WorldSettingsChangedEvent>;
}

export declare type WorldsMissingResourcesEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLDS_MISSING_RESOURCES;
    metadata: {
        title: string;
        description: string;
        url: string;
        when: number;
        address: string;
    };
};

export declare namespace WorldsMissingResourcesEvent {
    const schema: JSONSchema<WorldsMissingResourcesEvent>;
    const validate: ValidateFunction<WorldsMissingResourcesEvent>;
}

export declare type WorldSpawnCoordinateSetEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLD_SPAWN_COORDINATE_SET;
    metadata: {
        name: string;
        oldCoordinate: {
            x: number;
            y: number;
        } | null;
        newCoordinate: {
            x: number;
            y: number;
        };
    };
};

export declare namespace WorldSpawnCoordinateSetEvent {
    const schema: JSONSchema<WorldSpawnCoordinateSetEvent>;
    const validate: ValidateFunction<WorldSpawnCoordinateSetEvent>;
}

export declare type WorldsPermissionGrantedEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLDS_PERMISSION_GRANTED;
    metadata: {
        title: string;
        description: string;
        world: string;
        permissions: string[];
        url: string;
        address: string;
    };
};

export declare namespace WorldsPermissionGrantedEvent {
    const schema: JSONSchema<WorldsPermissionGrantedEvent>;
    const validate: ValidateFunction<WorldsPermissionGrantedEvent>;
}

export declare type WorldsPermissionRevokedEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLDS_PERMISSION_REVOKED;
    metadata: {
        title: string;
        description: string;
        world: string;
        permissions: string[];
        url: string;
        address: string;
    };
};

export declare namespace WorldsPermissionRevokedEvent {
    const schema: JSONSchema<WorldsPermissionRevokedEvent>;
    const validate: ValidateFunction<WorldsPermissionRevokedEvent>;
}

export declare type WorldUndeploymentEvent = BaseEvent & {
    type: Events.Type.WORLD;
    subType: Events.SubType.Worlds.WORLD_UNDEPLOYMENT;
    metadata: {
        worldName: string;
    };
};

export declare namespace WorldUndeploymentEvent {
    const schema: JSONSchema<WorldUndeploymentEvent>;
    const validate: ValidateFunction<WorldUndeploymentEvent>;
}

export { }