dcl-catalyst-client 22.0.0 → 22.0.1-38601546385.commit-cee8815

package/dist/client/specs/lambdas-client.d.ts

@@ -1,31 +1,94 @@
-export type GetParcelOperators400 = {
-    error?: string;
+export type ValidateSignature400 = SchemaValidationError | LambdasError;
+export type GetNftsCollections200CollectionsItem = {
+    id: string;
+    name: string;
 };
-export type ValidateSignature200 = {
-    [key: string]: any;
+export type GetNftsCollections200 = {
+    collections: GetNftsCollections200CollectionsItem[];
 };
-export type ValidateSignatureBody = {
-    [key: string]: any;
+export type GetEmotesByOwner200Item = {
+    /** Number of tokens of this item owned by the address */
+    amount: number;
+    /** Present only when `includeDefinitions` is set */
+    definition?: EmoteDefinition;
+    urn: string;
+};
+export type GetEmotesByOwnerIncludeDefinitions = (typeof GetEmotesByOwnerIncludeDefinitions)[keyof typeof GetEmotesByOwnerIncludeDefinitions];
+export declare const GetEmotesByOwnerIncludeDefinitions: {
+    readonly true: "true";
+};
+export type GetEmotesByOwnerParams = {
+    /**
+     * Third party collection URN. Only the third party part of the URN (the first five segments) is used.
+     */
+    collectionId?: string;
+    /**
+     * Presence flag: when present with any value (even `false`), each element is extended with its emote definition. Omit it to disable.
+     */
+    includeDefinitions?: GetEmotesByOwnerIncludeDefinitions;
+};
+export type GetWearablesByOwner200Item = {
+    /** Number of tokens of this item owned by the address */
+    amount: number;
+    /** Present only when `includeDefinitions` is set */
+    definition?: WearableDefinition;
+    urn: string;
+};
+export type GetWearablesByOwnerIncludeDefinitions = (typeof GetWearablesByOwnerIncludeDefinitions)[keyof typeof GetWearablesByOwnerIncludeDefinitions];
+export declare const GetWearablesByOwnerIncludeDefinitions: {
+    readonly true: "true";
+};
+export type GetWearablesByOwnerParams = {
+    /**
+     * Third party collection URN. Only the third party part of the URN (the first five segments) is used.
+     */
+    collectionId?: string;
+    /**
+     * Presence flag: when present with any value (even `false`), each element is extended with its wearable definition. Omit it to disable.
+     */
+    includeDefinitions?: GetWearablesByOwnerIncludeDefinitions;
+};
+export type SearchEmotesParams = {
+    /**
+     * Collection URN to search in. Can be repeated up to 500 times.
+     */
+    collectionId?: string[];
+    /**
+     * Emote URN to retrieve. Can be repeated up to 500 times.
+     */
+    emoteId?: string[];
+    /**
+     * Text to search for in the emotes. Case-insensitive, at least 3 characters.
+     */
+    textSearch?: string;
+    /**
+     * Maximum number of emotes to return. Values that are not a number between 1 and 500 fall back to 500.
+     */
+    limit?: number;
+    /**
+     * URN of the last emote of the previous page. Only emotes with a greater URN are returned.
+     */
+    lastId?: string;
 };
 export type SearchWearablesParams = {
     /**
-     * Lis of URNs that identify the collection. Maximum amount of ids allowed is 500.
+     * Collection URN to search in. Can be repeated up to 500 times.
      */
     collectionId?: string[];
     /**
-     * List of wearables URNs to search. Maximum amount of ids allowed is 500.
+     * Wearable URN to retrieve. Can be repeated up to 500 times.
      */
     wearableId?: string[];
     /**
-     * Search text
+     * Text to search for in the wearables. Case-insensitive, at least 3 characters.
      */
     textSearch?: string;
     /**
-     * Limit the quantity of results that will be returned by the request. You can only request up to 500 results.
+     * Maximum number of wearables to return. Values that are not a number between 1 and 500 fall back to 500.
      */
     limit?: number;
     /**
-     * The result will always be ordered by the local timestamp fields but in case of timestamp collisions, you can use the lastId field to filter the result
+     * URN of the last wearable of the previous page. Only wearables with a greater URN are returned.
      */
     lastId?: string;
 };
@@ -35,15 +98,23 @@ export type GetThirdPartyCollection200 = {
     pageSize: number;
     totalAmount: number;
 };
+export type GetThirdPartyCollectionIncludeDefinitions = (typeof GetThirdPartyCollectionIncludeDefinitions)[keyof typeof GetThirdPartyCollectionIncludeDefinitions];
+export declare const GetThirdPartyCollectionIncludeDefinitions: {
+    readonly true: "true";
+};
 export type GetThirdPartyCollectionParams = {
+    /**
+     * Presence flag: when present with any value (even `false`), each element is extended with its wearable definition. Omit it to disable.
+     */
+    includeDefinitions?: GetThirdPartyCollectionIncludeDefinitions;
     /**
      * The number of the requested page.
      */
-    pageNum?: string;
+    pageNum?: number;
     /**
      * The size of the requested page.
      */
-    pageSize?: string;
+    pageSize?: number;
 };
 export type GetThirdPartyWearables200 = {
     elements: ThirdPartyWearable[];
@@ -51,38 +122,78 @@ export type GetThirdPartyWearables200 = {
     pageSize: number;
     totalAmount: number;
 };
+export type GetThirdPartyWearablesDirection = (typeof GetThirdPartyWearablesDirection)[keyof typeof GetThirdPartyWearablesDirection];
+export declare const GetThirdPartyWearablesDirection: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+export type GetThirdPartyWearablesOrderBy = (typeof GetThirdPartyWearablesOrderBy)[keyof typeof GetThirdPartyWearablesOrderBy];
+export declare const GetThirdPartyWearablesOrderBy: {
+    readonly name: "name";
+};
+export type GetThirdPartyWearablesIncludeDefinitions = (typeof GetThirdPartyWearablesIncludeDefinitions)[keyof typeof GetThirdPartyWearablesIncludeDefinitions];
+export declare const GetThirdPartyWearablesIncludeDefinitions: {
+    readonly true: "true";
+};
 export type GetThirdPartyWearablesParams = {
+    /**
+     * Presence flag: when present with any value (even `false`), each element is extended with its wearable definition. Omit it to disable.
+     */
+    includeDefinitions?: GetThirdPartyWearablesIncludeDefinitions;
+    /**
+     * Only return wearables of these categories. Can be repeated.
+     */
+    category?: string[];
+    /**
+     * Only return wearables whose name contains this text. Case-insensitive.
+     */
+    name?: string;
+    /**
+     * Field to sort by.
+     */
+    orderBy?: GetThirdPartyWearablesOrderBy;
+    /**
+     * Sort direction.
+     */
+    direction?: GetThirdPartyWearablesDirection;
     /**
      * The number of the requested page.
      */
-    pageNum?: string;
+    pageNum?: number;
     /**
      * The size of the requested page.
      */
-    pageSize?: string;
+    pageSize?: number;
 };
-export type GetParcelPermissions400 = {
-    error?: string;
+export type GetLandsPermissionsParams = {
+    /**
+     * The number of the requested page.
+     */
+    pageNum?: number;
+    /**
+     * The size of the requested page.
+     */
+    pageSize?: number;
 };
 export type GetLandsParams = {
     /**
-     * The number of the requested page. It needs `pageSize` to be present to enable a paginated response.
+     * The number of the requested page.
      */
-    pageNum?: string;
+    pageNum?: number;
     /**
-     * The size of the requested page. It needs `pageNum` to be present to enable a paginated response.
+     * The size of the requested page.
      */
-    pageSize?: string;
+    pageSize?: number;
 };
 export type GetNamesParams = {
     /**
-     * The number of the requested page. It needs `pageSize` to be present to enable a paginated response.
+     * The number of the requested page.
      */
-    pageNum?: string;
+    pageNum?: number;
     /**
-     * The size of the requested page. It needs `pageNum` to be present to enable a paginated response.
+     * The size of the requested page.
      */
-    pageSize?: string;
+    pageSize?: number;
 };
 export type GetEmotes200 = {
     elements: Emote[];
@@ -90,23 +201,62 @@ export type GetEmotes200 = {
     pageSize: number;
     totalAmount: number;
 };
+export type GetEmotesDirection = (typeof GetEmotesDirection)[keyof typeof GetEmotesDirection];
+export declare const GetEmotesDirection: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+export type GetEmotesOrderBy = (typeof GetEmotesOrderBy)[keyof typeof GetEmotesOrderBy];
+export declare const GetEmotesOrderBy: {
+    readonly rarity: "rarity";
+    readonly name: "name";
+    readonly date: "date";
+};
+export type GetEmotesIncludeDefinitions = (typeof GetEmotesIncludeDefinitions)[keyof typeof GetEmotesIncludeDefinitions];
+export declare const GetEmotesIncludeDefinitions: {
+    readonly true: "true";
+};
+export type GetEmotesIncludeEntities = (typeof GetEmotesIncludeEntities)[keyof typeof GetEmotesIncludeEntities];
+export declare const GetEmotesIncludeEntities: {
+    readonly true: "true";
+};
 export type GetEmotesParams = {
     /**
-     * Third Party collection Id to filter emotes, if this param is not sent then the 3rd parties emotes are not shown. If it is sent, only the 3rd parties emotes are shown.
+     * Presence flag: when present with any value (even `false`), each element is extended with its content server entity. Omit it to disable. Cannot be combined with `includeDefinitions`.
      */
-    collectionId?: string;
+    includeEntities?: GetEmotesIncludeEntities;
+    /**
+     * Presence flag: when present with any value (even `false`), each element is extended with its emote definition. Omit it to disable. Cannot be combined with `includeEntities`.
+     */
+    includeDefinitions?: GetEmotesIncludeDefinitions;
+    /**
+     * Only return emotes of this category. Case-insensitive.
+     */
+    category?: string;
+    /**
+     * Only return emotes of this rarity. Case-insensitive.
+     */
+    rarity?: string;
+    /**
+     * Only return emotes whose name contains this text. Case-insensitive.
+     */
+    name?: string;
+    /**
+     * Field to sort by. `date` is the transfer date of the tokens.
+     */
+    orderBy?: GetEmotesOrderBy;
     /**
-     * If present, response will be extended with the entity data.
+     * Sort direction. Defaults to `ASC` when sorting by `name` and to `DESC` otherwise.
      */
-    includeEntities?: boolean;
+    direction?: GetEmotesDirection;
     /**
      * The number of the requested page.
      */
-    pageNum?: string;
+    pageNum?: number;
     /**
-     * The size of the requested page
+     * The size of the requested page.
      */
-    pageSize?: string;
+    pageSize?: number;
 };
 export type GetWearables200 = {
     elements: Wearable[];
@@ -114,79 +264,257 @@ export type GetWearables200 = {
     pageSize: number;
     totalAmount: number;
 };
+export type GetWearablesDirection = (typeof GetWearablesDirection)[keyof typeof GetWearablesDirection];
+export declare const GetWearablesDirection: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+export type GetWearablesOrderBy = (typeof GetWearablesOrderBy)[keyof typeof GetWearablesOrderBy];
+export declare const GetWearablesOrderBy: {
+    readonly rarity: "rarity";
+    readonly name: "name";
+    readonly date: "date";
+};
+export type GetWearablesIncludeDefinitions = (typeof GetWearablesIncludeDefinitions)[keyof typeof GetWearablesIncludeDefinitions];
+export declare const GetWearablesIncludeDefinitions: {
+    readonly true: "true";
+};
+export type GetWearablesIncludeEntities = (typeof GetWearablesIncludeEntities)[keyof typeof GetWearablesIncludeEntities];
+export declare const GetWearablesIncludeEntities: {
+    readonly true: "true";
+};
 export type GetWearablesParams = {
     /**
-     * If present, response will be extended with the entity data.
+     * Presence flag: when present with any value (even `false`), each element is extended with its content server entity. Omit it to disable. Cannot be combined with `includeDefinitions`.
      */
-    includeEntities?: boolean;
+    includeEntities?: GetWearablesIncludeEntities;
     /**
-     * If present, response will include the third-party wearables owned by the address. They will appear before other wearables if the response is paginated.
+     * Presence flag: when present with any value (even `false`), each element is extended with its wearable definition. Omit it to disable. Cannot be combined with `includeEntities`.
      */
-    includeThirdParty?: boolean;
+    includeDefinitions?: GetWearablesIncludeDefinitions;
     /**
-     * The number of the requested page.
+     * Only return wearables of this category. Case-insensitive.
      */
-    pageNum?: string;
+    category?: string;
     /**
-     * The size of the requested page.
+     * Only return wearables of this rarity. Case-insensitive.
+     */
+    rarity?: string;
+    /**
+     * Only return wearables whose name contains this text. Case-insensitive.
+     */
+    name?: string;
+    /**
+     * Field to sort by. `date` is the transfer date of the tokens.
+     */
+    orderBy?: GetWearablesOrderBy;
+    /**
+     * Sort direction. Defaults to `ASC` when sorting by `name` and to `DESC` otherwise.
      */
-    pageSize?: string;
+    direction?: GetWearablesDirection;
     /**
-     * Determines the field to be sort by. By default it will be by `transferredAt`. Possible values: `transferredAt` and `rarity`.
+     * The number of the requested page.
+     */
+    pageNum?: number;
+    /**
+     * The size of the requested page.
      */
-    orderBy?: string;
+    pageSize?: number;
 };
 export type GetCollections200CollectionsItem = {
     id: string;
     name: string;
 };
 export type GetCollections200 = {
-    collections?: GetCollections200CollectionsItem[];
-};
-export type PeersPeersItem = {
-    address?: string;
-    id?: string;
-    lastPing?: number;
-    parcel?: number[];
-    position?: number[];
-};
-export interface Peers {
-    ok?: boolean;
-    peers?: PeersPeersItem[];
-}
-export type IslandIdPeersItem = {
-    address?: string;
-    id?: string;
-    lastPing?: number;
-    parcel?: number[];
-    position?: number[];
-    preferedIslandId?: string;
-};
-export interface IslandId {
-    center?: number[];
-    id?: string;
-    maxPeers?: number;
-    peers?: IslandIdPeersItem[];
-    radius?: number;
-}
-export type IslandsIslandsItemPeersItem = {
-    address?: string;
-    id?: string;
-    lastPing?: number;
-    parcel?: number[];
-    position?: number[];
-    preferedIslandId?: string;
-};
-export type IslandsIslandsItem = {
-    center?: number[];
-    id?: string;
-    maxPeers?: number;
-    peers?: IslandsIslandsItemPeersItem[];
-    radius?: number;
-};
-export interface Islands {
-    islands?: IslandsIslandsItem[];
-    ok?: boolean;
+    collections: GetCollections200CollectionsItem[];
+};
+/**
+ * When `true` together with `trimmed`, adds the number of owned copies as `amount` to each trimmed element. Ignored without `trimmed`.
+ */
+export type IncludeAmountParameter = boolean;
+/**
+ * When `true`, each element is returned in its trimmed form: a reduced entity with only the fields needed to render the backpack. Otherwise the full form is returned.
+ */
+export type TrimmedParameter = boolean;
+/**
+ * Number of elements per page. Values above 1000 are rejected with a 400.
+ */
+export type PageSizeParameter = number;
+/**
+ * Number of the requested page, starting at 1.
+ */
+export type PageNumParameter = number;
+export type DirectionParameter = (typeof DirectionParameter)[keyof typeof DirectionParameter];
+export declare const DirectionParameter: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+export type OrderByParameter = (typeof OrderByParameter)[keyof typeof OrderByParameter];
+export declare const OrderByParameter: {
+    readonly rarity: "rarity";
+    readonly name: "name";
+    readonly date: "date";
+};
+export type RarityParameter = (typeof RarityParameter)[keyof typeof RarityParameter];
+export declare const RarityParameter: {
+    readonly common: "common";
+    readonly uncommon: "uncommon";
+    readonly rare: "rare";
+    readonly epic: "epic";
+    readonly legendary: "legendary";
+    readonly exotic: "exotic";
+    readonly mythic: "mythic";
+    readonly unique: "unique";
+};
+/**
+ * Only return elements whose name contains this text (case-insensitive).
+ */
+export type NameParameter = string;
+/**
+ * Only return elements of the given category (case-insensitive). Repeat the parameter to match any of several categories.
+ */
+export type CategoryParameter = string[];
+export type EmotesExplorerElementsItem = ExplorerEmote | ExplorerEmoteTrimmed;
+export interface EmotesExplorer {
+    /** Full elements by default, trimmed elements when `trimmed` is set. */
+    elements: EmotesExplorerElementsItem[];
+    pageNum: number;
+    pageSize: number;
+    /** Number of elements matching the filters across all pages. */
+    totalAmount: number;
+}
+export type ExplorerEmoteTrimmedEntityMetadataData = {
+    /** Absent for emotes without ADR-74 emote data. */
+    category?: string;
+    representations: ExplorerTrimmedRepresentation[];
+};
+export type ExplorerEmoteTrimmedEntityMetadata = {
+    data: ExplorerEmoteTrimmedEntityMetadataData;
+    /** Item URN. */
+    id: string;
+    name: string;
+    rarity?: string;
+};
+export type ExplorerEmoteTrimmedEntity = {
+    /** Entity id. */
+    id: string;
+    individualData: ExplorerIndividualData[];
+    metadata: ExplorerEmoteTrimmedEntityMetadata;
+    /** Content hash of the thumbnail file. */
+    thumbnail?: string;
+};
+/**
+ * Trimmed form of an owned emote, returned when `trimmed` is set.
+ */
+export interface ExplorerEmoteTrimmed {
+    /** Number of owned copies. Only present when `includeAmount` is set. */
+    amount?: number;
+    entity: ExplorerEmoteTrimmedEntity;
+}
+export type ExplorerEmoteType = (typeof ExplorerEmoteType)[keyof typeof ExplorerEmoteType];
+export declare const ExplorerEmoteType: {
+    readonly 'on-chain': "on-chain";
+};
+/**
+ * An emote owned by the address, grouped by URN.
+ */
+export interface ExplorerEmote {
+    /** Number of owned copies. */
+    amount: number;
+    category: string;
+    entity: Entity;
+    individualData: ExplorerIndividualData[];
+    /** Present when the item source reports it. */
+    itemType?: string;
+    name: string;
+    rarity: string;
+    type: ExplorerEmoteType;
+    urn: string;
+}
+export interface WearablesExplorer {
+    /** Full elements by default, trimmed elements when `trimmed` is set. */
+    elements: WearablesExplorerElementsItem[];
+    pageNum: number;
+    pageSize: number;
+    /** Number of elements matching the filters across all pages. */
+    totalAmount: number;
+}
+export type ExplorerWearableTrimmedEntity = {
+    /** Entity id. */
+    id: string;
+    individualData: ExplorerIndividualData[];
+    metadata: ExplorerWearableTrimmedEntityMetadata;
+    /** Content hash of the thumbnail file. */
+    thumbnail?: string;
+};
+/**
+ * Trimmed form of an owned wearable, returned when `trimmed` is set.
+ */
+export interface ExplorerWearableTrimmed {
+    /** Number of owned copies. Only present when `includeAmount` is set. */
+    amount?: number;
+    entity: ExplorerWearableTrimmedEntity;
+}
+export type WearablesExplorerElementsItem = ExplorerWearable | ExplorerWearableTrimmed;
+export interface ExplorerTrimmedRepresentation {
+    bodyShapes: string[];
+}
+export type ExplorerWearableTrimmedEntityMetadataData = {
+    category: string;
+    representations: ExplorerTrimmedRepresentation[];
+};
+export type ExplorerWearableTrimmedEntityMetadata = {
+    data: ExplorerWearableTrimmedEntityMetadataData;
+    /** Item URN. */
+    id: string;
+    isSmart: boolean;
+    name: string;
+    /** Absent when the entity metadata has no rarity, as with base wearables. */
+    rarity?: string;
+};
+export type ExplorerWearableType = (typeof ExplorerWearableType)[keyof typeof ExplorerWearableType];
+export declare const ExplorerWearableType: {
+    readonly 'base-wearable': "base-wearable";
+    readonly 'on-chain': "on-chain";
+    readonly 'third-party': "third-party";
+};
+/**
+ * Only present for on-chain wearables.
+ */
+export type ExplorerWearableItemType = (typeof ExplorerWearableItemType)[keyof typeof ExplorerWearableItemType];
+export declare const ExplorerWearableItemType: {
+    readonly wearable_v1: "wearable_v1";
+    readonly wearable_v2: "wearable_v2";
+    readonly smart_wearable_v1: "smart_wearable_v1";
+};
+/**
+ * One owned copy of the item. Base wearables only carry `id`; third-party wearables may add `tokenId`; on-chain items carry all fields.
+ */
+export interface ExplorerIndividualData {
+    /** Identifier of the owned copy (the item URN followed by the token id for on-chain items). */
+    id: string;
+    /** Price paid, in wei, as a string. */
+    price?: string;
+    tokenId?: string;
+    /** Unix timestamp, in seconds, of the transfer to the current owner, as a string. */
+    transferredAt?: string;
+}
+/**
+ * A wearable owned by the address, grouped by URN.
+ */
+export interface ExplorerWearable {
+    /** Number of owned copies. */
+    amount: number;
+    category: string;
+    entity: Entity;
+    individualData: ExplorerIndividualData[];
+    /** Only present for on-chain wearables. */
+    itemType?: ExplorerWearableItemType;
+    name: string;
+    /** Only present for on-chain wearables. */
+    rarity?: string;
+    type: ExplorerWearableType;
+    urn: string;
 }
 export type ThirdPartyIntegrationsDataItem = {
     description?: string;
@@ -201,15 +529,34 @@ export type ProfileAvatarsItemNameColor = {
     g: number;
     r: number;
 };
+export type ProfileAvatarsItemLinksItem = {
+    title: string;
+    url: string;
+};
 export type ProfileAvatarsItem = {
     avatar?: ProfileAvatarsItemAvatar;
+    birthdate?: number;
+    blocked?: string[];
+    country?: string;
     description?: string;
     email?: string;
+    employmentStatus?: string;
     ethAddress?: string;
+    gender?: string;
     hasClaimedName?: boolean;
+    hasConnectedWeb3?: boolean;
+    hobbies?: string;
     interests?: string[];
+    language?: string;
+    links?: ProfileAvatarsItemLinksItem[];
+    muted?: string[];
     name?: string;
     nameColor?: ProfileAvatarsItemNameColor;
+    profession?: string;
+    pronouns?: string;
+    realName?: string;
+    relationshipStatus?: string;
+    sexualOrientation?: string;
     tutorialStep?: number;
     unclaimedName?: string;
     userId?: string;
@@ -260,50 +607,59 @@ export type ProfileAvatarsItemAvatar = {
     bodyShape?: string;
     emotes?: ProfileAvatarsItemAvatarEmotesItem[];
     eyes?: ProfileAvatarsItemAvatarEyes;
+    /** Wearable categories rendered even when hidden by other wearables */
+    forceRender?: string[];
     hair?: ProfileAvatarsItemAvatarHair;
     skin?: ProfileAvatarsItemAvatarSkin;
     snapshots?: ProfileAvatarsItemAvatarSnapshots;
     wearables?: string[];
 };
 export interface PostProfiles {
-    ids?: string[];
+    ids: string[];
 }
 export interface ParcelOperators {
-    address: string;
     approvedForAll: string[];
     operator: string | null;
+    owner: string;
     updateManagers: string[];
     updateOperator: string | null;
 }
-export type RealmsItem = {
-    layer?: string;
-    maxUsers?: number;
-    serverName?: string;
-    url?: string;
-    userParcels?: number[][];
-    usersCount?: number;
-};
-export type Realms = RealmsItem[];
-export type HotScenesItemRealmsItem = {
-    layer?: string;
-    maxUsers?: number;
-    serverName?: string;
-    url?: string;
-    userParcels?: number[][];
-    usersCount?: number;
-};
-export type HotScenesItem = {
-    baseCoords?: number[];
-    creator?: string;
-    description?: string;
-    id?: string;
-    name?: string;
-    parcels?: number[][];
-    realms?: HotScenesItemRealmsItem[];
-    thumbnail?: string;
-    usersTotalCount?: number;
+export type SchemaValidationErrorDataItem = {
+    [key: string]: any;
 };
-export type HotScenes = HotScenesItem[];
+export interface SchemaValidationError {
+    /** JSON schema validation errors */
+    data?: SchemaValidationErrorDataItem[];
+    message: string;
+    ok: boolean;
+}
+export interface ValidateSignatureResponse {
+    /** Reason the validation failed */
+    error?: string;
+    /** Address of the first link of the chain. Present only when the signature is valid. */
+    ownerAddress?: string;
+    valid: boolean;
+}
+export type ValidateSignatureRequestAuthChainItemType = (typeof ValidateSignatureRequestAuthChainItemType)[keyof typeof ValidateSignatureRequestAuthChainItemType];
+export declare const ValidateSignatureRequestAuthChainItemType: {
+    readonly SIGNER: "SIGNER";
+    readonly ECDSA_EPHEMERAL: "ECDSA_EPHEMERAL";
+    readonly ECDSA_SIGNED_ENTITY: "ECDSA_SIGNED_ENTITY";
+    readonly ECDSA_EIP_1654_EPHEMERAL: "ECDSA_EIP_1654_EPHEMERAL";
+    readonly ECDSA_EIP_1654_SIGNED_ENTITY: "ECDSA_EIP_1654_SIGNED_ENTITY";
+};
+export type ValidateSignatureRequestAuthChainItem = {
+    payload: string;
+    /** Required for every link except `SIGNER`, which takes an empty string or null */
+    signature?: string | null;
+    type: ValidateSignatureRequestAuthChainItemType;
+};
+export interface ValidateSignatureRequest {
+    authChain: ValidateSignatureRequestAuthChainItem[];
+    signedMessage?: string;
+    /** Legacy alternative to `signedMessage`, used only when `signedMessage` is absent */
+    timestamp?: string;
+}
 export type DenylistedUsernames = string[];
 export type Pois = string[];
 export type ServersItem = {
@@ -312,77 +668,83 @@ export type ServersItem = {
     owner: string;
 };
 export type Servers = ServersItem[];
-export type WearablesWearablesItemI18nItem = {
-    code?: string;
-    text?: string;
-};
-export type WearablesWearablesItem = {
-    collectionAddress?: string;
-    createdAt?: number;
-    data?: WearablesWearablesItemData;
-    description?: string;
-    i18n?: WearablesWearablesItemI18nItem[];
-    id?: string;
-    image?: string;
-    rarity?: string;
-    thumbnail?: string;
-    updatedAt?: number;
-};
-export interface Wearables {
-    filters?: WearablesFilters;
-    pagination?: WearablesPagination;
-    wearables?: WearablesWearablesItem[];
+export interface NameOwner {
+    /** Ethereum address of the owner of the name */
+    owner: string;
 }
-export type WearablesWearablesItemDataRepresentationsItemOverrideReplacesItem = {
-    [key: string]: any;
-};
-export type WearablesWearablesItemDataRepresentationsItem = {
-    bodyShapes?: string[];
-    contents?: WearablesWearablesItemDataRepresentationsItemContentsItem[];
-    mainFile?: string;
-    overrideHides?: WearablesWearablesItemDataRepresentationsItemOverrideHidesItem[];
-    overrideReplaces?: WearablesWearablesItemDataRepresentationsItemOverrideReplacesItem[];
-};
-export type WearablesWearablesItemData = {
-    category?: string;
-    hides?: string[];
-    replaces?: string[];
-    representations?: WearablesWearablesItemDataRepresentationsItem[];
-    tags?: string[];
-};
-export type WearablesWearablesItemDataRepresentationsItemOverrideHidesItem = {
-    [key: string]: any;
-};
-export type WearablesWearablesItemDataRepresentationsItemContentsItem = {
-    key?: string;
-    url?: string;
-};
-export type WearablesPagination = {
-    limit?: number;
+export interface CatalogPagination {
+    /** The `lastId` received in the request, if any */
+    lastId?: string;
+    limit: number;
+    /** Query string to request the next page. Absent on the last page. */
     next?: string;
-};
-export type WearablesFilters = {
+}
+/**
+ * Filters applied to the search, lowercased
+ */
+export interface CatalogFilters {
+    collectionIds?: string[];
+    itemIds?: string[];
     textSearch?: string;
-};
+}
+export interface Emotes {
+    emotes: EmoteDefinition[];
+    filters: CatalogFilters;
+    pagination: CatalogPagination;
+}
+export interface Wearables {
+    filters: CatalogFilters;
+    pagination: CatalogPagination;
+    wearables: WearableDefinition[];
+}
 export type ThirdPartyWearableIndividualDataItem = {
-    id?: string;
+    id: string;
+    tokenId?: string;
 };
+export interface ThirdPartyWearable {
+    amount: number;
+    category: string;
+    /** Present only when `includeDefinitions` is set */
+    definition?: WearableDefinition;
+    entity: Entity;
+    individualData: ThirdPartyWearableIndividualDataItem[];
+    name: string;
+    urn: string;
+}
 export interface ParcelPermissions {
-    address: boolean;
     approvedForAll: boolean;
     operator: boolean;
+    owner: boolean;
     updateManager: boolean;
     updateOperator: boolean;
 }
+export type LandsPermissionsPaginatedElementsItem = {
+    /** Parcel id in the LAND subgraph */
+    id: string;
+    owner: string;
+    updateOperator: string;
+    x: string;
+    y: string;
+};
+export interface LandsPermissionsPaginated {
+    elements: LandsPermissionsPaginatedElementsItem[];
+    pageNum: number;
+    pageSize: number;
+    totalAmount: number;
+}
 export type LandsPaginatedElementsItem = {
+    /** `parcel` or `estate` */
     category: string;
     contractAddress: string;
     description?: string;
     image?: string;
     name?: string;
+    /** Price in wei of the active order, if any */
     price?: string;
     tokenId: string;
+    /** Present only for parcels */
     x?: string;
+    /** Present only for parcels */
     y?: string;
 };
 export interface LandsPaginated {
@@ -394,6 +756,7 @@ export interface LandsPaginated {
 export type NamesPaginatedElementsItem = {
     contractAddress: string;
     name: string;
+    /** Price in wei of the active order, if any */
     price?: string;
     tokenId: string;
 };
@@ -403,67 +766,223 @@ export interface NamesPaginated {
     pageSize: number;
     totalAmount: number;
 }
+export type EmoteDefinitionEmoteDataADR74RepresentationsItem = {
+    bodyShapes: string[];
+    contents: ItemContents;
+    mainFile: string;
+};
+export type EmoteDefinitionEmoteDataADR74 = {
+    category: string;
+    loop: boolean;
+    representations: EmoteDefinitionEmoteDataADR74RepresentationsItem[];
+    tags: string[];
+};
+/**
+ * Emote metadata with its file references resolved to content server URLs
+ */
+export interface EmoteDefinition {
+    collectionAddress?: string;
+    description: string;
+    emoteDataADR74: EmoteDefinitionEmoteDataADR74;
+    i18n: ItemI18n;
+    id: string;
+    image: string;
+    metrics?: ItemMetrics;
+    name: string;
+    rarity?: string;
+    thumbnail: string;
+}
 export interface Emote {
-    amount?: number;
+    /** Number of tokens of this item owned by the address */
+    amount: number;
     category: string;
+    /** Present only when `includeDefinitions` is set */
+    definition?: EmoteDefinition;
+    /** Present only when `includeEntities` is set */
     entity?: Entity;
+    individualData: ItemIndividualData;
+    name: string;
+    rarity: string;
     urn: string;
 }
 export interface LambdasError {
     error: string;
     message: string;
 }
-export type WearableIndividualDataItem = {
-    id?: string;
-    price?: string;
-    tokenId?: string;
-    transferredAt?: string;
-};
+export type WearableDefinitionDataRepresentationsItem = {
+    bodyShapes: string[];
+    contents: ItemContents;
+    mainFile: string;
+    overrideHides: string[];
+    overrideReplaces: string[];
+};
+export type WearableDefinitionData = {
+    category: string;
+    hides: string[];
+    removesDefaultHiding?: string[];
+    replaces: string[];
+    representations: WearableDefinitionDataRepresentationsItem[];
+    tags: string[];
+};
+export interface ItemMetrics {
+    bodies?: number;
+    entities?: number;
+    materials?: number;
+    meshes?: number;
+    textures?: number;
+    triangles?: number;
+}
+/**
+ * Wearable metadata with its file references resolved to content server URLs
+ */
+export interface WearableDefinition {
+    collectionAddress?: string;
+    data: WearableDefinitionData;
+    description: string;
+    i18n: ItemI18n;
+    id: string;
+    image: string;
+    metrics?: ItemMetrics;
+    name: string;
+    rarity?: string;
+    thumbnail: string;
+}
 export interface Wearable {
-    amount?: number;
+    /** Number of tokens of this item owned by the address */
+    amount: number;
     category: string;
+    /** Present only when `includeDefinitions` is set */
+    definition?: WearableDefinition;
+    /** Present only when `includeEntities` is set */
     entity?: Entity;
-    individualData?: WearableIndividualDataItem[];
+    individualData: ItemIndividualData;
     name: string;
     rarity: string;
     urn: string;
 }
+export type ItemContentsItem = {
+    key: string;
+    url: string;
+};
+/**
+ * Files of the representation, with their absolute content server URL
+ */
+export type ItemContents = ItemContentsItem[];
+export type ItemI18nItem = {
+    code: string;
+    text: string;
+};
+export type ItemI18n = ItemI18nItem[];
+export type ItemIndividualDataItem = {
+    /** Item URN followed by `:<tokenId>` */
+    id: string;
+    /** Price in wei, sent as a string */
+    price: string;
+    tokenId: string;
+    /** Unix timestamp in seconds, sent as a string */
+    transferredAt: string;
+};
+/**
+ * One entry per owned token
+ */
+export type ItemIndividualData = ItemIndividualDataItem[];
 export type Erc721AttributesItem = {
     trait_type?: string;
     value?: string;
 };
 export interface Erc721 {
-    attributes?: Erc721AttributesItem[];
-    description?: string;
-    id?: string;
+    attributes: Erc721AttributesItem[];
+    description: string;
+    /** URN of the item */
+    id: string;
+    /** URL of the item image, if it has one */
     image?: string;
-    language?: string;
+    language: string;
     name?: string;
+    /** URL of the item thumbnail, if it has one */
     thumbnail?: string;
 }
+export interface LambdasInternalError {
+    error: string;
+}
 export interface StatusLambdas {
-    commitHash?: string;
-    currentTime?: number;
-    version?: string;
+    commitHash: string;
+    /** Server time in milliseconds since epoch */
+    currentTime: number;
+    version: string;
+}
+export type DeploymentsPagination = {
+    lastId?: string;
+    limit: number;
+    /** Whether there are more deployments after this page */
+    moreData: boolean;
+    /** Query string to request the next page, present when `moreData` is true */
+    next?: string;
+    offset: number;
+};
+/**
+ * Filters applied to the request
+ */
+export type DeploymentsFilters = {
+    entityIds?: string[];
+    entityTypes?: string[];
+    from?: number;
+    onlyCurrentlyPointed?: boolean;
+    pointers?: string[];
+    to?: number;
+};
+export interface Deployments {
+    deployments: DeploymentsDeploymentsItem[];
+    /** Filters applied to the request */
+    filters: DeploymentsFilters;
+    pagination: DeploymentsPagination;
 }
-export type StatusContentSynchronizationStatusOtherServersItem = {
-    address: string;
-    connectionState: string;
-    lastDeploymentTimestamp: number;
+/**
+ * Present when `metadata` is in `fields` and the entity has metadata
+ */
+export type DeploymentsDeploymentsItemMetadata = {
+    [key: string]: any;
+};
+export type DeploymentsDeploymentsItemContentItem = {
+    hash: string;
+    /** File name */
+    key: string;
+};
+/**
+ * Present when `auditInfo` is in `fields`
+ */
+export type DeploymentsDeploymentsItemAuditInfo = {
+    authChain: AuthChain;
+    localTimestamp: number;
+    version: string;
+};
+export type DeploymentsDeploymentsItem = {
+    /** Present when `auditInfo` is in `fields` */
+    auditInfo?: DeploymentsDeploymentsItemAuditInfo;
+    /** Present when `content` is in `fields` */
+    content?: DeploymentsDeploymentsItemContentItem[];
+    /** Address of the deployer */
+    deployedBy: string;
+    entityId: string;
+    entityTimestamp: number;
+    entityType: string;
+    entityVersion: string;
+    /** Timestamp at which this server stored the deployment */
+    localTimestamp: number;
+    /** Present when `metadata` is in `fields` and the entity has metadata */
+    metadata?: DeploymentsDeploymentsItemMetadata;
+    /** Present when `pointers` is in `fields` */
+    pointers?: string[];
 };
 export type StatusContentSynchronizationStatus = {
+    /** Timestamp of the last time the list of servers was refreshed from the DAO (0 if it hasn't happened yet) */
     lastSyncWithDAO: number;
-    lastSyncWithOtherServers?: number;
-    otherServers?: StatusContentSynchronizationStatusOtherServersItem[];
+    /** `Bootstrapping` while the server is catching up with the rest of the network, during which it rejects new deployments; `Syncing` afterwards */
     synchronizationState: string;
 };
 export interface StatusContent {
     commitHash: string;
-    currentTime?: number;
     ethNetwork: string;
-    historySize?: number;
-    lastImmutableTime?: number;
-    name?: string;
     synchronizationStatus: StatusContentSynchronizationStatus;
     version: string;
 }
@@ -479,22 +998,52 @@ export type SnapshotsItem = {
     timeRange: SnapshotsItemTimeRange;
 };
 export type Snapshots = SnapshotsItem[];
+export type PointerChangesPagination = {
+    limit: number;
+    /** Whether there are more deployments after this page */
+    moreData: boolean;
+    /** Query string to request the next page, present when `moreData` is true */
+    next?: string;
+    offset: number;
+};
+/**
+ * Filters applied to the request
+ */
+export type PointerChangesFilters = {
+    entityTypes?: string[];
+    from?: number;
+    includeAuthChain?: boolean;
+    to?: number;
+};
 export type PointerChangesDeltasItem = {
     authChain: AuthChain;
+    deployerAddress?: string;
+    deploymentId?: number;
     entityId: string;
+    entityTimestamp: number;
     entityType: string;
     localTimestamp: number;
     pointers: string[];
+    version?: string;
 };
 export interface PointerChanges {
     deltas: PointerChangesDeltasItem[];
+    /** Filters applied to the request */
+    filters?: PointerChangesFilters;
+    pagination?: PointerChangesPagination;
 }
 export type FailedDeploymentsItem = {
+    authChain: AuthChain;
     entityId: string;
     entityType: string;
     errorDescription: string;
-    failedDeploymentsRepo?: string;
+    failureTimestamp: number;
+    /** Timestamp after which the deployment will be retried */
+    nextRetryAt?: number;
     reason: string;
+    retryCount?: number;
+    /** Hash of the snapshot the entity was found in, when it was synchronized from a snapshot */
+    snapshotHash?: string;
 };
 export type FailedDeployments = FailedDeploymentsItem[];
 export type EntityMetadata = {
@@ -513,14 +1062,6 @@ export interface Entity {
     type: string;
     version: string;
 }
-export interface ThirdPartyWearable {
-    amount?: number;
-    category: string;
-    entity: Entity;
-    individualData?: ThirdPartyWearableIndividualDataItem[];
-    name: string;
-    urn: string;
-}
 export interface Errors {
     errors: string[];
 }
@@ -540,23 +1081,9 @@ export type AuthChainItem = {
 export type AuthChain = AuthChainItem[];
 export interface AuditResponse {
     authChain: AuthChain;
-    denylistedContent?: string[];
-    isDenylisted?: boolean;
     localTimestamp: number;
-    overwrittenBy?: string;
     version: string;
 }
-export type StatsParcelsParcelsItemParcel = {
-    x?: number;
-    y?: number;
-};
-export type StatsParcelsParcelsItem = {
-    parcel?: StatsParcelsParcelsItemParcel;
-    peersCount?: number;
-};
-export interface StatsParcels {
-    parcels?: StatsParcelsParcelsItem[];
-}
 export type AboutLambdas = {
     commitHash?: string;
     healthy: boolean;
@@ -654,71 +1181,118 @@ export type AboutBff = {
     userCount?: number;
 };
 /**
- * Retrieve detailed information about the services
- * @summary Catalyst Server status
+ * Retrieve the version and commit of the Lambdas service and its current time
+ * @summary Lambdas status
  */
 export declare const getLambdaStatus: () => import("../utils/fetcher").CustomClient<StatusLambdas>;
 /**
- * Retrieve the list of collections URNs
+ * Retrieve the list of collections: the base wearables and base emotes collections, then the Ethereum collections, then the Polygon collections. Each network's collections are sorted by URN and capped at the first 1000, so the list as a whole is not sorted and may be incomplete.
  * @summary Get Collections
  */
 export declare const getCollections: () => import("../utils/fetcher").CustomClient<GetCollections200>;
 /**
- * Downloads a thumbnail image for the specified urn
+ * Downloads the file referenced by the `thumbnail` metadata field of the active entity with the specified pointer. The `Content-Type` header is detected from the file contents. Supports a single byte range via the `Range` header and conditional requests via `If-None-Match`. Also served by the content server at `/content/queries/items/{urn}/thumbnail`.
  * @summary Download thumbnail image
  */
 export declare const getThumbnail: (urn: string) => import("../utils/fetcher").CustomClient<Blob>;
 /**
- * Downloads the image for the specified urn
+ * Same as the GET request, without the body.
+ * @summary Check the thumbnail of an item
+ */
+export declare const headThumbnail: (urn: string) => import("../utils/fetcher").CustomClient<void>;
+/**
+ * Downloads the file referenced by the `image` metadata field of the active entity with the specified pointer. The `Content-Type` header is detected from the file contents. Supports a single byte range via the `Range` header and conditional requests via `If-None-Match`. Also served by the content server at `/content/queries/items/{urn}/image`.
  * @summary Download URN image
  */
 export declare const getImage: (urn: string) => import("../utils/fetcher").CustomClient<Blob>;
 /**
- * Retrieve ERC721/NFT Entity details
+ * Same as the GET request, without the body.
+ * @summary Check the image of an item
+ */
+export declare const headImage: (urn: string) => import("../utils/fetcher").CustomClient<void>;
+/**
+ * Retrieve the ERC721 metadata of a standard (with rarity) wearable or emote of a collection. The `description` of the response is empty; use the path with `emission` to include the issue number. Also served by the content server at `/content/queries/erc721/{chainId}/{contract}/{option}`.
+ * @summary Get ERC721 Entity without emission
+ */
+export declare const getStandardErc721WithoutEmission: (chainId: string, contract: string, option: string) => import("../utils/fetcher").CustomClient<Erc721>;
+/**
+ * Retrieve the ERC721 metadata of a standard (with rarity) wearable or emote of a collection. Also served by the content server at `/content/queries/erc721/{chainId}/{contract}/{option}/{emission}`.
  * @summary Get ERC721 Entity
  */
 export declare const getStandardErc721: (chainId: string, contract: string, option: string, emission: string) => import("../utils/fetcher").CustomClient<Erc721>;
 /**
- * Get a list of wearables owned by the given address
+ * Get a paginated list of the on-chain wearables owned by the given address, grouped by item. Base and third-party wearables are not included.
  * @summary Get list of wearables for an address
  */
 export declare const getWearables: (address: string, params?: GetWearablesParams) => import("../utils/fetcher").CustomClient<GetWearables200>;
 /**
- * Get a list of emotes owned by the given address
+ * Get a paginated list of the on-chain emotes owned by the given address, grouped by item. Base emotes are not included.
  * @summary Get list of emotes for an address
  */
 export declare const getEmotes: (address: string, params?: GetEmotesParams) => import("../utils/fetcher").CustomClient<GetEmotes200>;
 /**
- * Get a list of names owned by the given address
+ * Get a paginated list of the Decentraland names owned by the given address
  * @summary Get list of names for an address
  */
 export declare const getNames: (address: string, params?: GetNamesParams) => import("../utils/fetcher").CustomClient<NamesPaginated>;
 /**
- * Get a list of lands owned by the given address
+ * Get a paginated list of the parcels and estates owned by the given address
  * @summary Get list of lands for an address
  */
 export declare const getLands: (address: string, params?: GetLandsParams) => import("../utils/fetcher").CustomClient<LandsPaginated>;
 /**
- * Get the permissions a user has for a parcel
+ * Get a paginated list of the parcels for which the given address is the update operator. Operators, update managers and approvals for all are not included.
+ * @summary Get the parcels an address can operate
+ */
+export declare const getLandsPermissions: (address: string, params?: GetLandsPermissionsParams) => import("../utils/fetcher").CustomClient<LandsPermissionsPaginated>;
+/**
+ * Get the permissions an address has over a parcel, using the same rights resolution as `/lambdas/parcels/{x}/{y}/operators`
  * @summary Get the permissions for a parcel
  */
-export declare const getParcelPermissions: (address: string, x: string, y: string) => import("../utils/fetcher").CustomClient<ParcelPermissions>;
+export declare const getParcelPermissions: (address: string, x: number, y: number) => import("../utils/fetcher").CustomClient<ParcelPermissions>;
 /**
- * Returns the list of third party wearables for the provided address
+ * Returns a paginated list of the third party (linked) wearables owned by the provided address, across all registered third party collections
  * @summary Returns the list of third party wearables for the provided address
  */
 export declare const getThirdPartyWearables: (address: string, params?: GetThirdPartyWearablesParams) => import("../utils/fetcher").CustomClient<GetThirdPartyWearables200>;
 /**
- * Returns the list of third party wearables for the given collection
+ * Returns a paginated list of the third party (linked) wearables of the given collection owned by the provided address
  * @summary Returns the list of third party wearables for the given collection
  */
 export declare const getThirdPartyCollection: (address: string, collectionId: string, params?: GetThirdPartyCollectionParams) => import("../utils/fetcher").CustomClient<GetThirdPartyCollection200>;
 /**
- * Search for wearables based on the applied filters and retrieve detailed information
+ * Search the wearables catalog, base wearables included, and retrieve their definitions. At least one of `textSearch`, `collectionId` or `wearableId` is required. Results are sorted by URN, base wearables first, and paginated with the `lastId` cursor.
  * @deprecated
  * @summary Search Wearables
  */
 export declare const searchWearables: (params?: SearchWearablesParams) => import("../utils/fetcher").CustomClient<Wearables>;
+/**
+ * Search the on-chain emotes catalog and retrieve their definitions. Base emotes are not included. At least one of `textSearch`, `collectionId` or `emoteId` is required. Results are sorted by URN and paginated with the `lastId` cursor.
+ * @deprecated
+ * @summary Search Emotes
+ */
+export declare const searchEmotes: (params?: SearchEmotesParams) => import("../utils/fetcher").CustomClient<Emotes>;
+/**
+ * Legacy endpoint that returns every on-chain wearable owned by the address, with no pagination. When `collectionId` is set, the third party wearables of that collection are returned instead.
+ * @summary Get wearables by owner
+ */
+export declare const getWearablesByOwner: (owner: string, params?: GetWearablesByOwnerParams) => import("../utils/fetcher").CustomClient<GetWearablesByOwner200Item[]>;
+/**
+ * Legacy endpoint that returns every on-chain emote owned by the address, with no pagination. When `collectionId` is set, the third party items of that collection are returned instead.
+ * @summary Get emotes by owner
+ */
+export declare const getEmotesByOwner: (owner: string, params?: GetEmotesByOwnerParams) => import("../utils/fetcher").CustomClient<GetEmotesByOwner200Item[]>;
+/**
+ * Same response as `/lambdas/collections`, served under the path lamb2 uses internally
+ * @deprecated
+ * @summary Get Collections (alias)
+ */
+export declare const getNftsCollections: () => import("../utils/fetcher").CustomClient<GetNftsCollections200>;
+/**
+ * Returns the address that owns the given Decentraland name
+ * @summary Get the owner of a name
+ */
+export declare const getNameOwner: (name: string) => import("../utils/fetcher").CustomClient<NameOwner>;
 /**
  * Retrieve the list of Catalyst Servers
  * @summary Get Catalyst Servers
@@ -735,28 +1309,18 @@ export declare const getPois: () => import("../utils/fetcher").CustomClient<Pois
  */
 export declare const getDenylistedUserNames: () => import("../utils/fetcher").CustomClient<DenylistedUsernames>;
 /**
- * Given a signed message and it's AuthChain, validate it's authenticity. A message can be signed, for example, to prove ownership of the Entity pointers that they want to modify.
+ * Given a signed message and its AuthChain, validate its authenticity. A message can be signed, for example, to prove ownership of the Entity pointers that they want to modify. An invalid signature is reported with a 200 response and `valid: false`.
  * @deprecated
  * @summary Validate signed message
  */
-export declare const validateSignature: (validateSignatureBody: ValidateSignatureBody) => import("../utils/fetcher").CustomClient<ValidateSignature200>;
-/**
- * Returns the list of scenes where there are more users with coordinates and the list of parcels that compose the scene.
- * @summary Hot Scenes
- */
-export declare const getHotScenes: () => import("../utils/fetcher").CustomClient<HotScenes>;
+export declare const validateSignature: (validateSignatureRequest: ValidateSignatureRequest) => import("../utils/fetcher").CustomClient<ValidateSignatureResponse>;
 /**
- * Returns the list of realms with details about the users in it
- * @summary Get Realms status
- */
-export declare const getRealms: () => import("../utils/fetcher").CustomClient<Realms>;
-/**
- * Get the operators for a parcel
+ * Get the owner of a parcel and the addresses allowed to operate it. When the parcel belongs to an estate, the owner, operator and update managers are those of the estate, and a parcel-level update operator takes precedence over the estate one.
  * @summary Get the operators for a parcel
  */
-export declare const getParcelOperators: (x: string, y: string) => import("../utils/fetcher").CustomClient<ParcelOperators>;
+export declare const getParcelOperators: (x: number, y: number) => import("../utils/fetcher").CustomClient<ParcelOperators>;
 /**
- * Returns all the Avatars details associated with the Ethereum addresses in the body
+ * Returns the profiles of the Ethereum addresses in the body. Addresses without a deployed profile are omitted from the response.
  * @summary Get Avatars details
  */
 export declare const getAvatarsDetailsByPost: (postProfiles: PostProfiles) => import("../utils/fetcher").CustomClient<Profile[]>;
@@ -766,7 +1330,13 @@ export declare const getAvatarsDetailsByPost: (postProfiles: PostProfiles) => im
  */
 export declare const getAvatarDetails: (id: string) => import("../utils/fetcher").CustomClient<Profile>;
 /**
- * Given a Ethereum address of a user, return the Outfits entity.
+ * Legacy alias of `/lambdas/profiles/{id}`. When the address has no deployed profile it responds 200 with `{ "avatars": [], "timestamp": 0 }` instead of 404.
+ * @deprecated
+ * @summary Get Avatar details (legacy)
+ */
+export declare const getAvatarDetailsLegacy: (id: string) => import("../utils/fetcher").CustomClient<Profile>;
+/**
+ * Given a Ethereum address of a user, return their Outfits entity. Outfits with wearables the user no longer owns are removed from the metadata, as are outfits in slots above 4 when the user owns no name.
  * @summary Get Outfits
  */
 export declare const getOutfits: (id: string) => import("../utils/fetcher").CustomClient<Entity>;
@@ -780,25 +1350,33 @@ type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
 export type GetLambdaStatusResult = NonNullable<Awaited<ReturnType<typeof getLambdaStatus>>>;
 export type GetCollectionsResult = NonNullable<Awaited<ReturnType<typeof getCollections>>>;
 export type GetThumbnailResult = NonNullable<Awaited<ReturnType<typeof getThumbnail>>>;
+export type HeadThumbnailResult = NonNullable<Awaited<ReturnType<typeof headThumbnail>>>;
 export type GetImageResult = NonNullable<Awaited<ReturnType<typeof getImage>>>;
+export type HeadImageResult = NonNullable<Awaited<ReturnType<typeof headImage>>>;
+export type GetStandardErc721WithoutEmissionResult = NonNullable<Awaited<ReturnType<typeof getStandardErc721WithoutEmission>>>;
 export type GetStandardErc721Result = NonNullable<Awaited<ReturnType<typeof getStandardErc721>>>;
 export type GetWearablesResult = NonNullable<Awaited<ReturnType<typeof getWearables>>>;
 export type GetEmotesResult = NonNullable<Awaited<ReturnType<typeof getEmotes>>>;
 export type GetNamesResult = NonNullable<Awaited<ReturnType<typeof getNames>>>;
 export type GetLandsResult = NonNullable<Awaited<ReturnType<typeof getLands>>>;
+export type GetLandsPermissionsResult = NonNullable<Awaited<ReturnType<typeof getLandsPermissions>>>;
 export type GetParcelPermissionsResult = NonNullable<Awaited<ReturnType<typeof getParcelPermissions>>>;
 export type GetThirdPartyWearablesResult = NonNullable<Awaited<ReturnType<typeof getThirdPartyWearables>>>;
 export type GetThirdPartyCollectionResult = NonNullable<Awaited<ReturnType<typeof getThirdPartyCollection>>>;
 export type SearchWearablesResult = NonNullable<Awaited<ReturnType<typeof searchWearables>>>;
+export type SearchEmotesResult = NonNullable<Awaited<ReturnType<typeof searchEmotes>>>;
+export type GetWearablesByOwnerResult = NonNullable<Awaited<ReturnType<typeof getWearablesByOwner>>>;
+export type GetEmotesByOwnerResult = NonNullable<Awaited<ReturnType<typeof getEmotesByOwner>>>;
+export type GetNftsCollectionsResult = NonNullable<Awaited<ReturnType<typeof getNftsCollections>>>;
+export type GetNameOwnerResult = NonNullable<Awaited<ReturnType<typeof getNameOwner>>>;
 export type GetCatalystServersResult = NonNullable<Awaited<ReturnType<typeof getCatalystServers>>>;
 export type GetPoisResult = NonNullable<Awaited<ReturnType<typeof getPois>>>;
 export type GetDenylistedUserNamesResult = NonNullable<Awaited<ReturnType<typeof getDenylistedUserNames>>>;
 export type ValidateSignatureResult = NonNullable<Awaited<ReturnType<typeof validateSignature>>>;
-export type GetHotScenesResult = NonNullable<Awaited<ReturnType<typeof getHotScenes>>>;
-export type GetRealmsResult = NonNullable<Awaited<ReturnType<typeof getRealms>>>;
 export type GetParcelOperatorsResult = NonNullable<Awaited<ReturnType<typeof getParcelOperators>>>;
 export type GetAvatarsDetailsByPostResult = NonNullable<Awaited<ReturnType<typeof getAvatarsDetailsByPost>>>;
 export type GetAvatarDetailsResult = NonNullable<Awaited<ReturnType<typeof getAvatarDetails>>>;
+export type GetAvatarDetailsLegacyResult = NonNullable<Awaited<ReturnType<typeof getAvatarDetailsLegacy>>>;
 export type GetOutfitsResult = NonNullable<Awaited<ReturnType<typeof getOutfits>>>;
 export type GetThirdPartyIntegrationsResult = NonNullable<Awaited<ReturnType<typeof getThirdPartyIntegrations>>>;
 export {};