@ludo.ninja/api 1.0.0

package/build/graphql_tools/__generated__/schema.d.ts

@@ -0,0 +1,4742 @@
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T | null;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    Long: any;
+    Upload: any;
+};
+export type IAddress = {
+    creators?: Maybe<Array<Maybe<IWallet>>>;
+    owners?: Maybe<Array<Maybe<IWallet>>>;
+    associateAddresses?: Maybe<Array<Maybe<IWallet>>>;
+};
+export type IAsset = {
+    address?: Maybe<Scalars['String']>;
+    assetId: Scalars['String'];
+    assetOrder?: Maybe<Scalars['Int']>;
+    attributes?: Maybe<Array<Maybe<IAttribute>>>;
+    blockHeight?: Maybe<Scalars['Long']>;
+    blockTimestamp?: Maybe<Scalars['Long']>;
+    blockchain?: Maybe<Scalars['String']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    chainId?: Maybe<Scalars['String']>;
+    collectionId?: Maybe<Scalars['String']>;
+    collectionMedias?: Maybe<Array<Maybe<IMedia>>>;
+    collectionOriginalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    collectionTitle?: Maybe<Scalars['String']>;
+    collectionUrl?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    description?: Maybe<Scalars['String']>;
+    galleries?: Maybe<IGalleries>;
+    lastSoldAt?: Maybe<Scalars['String']>;
+    latestPriceAmount?: Maybe<Scalars['Float']>;
+    latestPriceBlockHeight?: Maybe<Scalars['Long']>;
+    latestPriceCurrency?: Maybe<Scalars['String']>;
+    liked?: Maybe<Scalars['Boolean']>;
+    likes?: Maybe<Scalars['Int']>;
+    listedAt?: Maybe<Scalars['String']>;
+    markets?: Maybe<Array<Maybe<IAssetMarket>>>;
+    mediaUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    mintedAt?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    price?: Maybe<Scalars['Float']>;
+    rank?: Maybe<Scalars['Float']>;
+    rankMax?: Maybe<Scalars['Float']>;
+    rankRaw?: Maybe<Scalars['Float']>;
+    rankUpdatedAt?: Maybe<Scalars['Float']>;
+    score?: Maybe<Scalars['String']>;
+    supply?: Maybe<Scalars['String']>;
+    symbol?: Maybe<Scalars['String']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+    tokenId?: Maybe<Scalars['String']>;
+    totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+    traits?: Maybe<Array<Maybe<ITrait>>>;
+    type?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['String']>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type IAssetGallery = {
+    galleryId: Scalars['ID'];
+    galleryName: Scalars['String'];
+};
+export type IAssetMarket = {
+    marketId?: Maybe<Scalars['String']>;
+    marketName?: Maybe<Scalars['String']>;
+    marketDomain?: Maybe<Scalars['String']>;
+    marketUrl?: Maybe<Scalars['String']>;
+};
+export type IAssetModeration = {
+    assetId: Scalars['String'];
+    status?: Maybe<Scalars['String']>;
+    category?: Maybe<Scalars['String']>;
+    locationsToShow?: Maybe<Array<Maybe<Scalars['String']>>>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    adult?: Maybe<Scalars['Boolean']>;
+    lockedFrom?: Maybe<Scalars['Long']>;
+    lockedTo?: Maybe<Scalars['Long']>;
+    deletedOn?: Maybe<Scalars['Long']>;
+    address?: Maybe<Scalars['String']>;
+    tokenId?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    chainId?: Maybe<Scalars['String']>;
+    blockHeight?: Maybe<Scalars['Long']>;
+    blockTimestamp?: Maybe<Scalars['Long']>;
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    attributes?: Maybe<Array<Maybe<IAttribute>>>;
+    likes?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    rank?: Maybe<Scalars['Float']>;
+};
+export type IAssetModerationFilter = {
+    itemName?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    addressVariety?: Maybe<Array<Maybe<ISelectionInput>>>;
+    status?: Maybe<Array<Maybe<ISelectionInput>>>;
+    place?: Maybe<Array<Maybe<ISelectionInput>>>;
+    category?: Maybe<Array<Maybe<ISelectionInput>>>;
+    blockchain?: Maybe<Array<Maybe<ISelectionInput>>>;
+    sort: ISelectionInput;
+    dateFrom?: Maybe<Scalars['String']>;
+    dateTo?: Maybe<Scalars['String']>;
+};
+export type IAssetModerationsPage = {
+    assetModerations?: Maybe<Array<Maybe<IAssetModeration>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IAssetPage = {
+    assets: Array<Maybe<IAsset>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IAssetReport = {
+    reportId: Scalars['ID'];
+    type?: Maybe<Scalars['String']>;
+    status?: Maybe<Scalars['String']>;
+    issuerProfile?: Maybe<IProfile>;
+    issuerAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    reason?: Maybe<Scalars['String']>;
+    link?: Maybe<Scalars['String']>;
+    reportedAt?: Maybe<Scalars['Long']>;
+    entityStatus?: Maybe<Scalars['String']>;
+    locationsToShow?: Maybe<Array<Maybe<Scalars['String']>>>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    adult?: Maybe<Scalars['Boolean']>;
+    lockedFrom?: Maybe<Scalars['Long']>;
+    lockedTo?: Maybe<Scalars['Long']>;
+    deletedOn?: Maybe<Scalars['Long']>;
+    category?: Maybe<Scalars['String']>;
+    assetId?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    tokenId?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    chainId?: Maybe<Scalars['String']>;
+    blockHeight?: Maybe<Scalars['Long']>;
+    blockTimestamp?: Maybe<Scalars['Long']>;
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    ownersAddresses?: Maybe<Scalars['String']>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    creatorsAddresses?: Maybe<Scalars['String']>;
+    attributes?: Maybe<Array<Maybe<IAttribute>>>;
+    likes?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    rank?: Maybe<Scalars['Float']>;
+};
+export type IAssetReportFilter = {
+    name?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    varietyOfAddress?: Maybe<Array<Maybe<ISelectionInput>>>;
+    status?: Maybe<Array<Maybe<ISelectionInput>>>;
+    reason?: Maybe<Array<Maybe<ISelectionInput>>>;
+    blockchain?: Maybe<Array<Maybe<ISelectionInput>>>;
+    category?: Maybe<Array<Maybe<ISelectionInput>>>;
+    rate?: Maybe<ISelectionInput>;
+    sort: ISelectionInput;
+    dateFrom?: Maybe<Scalars['String']>;
+    dateTo?: Maybe<Scalars['String']>;
+};
+export type IAssetReportRestriction = {
+    reportId: Scalars['ID'];
+    locationsToShow: Array<Maybe<Scalars['String']>>;
+    blurred: Scalars['Boolean'];
+};
+export type IAssetReportsPage = {
+    assetReports?: Maybe<Array<Maybe<IAssetReport>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IAssetsPage = {
+    assets: Array<Maybe<IAsset>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IAttribute = {
+    name?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+};
+export type IBannerAsset = {
+    assetId: Scalars['String'];
+    blurred?: Maybe<Scalars['Boolean']>;
+    media: Scalars['String'];
+    name?: Maybe<Scalars['String']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type IBannerAssetsPage = {
+    assets?: Maybe<Array<Maybe<IBannerAsset>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type ICollection = {
+    blockchain?: Maybe<Scalars['String']>;
+    collectionAssets?: Maybe<Array<Maybe<ICollectionAsset>>>;
+    collectionId?: Maybe<Scalars['String']>;
+    collectionMarkets?: Maybe<Array<Maybe<ICollectionMarket>>>;
+    collectionTitle?: Maybe<Scalars['String']>;
+    contractAddress?: Maybe<Scalars['String']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    floorPrices?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+    identifier?: Maybe<Scalars['String']>;
+    items?: Maybe<Scalars['Int']>;
+    liked?: Maybe<Scalars['Boolean']>;
+    likes?: Maybe<Scalars['Int']>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    nsfw?: Maybe<Scalars['Int']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    owners?: Maybe<Scalars['Int']>;
+    rank?: Maybe<Scalars['Float']>;
+    tokenId?: Maybe<Scalars['String']>;
+    totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+    verified?: Maybe<Scalars['Boolean']>;
+};
+export type ICollectionAsset = {
+    address?: Maybe<Scalars['String']>;
+    assetId?: Maybe<Scalars['String']>;
+    attributes?: Maybe<Array<Maybe<IAttribute>>>;
+    blockHeight?: Maybe<Scalars['Long']>;
+    blockchain?: Maybe<Scalars['String']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    chainId?: Maybe<Scalars['String']>;
+    collectionId?: Maybe<Scalars['String']>;
+    collectionMedias?: Maybe<Array<Maybe<IMedia>>>;
+    collectionOriginalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    collectionTitle?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    description?: Maybe<Scalars['String']>;
+    liked?: Maybe<Scalars['Boolean']>;
+    likes?: Maybe<Scalars['Int']>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    name?: Maybe<Scalars['String']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    prices?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+    rank?: Maybe<Scalars['Float']>;
+    tokenId?: Maybe<Scalars['String']>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type ICollectionAssetsPage = {
+    collectionAssets?: Maybe<Array<Maybe<ICollectionAsset>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type ICollectionFilterInput = {
+    blockchain: Scalars['String'];
+    category: Scalars['String'];
+    time: Scalars['String'];
+    status: Scalars['String'];
+};
+export type ICollectionMarket = {
+    marketId?: Maybe<Scalars['String']>;
+    marketName?: Maybe<Scalars['String']>;
+    marketDomain?: Maybe<Scalars['String']>;
+    marketUrl?: Maybe<Scalars['String']>;
+};
+export type ICollectionPage = {
+    collections: Array<Maybe<ICollection>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+};
+export type ICollectionsPage = {
+    collections?: Maybe<Array<Maybe<ICollection>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type ICreation = {
+    address?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    fileSize?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    itemId: Scalars['String'];
+    itemType: Scalars['String'];
+    liked?: Maybe<Scalars['Boolean']>;
+    likes?: Maybe<Scalars['Int']>;
+    media?: Maybe<Scalars['String']>;
+    mediaPreview?: Maybe<Scalars['String']>;
+    mimeType?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    prices?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+    rank?: Maybe<Scalars['Float']>;
+    sizeRatio?: Maybe<Scalars['Float']>;
+    tokenId?: Maybe<Scalars['String']>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type ICreationFilterInput = {
+    type: Scalars['String'];
+    blockchain: Scalars['String'];
+    category: Scalars['String'];
+    time: Scalars['String'];
+    status: Scalars['String'];
+};
+export type ICreationsPage = {
+    creations?: Maybe<Array<Maybe<ICreation>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+};
+export type ICurrencyAmountPair = {
+    currency?: Maybe<Scalars['String']>;
+    amount?: Maybe<Scalars['Float']>;
+};
+export type IDynamicAssetData = {
+    isLikedByUser?: Maybe<Scalars['Boolean']>;
+    likesNum?: Maybe<Scalars['Int']>;
+    assetId?: Maybe<Scalars['String']>;
+};
+export type IDynamicCollectionData = {
+    isLikedByUser?: Maybe<Scalars['Boolean']>;
+    likesNum?: Maybe<Scalars['Int']>;
+    collectionAssetsPage?: Maybe<ICollectionAssetsPage>;
+    collectionId?: Maybe<Scalars['String']>;
+};
+export type IDynamicCollectionDataInput = {
+    collectionId: Scalars['String'];
+    assetsPageSize?: Maybe<Scalars['Int']>;
+    assetsPageToken?: Maybe<Scalars['String']>;
+};
+export type IEvent = {
+    event?: Maybe<Scalars['String']>;
+    price?: Maybe<Scalars['Float']>;
+    to?: Maybe<IWallet>;
+    from?: Maybe<IWallet>;
+};
+export type IExpectation = {
+    name: Scalars['String'];
+    imageUrl: Scalars['String'];
+};
+export type IFactor = {
+    favorites?: Maybe<Scalars['Long']>;
+    highestOffer?: Maybe<Scalars['Float']>;
+    verified?: Maybe<Scalars['Boolean']>;
+};
+export type IFee = {
+    service?: Maybe<Scalars['Float']>;
+    royalties?: Maybe<Scalars['Float']>;
+    extra?: Maybe<Scalars['Float']>;
+    creators?: Maybe<Scalars['Float']>;
+};
+export type IFollower = {
+    userId: Scalars['ID'];
+    username?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    following?: Maybe<Scalars['Boolean']>;
+};
+export type IGalleries = {
+    assetGalleries: Array<Maybe<IAssetGallery>>;
+};
+export type IGalleriesPage = {
+    galleries?: Maybe<Array<Maybe<IGallery>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+};
+export type IGalleriesPageV2 = {
+    galleries?: Maybe<Array<Maybe<IGalleryV2>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+};
+export type IGallery = {
+    galleryId: Scalars['ID'];
+    galleryType: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    userId: Scalars['ID'];
+    username?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    userWallets?: Maybe<Array<Maybe<IWallet>>>;
+    banner?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    items?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    publiclyAccessible?: Maybe<Scalars['Boolean']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    galleryCreations?: Maybe<Array<Maybe<IGalleryCreation>>>;
+};
+export type IGalleryAsset = {
+    assetId: Scalars['String'];
+    assetOrder?: Maybe<Scalars['Int']>;
+    attributes?: Maybe<Array<Maybe<IAttribute>>>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    creatorAddress?: Maybe<Scalars['String']>;
+    creatorName?: Maybe<Scalars['String']>;
+    creatorUserId?: Maybe<Scalars['String']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    fileSize?: Maybe<Scalars['Long']>;
+    galleryId?: Maybe<Scalars['String']>;
+    galleryName?: Maybe<Scalars['String']>;
+    likes?: Maybe<Scalars['Int']>;
+    media?: Maybe<Scalars['String']>;
+    mediaRatio?: Maybe<Scalars['Float']>;
+    medias?: Maybe<Array<Maybe<IMedia>>>;
+    mimeType?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    originalMedia?: Maybe<Scalars['String']>;
+    originalMediaPreview?: Maybe<Scalars['String']>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type IGalleryAssetInput = {
+    assetId: Scalars['String'];
+    assetOrder: Scalars['Int'];
+};
+export type IGalleryCreation = {
+    galleryId: Scalars['String'];
+    creationId: Scalars['String'];
+    itemId?: Maybe<Scalars['String']>;
+    itemType?: Maybe<Scalars['String']>;
+    itemOrder?: Maybe<Scalars['Int']>;
+    galleryName?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    tokenId?: Maybe<Scalars['String']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+    media?: Maybe<Scalars['String']>;
+    mediaPreview?: Maybe<Scalars['String']>;
+    mimeType?: Maybe<Scalars['String']>;
+    sizeRatio?: Maybe<Scalars['Float']>;
+    fileSize?: Maybe<Scalars['Long']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    likes?: Maybe<Scalars['Int']>;
+    liked?: Maybe<Scalars['Boolean']>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    prices?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+};
+export type IGalleryCreationInput = {
+    creationId: Scalars['String'];
+    itemOrder: Scalars['Int'];
+};
+export type IGalleryCreationsPage = {
+    galleryCreations: Array<Maybe<IGalleryCreation>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IGalleryPage = {
+    galleries: Array<Maybe<IGallery>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+};
+export type IGalleryProfileFilterInput = {
+    blockchain: Scalars['String'];
+    category: Scalars['String'];
+    time: Scalars['String'];
+};
+export type IGalleryReport = {
+    reportId: Scalars['ID'];
+    type?: Maybe<Scalars['String']>;
+    status?: Maybe<Scalars['String']>;
+    issuerId?: Maybe<Scalars['String']>;
+    issuerName?: Maybe<Scalars['String']>;
+    issuerAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    offenderId?: Maybe<Scalars['String']>;
+    offenderName?: Maybe<Scalars['String']>;
+    offenderAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    reason?: Maybe<Scalars['String']>;
+    link?: Maybe<Scalars['String']>;
+    reportedAt?: Maybe<Scalars['Long']>;
+    entityStatus?: Maybe<Scalars['String']>;
+    locationsToShow?: Maybe<Array<Maybe<Scalars['String']>>>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    adult?: Maybe<Scalars['Boolean']>;
+    lockedFrom?: Maybe<Scalars['Long']>;
+    lockedTo?: Maybe<Scalars['Long']>;
+    deletedOn?: Maybe<Scalars['Long']>;
+    category?: Maybe<Scalars['String']>;
+    galleryId?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    customUrl?: Maybe<Scalars['String']>;
+    userId?: Maybe<Scalars['ID']>;
+    username?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    subscribes?: Maybe<Scalars['Int']>;
+    items?: Maybe<Scalars['Int']>;
+    galleryAssets?: Maybe<Array<Maybe<IGalleryAsset>>>;
+};
+export type IGalleryReportFilter = {
+    name?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    varietyOfAddress?: Maybe<Array<Maybe<ISelectionInput>>>;
+    status?: Maybe<Array<Maybe<ISelectionInput>>>;
+    reason?: Maybe<Array<Maybe<ISelectionInput>>>;
+    category?: Maybe<Array<Maybe<ISelectionInput>>>;
+    rate?: Maybe<ISelectionInput>;
+    sort: ISelectionInput;
+    dateFrom?: Maybe<Scalars['String']>;
+    dateTo?: Maybe<Scalars['String']>;
+};
+export type IGalleryReportRestriction = {
+    reportId: Scalars['ID'];
+    locationsToShow: Array<Maybe<Scalars['String']>>;
+    blurred: Scalars['Boolean'];
+};
+export type IGalleryReportsPage = {
+    galleryReports?: Maybe<Array<Maybe<IGalleryReport>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IGallerySearchFilterInput = {
+    blockchain: Scalars['String'];
+    category: Scalars['String'];
+    time: Scalars['String'];
+    type: Scalars['String'];
+};
+export type IGalleryV2 = {
+    galleryId: Scalars['ID'];
+    galleryType: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    userId: Scalars['ID'];
+    username?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    userWallets?: Maybe<Array<Maybe<IWallet>>>;
+    banner?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    items?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    publiclyAccessible?: Maybe<Scalars['Boolean']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export type IHistory = {
+    offers?: Maybe<Array<Maybe<IOffer>>>;
+    events?: Maybe<Array<Maybe<IEvent>>>;
+};
+export type IIdentity = {
+    userId: Scalars['ID'];
+    wallets: Array<Maybe<Scalars['String']>>;
+    authToken: Scalars['String'];
+    refreshToken: Scalars['String'];
+    newUser: Scalars['Boolean'];
+};
+export type IInputProfile = {
+    username?: Maybe<Scalars['String']>;
+    about?: Maybe<Scalars['String']>;
+    social?: Maybe<IInputSocial>;
+    showNsfw?: Maybe<Scalars['Boolean']>;
+};
+export type IInputSocial = {
+    facebook?: Maybe<Scalars['String']>;
+    twitter?: Maybe<Scalars['String']>;
+    instagram?: Maybe<Scalars['String']>;
+    website?: Maybe<Scalars['String']>;
+};
+export type IInterest = {
+    name: Scalars['String'];
+    imageUrl: Scalars['String'];
+};
+export type ILogin = {
+    userId?: Maybe<Scalars['ID']>;
+    loggedTime?: Maybe<Scalars['Long']>;
+    ip?: Maybe<Scalars['String']>;
+    location?: Maybe<Scalars['String']>;
+};
+export type ILoginsPage = {
+    logins?: Maybe<Array<Maybe<ILogin>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IMarket = {
+    marketId: Scalars['String'];
+    tokenId?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    factors?: Maybe<IFactor>;
+    asset?: Maybe<IAsset>;
+    addresses?: Maybe<IAddress>;
+    histories?: Maybe<IHistory>;
+    marketData?: Maybe<IMarketData>;
+    fees?: Maybe<IFee>;
+};
+export type IMarketData = {
+    marketName?: Maybe<Scalars['String']>;
+    marketUpdatedAt?: Maybe<Scalars['String']>;
+    domain?: Maybe<Scalars['String']>;
+};
+export type IMarketsPage = {
+    markets?: Maybe<Array<Maybe<IMarket>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IMedia = {
+    assetId?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    fileSize?: Maybe<Scalars['Long']>;
+    mimeType?: Maybe<Scalars['String']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    originalUrl?: Maybe<Scalars['String']>;
+    previewUrl?: Maybe<Scalars['String']>;
+    sizeRatio?: Maybe<Scalars['Float']>;
+    url?: Maybe<Scalars['String']>;
+};
+export type IMutation = {
+    addAssetsToGallery: Scalars['Boolean'];
+    addAssetsToGalleryV2: Scalars['Boolean'];
+    addCollectionsToGallery: Scalars['Boolean'];
+    addCollectionsToGalleryV2: Scalars['Boolean'];
+    addCreationsToGallery: Scalars['Boolean'];
+    addCreationsToGalleryV2: Scalars['Boolean'];
+    addWalletBitcoin: Scalars['Boolean'];
+    addWalletElrond: Scalars['Boolean'];
+    addWalletFlow: Scalars['Boolean'];
+    addWalletMetamask: Scalars['Boolean'];
+    addWalletNear: Scalars['Boolean'];
+    addWalletSolana: Scalars['Boolean'];
+    addWalletTerra: Scalars['Boolean'];
+    addWalletTezos: Scalars['Boolean'];
+    addWalletWalletConnect: Scalars['Boolean'];
+    approveAsset: Scalars['Boolean'];
+    approveAssets: Scalars['Boolean'];
+    approveUser: Scalars['Boolean'];
+    approveUsers: Scalars['Boolean'];
+    blockUser: Scalars['Boolean'];
+    blockUsers: Scalars['Boolean'];
+    createFavoriteListV2: Scalars['ID'];
+    createFavorites: Scalars['ID'];
+    createGallery: Scalars['ID'];
+    createGalleryV2: Scalars['ID'];
+    createNonce: Scalars['String'];
+    deleteGallery: Scalars['Boolean'];
+    deleteGalleryBanner: Scalars['Boolean'];
+    deleteIdentity: Scalars['Boolean'];
+    deleteUserpic: Scalars['Boolean'];
+    dislikeAsset: Scalars['Boolean'];
+    dislikeCollection: Scalars['Boolean'];
+    editGallery: Scalars['Boolean'];
+    followProfile: Scalars['Boolean'];
+    hideAsset: Scalars['Boolean'];
+    hideAssets: Scalars['Boolean'];
+    hideBannerAsset: Scalars['Boolean'];
+    hideShowcaseAsset: Scalars['Boolean'];
+    likeAsset: Scalars['Boolean'];
+    likeCollection: Scalars['Boolean'];
+    refreshToken: ITokenPair;
+    rejectAssetReport: Scalars['Boolean'];
+    rejectAssetReports: Scalars['Boolean'];
+    rejectGalleryReport: Scalars['Boolean'];
+    rejectGalleryReports: Scalars['Boolean'];
+    rejectUserReport: Scalars['Boolean'];
+    rejectUserReports: Scalars['Boolean'];
+    removeAssetFromGallery: Scalars['Boolean'];
+    removeAssetFromGalleryV2: Scalars['Boolean'];
+    removeCollectionFromGallery: Scalars['Boolean'];
+    removeCollectionFromGalleryV2: Scalars['Boolean'];
+    removeCreationFromGallery: Scalars['Boolean'];
+    removeCreationFromGalleryV2: Scalars['Boolean'];
+    reportAsset: Scalars['Boolean'];
+    reportGallery: Scalars['Boolean'];
+    reportUser: Scalars['Boolean'];
+    restrictAsset: Scalars['Boolean'];
+    restrictAssets: Scalars['Boolean'];
+    restrictGalleries: Scalars['Boolean'];
+    restrictGallery: Scalars['Boolean'];
+    restrictUser: Scalars['Boolean'];
+    restrictUsers: Scalars['Boolean'];
+    revokeToken: Scalars['Boolean'];
+    saveUserExpectations: Scalars['Boolean'];
+    saveUserInterests: Scalars['Boolean'];
+    saveUserOffers: Scalars['Boolean'];
+    setDummy: Scalars['String'];
+    showAsset: Scalars['Boolean'];
+    showBannerAsset: Scalars['Boolean'];
+    showShowcaseAsset: Scalars['Boolean'];
+    signInAdminMetamask: IIdentity;
+    signInBitcoin: IIdentity;
+    signInElrond: IIdentity;
+    signInFlow: IIdentity;
+    signInMetamask: IIdentity;
+    signInNear: IIdentity;
+    signInSolana: IIdentity;
+    signInTerra: IIdentity;
+    signInTezos: IIdentity;
+    signInWalletConnect: IIdentity;
+    submitAsset: Scalars['Boolean'];
+    subscribeGallery: Scalars['Int'];
+    unfollowProfile: Scalars['Boolean'];
+    unsubscribeGallery: Scalars['Int'];
+    updateProfile: Scalars['Boolean'];
+    uploadGalleryBanner: Scalars['String'];
+    uploadUserpic: Scalars['String'];
+};
+export type IMutationAddAssetsToGalleryArgs = {
+    galleryId: Scalars['ID'];
+    assetIds: Array<Scalars['String']>;
+};
+export type IMutationAddAssetsToGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    assetIds: Array<Scalars['String']>;
+};
+export type IMutationAddCollectionsToGalleryArgs = {
+    galleryId: Scalars['ID'];
+    collectionIds: Array<Scalars['String']>;
+};
+export type IMutationAddCollectionsToGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    collectionIds: Array<Scalars['String']>;
+};
+export type IMutationAddCreationsToGalleryArgs = {
+    galleryId: Scalars['ID'];
+    creationIds: Array<Scalars['String']>;
+};
+export type IMutationAddCreationsToGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    creationIds: Array<Scalars['String']>;
+};
+export type IMutationAddWalletBitcoinArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationAddWalletElrondArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationAddWalletFlowArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationAddWalletMetamaskArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+};
+export type IMutationAddWalletNearArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationAddWalletSolanaArgs = {
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+};
+export type IMutationAddWalletTerraArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationAddWalletTezosArgs = {
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+};
+export type IMutationAddWalletWalletConnectArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+};
+export type IMutationApproveAssetArgs = {
+    assetId: Scalars['String'];
+};
+export type IMutationApproveAssetsArgs = {
+    assetIds: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationApproveUserArgs = {
+    userId: Scalars['ID'];
+};
+export type IMutationApproveUsersArgs = {
+    userIds: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationBlockUserArgs = {
+    userId: Scalars['ID'];
+    lockedFrom?: Maybe<Scalars['String']>;
+    lockedTo?: Maybe<Scalars['String']>;
+    forever: Scalars['Boolean'];
+};
+export type IMutationBlockUsersArgs = {
+    input: Array<Maybe<IUpdateUserModeration>>;
+};
+export type IMutationCreateFavoriteListV2Args = {
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export type IMutationCreateFavoritesArgs = {
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export type IMutationCreateGalleryArgs = {
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export type IMutationCreateGalleryV2Args = {
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export type IMutationCreateNonceArgs = {
+    address: Scalars['String'];
+    blockchain: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+};
+export type IMutationDeleteGalleryArgs = {
+    galleryId: Scalars['ID'];
+};
+export type IMutationDeleteGalleryBannerArgs = {
+    galleryId: Scalars['ID'];
+};
+export type IMutationDeleteIdentityArgs = {
+    deleteReason: Scalars['String'];
+    comment?: Maybe<Scalars['String']>;
+};
+export type IMutationDislikeAssetArgs = {
+    assetId: Scalars['String'];
+};
+export type IMutationDislikeCollectionArgs = {
+    collectionId: Scalars['String'];
+};
+export type IMutationEditGalleryArgs = {
+    galleryId: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    customUrl?: Maybe<Scalars['String']>;
+};
+export type IMutationFollowProfileArgs = {
+    followingUserId: Scalars['ID'];
+};
+export type IMutationHideAssetArgs = {
+    assetId: Scalars['String'];
+    blurred: Scalars['Boolean'];
+    locationsToHide: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationHideAssetsArgs = {
+    input: Array<Maybe<IUpdateAssetModeration>>;
+};
+export type IMutationHideBannerAssetArgs = {
+    id: Scalars['String'];
+};
+export type IMutationHideShowcaseAssetArgs = {
+    id: Scalars['String'];
+};
+export type IMutationLikeAssetArgs = {
+    assetId: Scalars['String'];
+};
+export type IMutationLikeCollectionArgs = {
+    collectionId: Scalars['String'];
+};
+export type IMutationRefreshTokenArgs = {
+    refreshToken: Scalars['String'];
+};
+export type IMutationRejectAssetReportArgs = {
+    reportId: Scalars['ID'];
+};
+export type IMutationRejectAssetReportsArgs = {
+    reportIds: Array<Maybe<Scalars['ID']>>;
+};
+export type IMutationRejectGalleryReportArgs = {
+    reportId: Scalars['ID'];
+};
+export type IMutationRejectGalleryReportsArgs = {
+    reportIds: Array<Maybe<Scalars['ID']>>;
+};
+export type IMutationRejectUserReportArgs = {
+    reportId: Scalars['ID'];
+};
+export type IMutationRejectUserReportsArgs = {
+    reportIds: Array<Maybe<Scalars['ID']>>;
+};
+export type IMutationRemoveAssetFromGalleryArgs = {
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+};
+export type IMutationRemoveAssetFromGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    assetId: Scalars['String'];
+};
+export type IMutationRemoveCollectionFromGalleryArgs = {
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+};
+export type IMutationRemoveCollectionFromGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    collectionId: Scalars['String'];
+};
+export type IMutationRemoveCreationFromGalleryArgs = {
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+};
+export type IMutationRemoveCreationFromGalleryV2Args = {
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+};
+export type IMutationReportAssetArgs = {
+    assetId: Scalars['String'];
+    reason: ISelectionInput;
+};
+export type IMutationReportGalleryArgs = {
+    galleryId: Scalars['String'];
+    reason: ISelectionInput;
+};
+export type IMutationReportUserArgs = {
+    userId: Scalars['ID'];
+    reason: ISelectionInput;
+};
+export type IMutationRestrictAssetArgs = {
+    reportId: Scalars['ID'];
+    locationsToShow: Array<Maybe<Scalars['String']>>;
+    blurred: Scalars['Boolean'];
+};
+export type IMutationRestrictAssetsArgs = {
+    input: Array<Maybe<IAssetReportRestriction>>;
+};
+export type IMutationRestrictGalleriesArgs = {
+    input: Array<Maybe<IGalleryReportRestriction>>;
+};
+export type IMutationRestrictGalleryArgs = {
+    reportId: Scalars['ID'];
+    locationsToShow: Array<Maybe<Scalars['String']>>;
+    blurred: Scalars['Boolean'];
+};
+export type IMutationRestrictUserArgs = {
+    reportId: Scalars['ID'];
+    lockedFrom?: Maybe<Scalars['String']>;
+    lockedTo?: Maybe<Scalars['String']>;
+    forever: Scalars['Boolean'];
+};
+export type IMutationRestrictUsersArgs = {
+    input: Array<Maybe<IUserReportRestriction>>;
+};
+export type IMutationSaveUserExpectationsArgs = {
+    expectations: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationSaveUserInterestsArgs = {
+    interests: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationSaveUserOffersArgs = {
+    offers: Array<Maybe<Scalars['String']>>;
+};
+export type IMutationShowAssetArgs = {
+    assetId: Scalars['String'];
+};
+export type IMutationShowBannerAssetArgs = {
+    id: Scalars['String'];
+};
+export type IMutationShowShowcaseAssetArgs = {
+    id: Scalars['String'];
+};
+export type IMutationSignInAdminMetamaskArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+};
+export type IMutationSignInBitcoinArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInElrondArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInFlowArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInMetamaskArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInNearArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInSolanaArgs = {
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInTerraArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInTezosArgs = {
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSignInWalletConnectArgs = {
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    restore?: Maybe<Scalars['Boolean']>;
+};
+export type IMutationSubmitAssetArgs = {
+    address: Scalars['String'];
+};
+export type IMutationSubscribeGalleryArgs = {
+    galleryId: Scalars['ID'];
+};
+export type IMutationUnfollowProfileArgs = {
+    followingUserId: Scalars['ID'];
+};
+export type IMutationUnsubscribeGalleryArgs = {
+    galleryId: Scalars['ID'];
+};
+export type IMutationUpdateProfileArgs = {
+    profile?: Maybe<IInputProfile>;
+};
+export type IMutationUploadGalleryBannerArgs = {
+    galleryId: Scalars['ID'];
+    file: Scalars['Upload'];
+};
+export type IMutationUploadUserpicArgs = {
+    file: Scalars['Upload'];
+};
+export type IOffer = {
+    floorDifference?: Maybe<Scalars['Float']>;
+    from?: Maybe<IWallet>;
+    image: Scalars['String'];
+    name: Scalars['String'];
+    price?: Maybe<Scalars['Float']>;
+    status?: Maybe<Scalars['String']>;
+};
+export type IProfile = {
+    about?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    deleted?: Maybe<Scalars['Boolean']>;
+    deletedAt?: Maybe<Scalars['Long']>;
+    followers?: Maybe<Scalars['Int']>;
+    following?: Maybe<Scalars['Boolean']>;
+    followings?: Maybe<Scalars['Int']>;
+    profileId?: Maybe<Scalars['String']>;
+    rank?: Maybe<Scalars['Float']>;
+    showNsfw?: Maybe<Scalars['Boolean']>;
+    social?: Maybe<ISocial>;
+    userId: Scalars['ID'];
+    username?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    views?: Maybe<Scalars['Int']>;
+    visible?: Maybe<Scalars['Boolean']>;
+    wallet?: Maybe<Scalars['String']>;
+    wallets?: Maybe<Array<Maybe<IWallet>>>;
+    website?: Maybe<Scalars['String']>;
+};
+export type IProfilePage = {
+    nextPageToken?: Maybe<Scalars['String']>;
+    profiles: Array<Maybe<IProfile>>;
+};
+export type IQuery = {
+    fetchAllAssets: IAssetsPage;
+    fetchAllBannerAssets: IBannerAssetsPage;
+    fetchAllMarkets: IMarketsPage;
+    fetchAllShowcaseAssets: IShowcaseAssetsPage;
+    fetchAllShowcaseItems: IShowcaseItemsPage;
+    fetchAsset: IAsset;
+    fetchAssetByBlockchain: IAsset;
+    fetchAssetModeration: IAssetModeration;
+    fetchAssetModerationStatuses: Array<Maybe<ISelection>>;
+    fetchAssetModerations: IAssetModerationsPage;
+    /** This query is not connected to the front */
+    fetchAssetNamesSuggestions: Array<Maybe<Scalars['String']>>;
+    fetchAssetReports: IAssetReportsPage;
+    fetchAssets: Array<Maybe<IAsset>>;
+    /** This query must be used on the first page */
+    fetchAssetsCount: Scalars['Long'];
+    fetchBannerAssets: Array<Maybe<IBannerAsset>>;
+    fetchBlockchainSelections: Array<Maybe<ISelection>>;
+    fetchCategorySelections: Array<Maybe<ISelection>>;
+    fetchCollection: ICollection;
+    fetchCollectionAssets: ICollectionAssetsPage;
+    fetchCollections: ICollectionsPage;
+    fetchCollectionsByIds: Array<ICollection>;
+    fetchCreation: ICreation;
+    fetchCreations: ICreationsPage;
+    fetchCreationsByItemType: ICreationsPage;
+    fetchDynamicAssetData: IDynamicAssetData;
+    fetchDynamicAssetsData: Array<Maybe<IDynamicAssetData>>;
+    fetchDynamicCollectionData: IDynamicCollectionData;
+    fetchDynamicCollectionsData: Array<IDynamicCollectionData>;
+    fetchExpectations: Array<Maybe<IExpectation>>;
+    fetchFavorites: IGalleriesPage;
+    fetchFavoritesV2: IGalleriesPageV2;
+    fetchFollowers: Array<Maybe<IFollower>>;
+    fetchFollowings: Array<Maybe<IFollower>>;
+    fetchGalleries: IGalleriesPage;
+    fetchGalleriesV2: IGalleriesPageV2;
+    fetchGallery: IGallery;
+    fetchGalleryAssets: IAssetsPage;
+    fetchGalleryCreations: IGalleryCreationsPage;
+    fetchGalleryReports: IGalleryReportsPage;
+    fetchGalleryV2: IGalleryV2;
+    fetchInterests: Array<Maybe<IInterest>>;
+    fetchLiked: Scalars['Boolean'];
+    fetchLikes: Scalars['Int'];
+    fetchLogins: ILoginsPage;
+    fetchMarket: IMarket;
+    fetchMyFavorites: IGalleriesPage;
+    fetchMyFavoritesV2: IGalleriesPageV2;
+    fetchMyGalleries: IGalleriesPage;
+    fetchMyGalleriesV2: IGalleriesPageV2;
+    fetchOffers: Array<Maybe<IOffer>>;
+    fetchPlaceSelections: Array<Maybe<ISelection>>;
+    fetchProfile: IProfile;
+    fetchProfileDeleteSelections: Array<Maybe<ISelection>>;
+    fetchRateSelections: Array<Maybe<ISelection>>;
+    fetchReportReasonSelections: Array<Maybe<ISelection>>;
+    fetchReportStatusSelections: Array<Maybe<ISelection>>;
+    fetchSearchResultBlockchainSelections: Array<Maybe<ISelection>>;
+    fetchSearchResultCategorySelections: Array<Maybe<ISelection>>;
+    fetchSearchResultStatusSelections: Array<Maybe<ISelection>>;
+    fetchSearchResultTimeSelections: Array<Maybe<ISelection>>;
+    fetchSearchResultTypeSelections: Array<Maybe<ISelection>>;
+    fetchSearchSortSelections: Array<Maybe<ISelection>>;
+    fetchSetsSearchResultTypeSelections: Array<Maybe<ISelection>>;
+    fetchShowcaseAssets: IShowcaseAssetsPage;
+    fetchShowcaseItems: IShowcaseItemsPage;
+    fetchSortSelections: Array<Maybe<ISelection>>;
+    fetchSubscribedGalleries: IGalleriesPage;
+    fetchUserExpectations: Array<Maybe<IUserExpectation>>;
+    fetchUserFavorites: IGalleriesPage;
+    fetchUserFavoritesV2: IGalleriesPageV2;
+    fetchUserGalleries: IGalleriesPage;
+    fetchUserGalleriesV2: IGalleriesPageV2;
+    fetchUserInterests: Array<Maybe<IUserInterest>>;
+    fetchUserModeration: IUserModeration;
+    fetchUserModerationStatuses: Array<Maybe<ISelection>>;
+    fetchUserModerations: IUserModerationsPage;
+    fetchUserOffers: Array<Maybe<IUserOffer>>;
+    fetchUserPortfolio: Array<Maybe<ICurrencyAmountPair>>;
+    fetchUserReports: IUserReportsPage;
+    fetchUserWallets: Array<Maybe<IWallet>>;
+    fetchUserpic?: Maybe<Scalars['String']>;
+    fetchVarietyOfAddressSelections: Array<Maybe<ISelection>>;
+    fetchWalletSelections: Array<Maybe<ISelection>>;
+    fetchWallets: Array<Maybe<IWallet>>;
+    /** This query should be changed according to new design */
+    findAllAssetsByName: IAssetPage;
+    /** This query should be changed according to new design */
+    findAllAssetsByOwner: IAssetPage;
+    /** This query should be changed according to new design */
+    findAllAssetsByTerm: IAssetPage;
+    /** This query should be changed according to new design */
+    findAllGalleriesByName: IGalleryPage;
+    /** This query should be changed according to new design */
+    findAllGalleriesByTerm: IGalleryPage;
+    findAllTopEntitiesByName: ITopEntitiesPage;
+    findAllTopEntitiesByTerm: ITopEntitiesPage;
+    /** This query should be changed according to new design */
+    findAssetsByName: IAssetPage;
+    /** This query should be changed according to new design */
+    findAssetsByOwner: IAssetPage;
+    /** This query should be changed according to new design */
+    findAssetsByTerm: IAssetPage;
+    findCollections: ICollectionPage;
+    /** This query should be changed according to new design */
+    findCollectionsByTitle: ICollectionPage;
+    findCreations: ICreationsPage;
+    /** This query should be changed according to new design */
+    findGalleriesByName: IGalleryPage;
+    /** This query should be changed according to new design */
+    findGalleriesByTerm: IGalleryPage;
+    /** This query should be changed according to new design */
+    findProfilesByName: IProfilePage;
+    /** This query should be changed according to new design */
+    findProfilesByTerm: IProfilePage;
+    findSets: IGalleryPage;
+    findShowcaseItems: IShowcaseItemPage;
+    /** These queries are used for search suggestions */
+    findTopEntitiesByName: ITopEntitiesPage;
+    findTopEntitiesByTerm: ITopEntitiesPage;
+    findUserCreations: ICreationsPage;
+    findUserFavoriteLists: IGalleryPage;
+    findUserGalleries: IGalleryPage;
+    findUserShowcaseItems: IShowcaseItemPage;
+    getDummy: Scalars['String'];
+    isValidAuthToken: Scalars['Boolean'];
+};
+export type IQueryFetchAllAssetsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAllBannerAssetsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAllMarketsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAllShowcaseAssetsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAllShowcaseItemsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAssetArgs = {
+    assetId: Scalars['String'];
+};
+export type IQueryFetchAssetByBlockchainArgs = {
+    blockchain: Scalars['String'];
+    address?: Maybe<Scalars['String']>;
+    tokenId?: Maybe<Scalars['String']>;
+    elrondId?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAssetModerationArgs = {
+    assetId: Scalars['String'];
+};
+export type IQueryFetchAssetModerationsArgs = {
+    input: IAssetModerationFilter;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAssetNamesSuggestionsArgs = {
+    term: Scalars['String'];
+};
+export type IQueryFetchAssetReportsArgs = {
+    input: IAssetReportFilter;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchAssetsArgs = {
+    assetIds: Array<Scalars['String']>;
+};
+export type IQueryFetchBannerAssetsArgs = {
+    pageSize: Scalars['Int'];
+};
+export type IQueryFetchCollectionArgs = {
+    collectionId: Scalars['String'];
+};
+export type IQueryFetchCollectionAssetsArgs = {
+    collectionId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchCollectionsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchCollectionsByIdsArgs = {
+    collectionIds: Array<Scalars['String']>;
+};
+export type IQueryFetchCreationArgs = {
+    id: Scalars['String'];
+};
+export type IQueryFetchCreationsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchCreationsByItemTypeArgs = {
+    itemType: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchDynamicAssetDataArgs = {
+    assetId: Scalars['String'];
+};
+export type IQueryFetchDynamicAssetsDataArgs = {
+    assetIds: Array<Scalars['String']>;
+};
+export type IQueryFetchDynamicCollectionDataArgs = {
+    input: IDynamicCollectionDataInput;
+};
+export type IQueryFetchDynamicCollectionsDataArgs = {
+    input: Array<IDynamicCollectionDataInput>;
+};
+export type IQueryFetchFavoritesArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchFavoritesV2Args = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchFollowersArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFetchFollowingsArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFetchGalleriesArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchGalleriesV2Args = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchGalleryArgs = {
+    galleryId: Scalars['String'];
+};
+export type IQueryFetchGalleryAssetsArgs = {
+    galleryId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchGalleryCreationsArgs = {
+    galleryId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchGalleryReportsArgs = {
+    input: IGalleryReportFilter;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchGalleryV2Args = {
+    galleryId: Scalars['String'];
+};
+export type IQueryFetchLikedArgs = {
+    assetId: Scalars['String'];
+};
+export type IQueryFetchLikesArgs = {
+    assetId: Scalars['String'];
+};
+export type IQueryFetchLoginsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchMarketArgs = {
+    marketId: Scalars['String'];
+};
+export type IQueryFetchMyFavoritesArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchMyFavoritesV2Args = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchMyGalleriesArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchMyGalleriesV2Args = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchProfileArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFetchShowcaseAssetsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchShowcaseItemsArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchSubscribedGalleriesArgs = {
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchUserFavoritesArgs = {
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchUserFavoritesV2Args = {
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchUserGalleriesArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    userId: Scalars['ID'];
+};
+export type IQueryFetchUserGalleriesV2Args = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    userId: Scalars['ID'];
+};
+export type IQueryFetchUserModerationArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFetchUserModerationsArgs = {
+    input: IUserModerationFilter;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchUserPortfolioArgs = {
+    ownerId: Scalars['String'];
+};
+export type IQueryFetchUserReportsArgs = {
+    input: IUserReportFilter;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFetchUserWalletsArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFetchUserpicArgs = {
+    userId: Scalars['ID'];
+};
+export type IQueryFindAllAssetsByNameArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAllAssetsByOwnerArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAllAssetsByTermArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAllGalleriesByNameArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAllGalleriesByTermArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAllTopEntitiesByNameArgs = {
+    name: Scalars['String'];
+    pageSize: Scalars['Int'];
+};
+export type IQueryFindAllTopEntitiesByTermArgs = {
+    pageSize: Scalars['Int'];
+    term: Scalars['String'];
+};
+export type IQueryFindAssetsByNameArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAssetsByOwnerArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindAssetsByTermArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindCollectionsArgs = {
+    term: Scalars['String'];
+    input: ICollectionFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindCollectionsByTitleArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindCreationsArgs = {
+    input: ICreationFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    term: Scalars['String'];
+};
+export type IQueryFindGalleriesByNameArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindGalleriesByTermArgs = {
+    input: ISearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindProfilesByNameArgs = {
+    name: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindProfilesByTermArgs = {
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    term: Scalars['String'];
+};
+export type IQueryFindSetsArgs = {
+    term: Scalars['String'];
+    input: IGallerySearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindShowcaseItemsArgs = {
+    input: IShowcaseItemFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    term: Scalars['String'];
+};
+export type IQueryFindTopEntitiesByNameArgs = {
+    name: Scalars['String'];
+    pageSize: Scalars['Int'];
+};
+export type IQueryFindTopEntitiesByTermArgs = {
+    pageSize: Scalars['Int'];
+    term: Scalars['String'];
+};
+export type IQueryFindUserCreationsArgs = {
+    input: ICreationFilterInput;
+    ownerId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindUserFavoriteListsArgs = {
+    ownerId: Scalars['String'];
+    input: IGalleryProfileFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindUserGalleriesArgs = {
+    ownerId: Scalars['String'];
+    input: IGalleryProfileFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryFindUserShowcaseItemsArgs = {
+    input: IShowcaseItemFilterInput;
+    ownerId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+};
+export type IQueryIsValidAuthTokenArgs = {
+    authToken: Scalars['String'];
+};
+export type ISearchFilterInput = {
+    categories?: Maybe<Array<Maybe<ISelectionInput>>>;
+    sort: ISelectionInput;
+    word: Scalars['String'];
+};
+export type ISelection = {
+    id: Scalars['String'];
+    ordering: Scalars['Int'];
+    label: Scalars['String'];
+};
+export type ISelectionInput = {
+    id: Scalars['String'];
+    label?: Maybe<Scalars['String']>;
+};
+export type IShowcaseAsset = {
+    assetId: Scalars['String'];
+    blockchain?: Maybe<Scalars['String']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    liked?: Maybe<Scalars['Boolean']>;
+    likes?: Maybe<Scalars['Int']>;
+    media?: Maybe<Scalars['String']>;
+    mediaPreview?: Maybe<Scalars['String']>;
+    mimeType?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    sizeRatio?: Maybe<Scalars['Float']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type IShowcaseAssetsPage = {
+    assets?: Maybe<Array<Maybe<IShowcaseAsset>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IShowcaseItem = {
+    blockchain?: Maybe<Scalars['String']>;
+    blurred?: Maybe<Scalars['Boolean']>;
+    creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    fileSize?: Maybe<Scalars['Long']>;
+    itemId: Scalars['String'];
+    itemType: Scalars['String'];
+    likes?: Maybe<Scalars['Int']>;
+    media?: Maybe<Scalars['String']>;
+    mediaPreview?: Maybe<Scalars['String']>;
+    mimeType?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    nsfw?: Maybe<Scalars['Int']>;
+    ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+    sizeRatio?: Maybe<Scalars['Float']>;
+    visible?: Maybe<Scalars['Boolean']>;
+};
+export type IShowcaseItemFilterInput = {
+    blockchain: Scalars['String'];
+    category: Scalars['String'];
+    nsfw?: Maybe<Scalars['Int']>;
+    status: Scalars['String'];
+    time: Scalars['String'];
+    type: Scalars['String'];
+};
+export type IShowcaseItemPage = {
+    nextPageToken?: Maybe<Scalars['String']>;
+    results?: Maybe<Scalars['Long']>;
+    showcaseItems: Array<Maybe<IShowcaseItem>>;
+};
+export type IShowcaseItemsPage = {
+    showcaseItems?: Maybe<Array<Maybe<IShowcaseItem>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type ISocial = {
+    facebook?: Maybe<Scalars['String']>;
+    twitter?: Maybe<Scalars['String']>;
+    instagram?: Maybe<Scalars['String']>;
+    website?: Maybe<Scalars['String']>;
+};
+export type ITestResponse = {
+    name?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+    test?: Maybe<Scalars['String']>;
+};
+export type ITokenPair = {
+    userId?: Maybe<Scalars['ID']>;
+    tokenAuth?: Maybe<Scalars['String']>;
+    tokenRefresh?: Maybe<Scalars['String']>;
+    role?: Maybe<Scalars['String']>;
+};
+export type ITopEntitiesPage = {
+    assets: Array<Maybe<IAsset>>;
+    collections: Array<Maybe<ICollection>>;
+    profiles: Array<Maybe<IProfile>>;
+};
+export type ITrait = {
+    name?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+    rarity?: Maybe<Scalars['Float']>;
+};
+export type IUpdateAssetModeration = {
+    assetId: Scalars['String'];
+    locationsToHide: Array<Maybe<Scalars['String']>>;
+    blurred: Scalars['Boolean'];
+};
+export type IUpdateUserModeration = {
+    userId: Scalars['ID'];
+    lockedFrom?: Maybe<Scalars['String']>;
+    lockedTo?: Maybe<Scalars['String']>;
+    forever: Scalars['Boolean'];
+};
+export type IUserExpectation = {
+    userId: Scalars['ID'];
+    name: Scalars['String'];
+    imageUrl: Scalars['String'];
+};
+export type IUserInterest = {
+    userId: Scalars['String'];
+    name: Scalars['String'];
+    imageUrl: Scalars['String'];
+    percents?: Maybe<Scalars['Int']>;
+};
+export type IUserModeration = {
+    userId: Scalars['ID'];
+    status?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    lockedFrom?: Maybe<Scalars['Long']>;
+    lockedTo?: Maybe<Scalars['Long']>;
+    deletedOn?: Maybe<Scalars['Long']>;
+    username?: Maybe<Scalars['String']>;
+    website?: Maybe<Scalars['String']>;
+    about?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    profileLink?: Maybe<Scalars['String']>;
+    wallets?: Maybe<Array<Maybe<IUserWallet>>>;
+};
+export type IUserModerationFilter = {
+    username?: Maybe<Scalars['String']>;
+    wallet?: Maybe<Array<Maybe<ISelectionInput>>>;
+    status?: Maybe<Array<Maybe<ISelectionInput>>>;
+    sort: ISelectionInput;
+    dateFrom?: Maybe<Scalars['String']>;
+    dateTo?: Maybe<Scalars['String']>;
+};
+export type IUserModerationsPage = {
+    userModerations?: Maybe<Array<Maybe<IUserModeration>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IUserOffer = {
+    userId: Scalars['ID'];
+    name: Scalars['String'];
+};
+export type IUserReport = {
+    reportId: Scalars['ID'];
+    type?: Maybe<Scalars['String']>;
+    status?: Maybe<Scalars['String']>;
+    issuerProfile?: Maybe<IProfile>;
+    issuerAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    offenderProfile?: Maybe<IProfile>;
+    offenderAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+    reason?: Maybe<Scalars['String']>;
+    link?: Maybe<Scalars['String']>;
+    reportedAt?: Maybe<Scalars['Long']>;
+    entityStatus?: Maybe<Scalars['String']>;
+    lockedFrom?: Maybe<Scalars['Long']>;
+    lockedTo?: Maybe<Scalars['Long']>;
+    deletedOn?: Maybe<Scalars['Long']>;
+    username?: Maybe<Scalars['String']>;
+    website?: Maybe<Scalars['String']>;
+    about?: Maybe<Scalars['String']>;
+    userpic?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    profileLink?: Maybe<Scalars['String']>;
+    wallets?: Maybe<Array<Maybe<IUserWallet>>>;
+    rank?: Maybe<Scalars['Float']>;
+};
+export type IUserReportFilter = {
+    name?: Maybe<Scalars['String']>;
+    address?: Maybe<Scalars['String']>;
+    status?: Maybe<Array<Maybe<ISelectionInput>>>;
+    reason?: Maybe<Array<Maybe<ISelectionInput>>>;
+    sort: ISelectionInput;
+    dateFrom?: Maybe<Scalars['String']>;
+    dateTo?: Maybe<Scalars['String']>;
+};
+export type IUserReportRestriction = {
+    reportId: Scalars['ID'];
+    lockedFrom?: Maybe<Scalars['String']>;
+    lockedTo?: Maybe<Scalars['String']>;
+    forever: Scalars['Boolean'];
+};
+export type IUserReportsPage = {
+    userReports?: Maybe<Array<Maybe<IUserReport>>>;
+    nextPageToken?: Maybe<Scalars['String']>;
+};
+export type IUserWallet = {
+    address?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    chainId?: Maybe<Scalars['String']>;
+    userId?: Maybe<Scalars['ID']>;
+    walletName?: Maybe<Scalars['String']>;
+};
+export type IWallet = {
+    address: Scalars['String'];
+    blockchain: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['String']>;
+    userId: Scalars['ID'];
+    walletName: Scalars['String'];
+};
+export type IDislikeAssetMutationVariables = Exact<{
+    assetId: Scalars['String'];
+}>;
+export type IDislikeAssetMutation = Pick<IMutation, 'dislikeAsset'>;
+export type ILikeAssetMutationVariables = Exact<{
+    assetId: Scalars['String'];
+}>;
+export type ILikeAssetMutation = Pick<IMutation, 'likeAsset'>;
+export type IFetchAssetQueryVariables = Exact<{
+    assetId: Scalars['String'];
+}>;
+export type IFetchAssetQuery = {
+    fetchAsset: (Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'> & {
+        totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>;
+        collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+        medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'previewUrl'>>>>;
+        ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>>;
+    });
+};
+export type IFetchAssetByBlockchainQueryVariables = Exact<{
+    blockchain: Scalars['String'];
+    address?: Maybe<Scalars['String']>;
+    tokenId?: Maybe<Scalars['String']>;
+    elrondId?: Maybe<Scalars['String']>;
+}>;
+export type IFetchAssetByBlockchainQuery = {
+    fetchAssetByBlockchain: (Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'> & {
+        totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>;
+        collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+        medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'previewUrl' | 'sizeRatio' | 'fileSize'>>>>;
+        ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>>;
+    });
+};
+export type IFetchAssetsQueryVariables = Exact<{
+    assetIds: Array<Scalars['String']>;
+}>;
+export type IFetchAssetsQuery = {
+    fetchAssets: Array<Maybe<(Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'> & {
+        totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>;
+        collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+        medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'previewUrl'>>>>;
+        ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>;
+        attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>>;
+    })>>;
+};
+export type IFetchDynamicAssetLikesQueryVariables = Exact<{
+    assetId: Scalars['String'];
+}>;
+export type IFetchDynamicAssetLikesQuery = {
+    fetchDynamicAssetData: Pick<IDynamicAssetData, 'isLikedByUser' | 'likesNum'>;
+};
+export type IFetchDynamicAssetsLikesQueryVariables = Exact<{
+    assetIds: Array<Scalars['String']>;
+}>;
+export type IFetchDynamicAssetsLikesQuery = {
+    fetchDynamicAssetsData: Array<Maybe<Pick<IDynamicAssetData, 'isLikedByUser' | 'likesNum' | 'assetId'>>>;
+};
+export type IFetchLikedQueryVariables = Exact<{
+    assetId: Scalars['String'];
+}>;
+export type IFetchLikedQuery = Pick<IQuery, 'fetchLiked'>;
+export type IDislikeCollectionMutationVariables = Exact<{
+    collectionId: Scalars['String'];
+}>;
+export type IDislikeCollectionMutation = Pick<IMutation, 'dislikeCollection'>;
+export type ILikeCollectionMutationVariables = Exact<{
+    collectionId: Scalars['String'];
+}>;
+export type ILikeCollectionMutation = Pick<IMutation, 'likeCollection'>;
+export type IFetchCollectionQueryVariables = Exact<{
+    collectionId: Scalars['String'];
+}>;
+export type IFetchCollectionQuery = {
+    fetchCollection: (Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'collectionTitle' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank'> & {
+        totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        collectionMarkets?: Maybe<Array<Maybe<Pick<ICollectionMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>;
+        creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'username' | 'userpic'>>>>;
+        floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+    });
+};
+export type IFetchCollectionsQueryVariables = Exact<{
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+    collectionId: Scalars['String'];
+}>;
+export type IFetchCollectionsQuery = {
+    fetchCollectionAssets: (Pick<ICollectionAssetsPage, 'nextPageToken'> & {
+        collectionAssets?: Maybe<Array<Maybe<(Pick<ICollectionAsset, 'collectionId' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'chainId' | 'creatorsAddresses' | 'originalUrls' | 'name' | 'description' | 'likes' | 'liked' | 'views' | 'visible' | 'createdAt' | 'blurred' | 'rank'> & {
+            medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+        })>>>;
+    });
+};
+export type IFetchCollectionsByIdsQueryVariables = Exact<{
+    collectionIds: Array<Scalars['String']>;
+}>;
+export type IFetchCollectionsByIdsQuery = {
+    fetchCollectionsByIds: Array<(Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'collectionTitle' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank'> & {
+        totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        collectionMarkets?: Maybe<Array<Maybe<Pick<ICollectionMarket, 'marketName' | 'marketDomain' | 'marketUrl'>>>>;
+        creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'username' | 'userpic'>>>>;
+        floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+    })>;
+};
+export type IFetchDynamicCollectionDataQueryVariables = Exact<{
+    input: IDynamicCollectionDataInput;
+}>;
+export type IFetchDynamicCollectionDataQuery = {
+    fetchDynamicCollectionData: (Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'> & {
+        collectionAssetsPage?: Maybe<(Pick<ICollectionAssetsPage, 'nextPageToken'> & {
+            collectionAssets?: Maybe<Array<Maybe<(Pick<ICollectionAsset, 'collectionId' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'chainId' | 'creatorsAddresses' | 'originalUrls' | 'name' | 'description' | 'likes' | 'liked' | 'views' | 'visible' | 'createdAt' | 'blurred' | 'rank'> & {
+                medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+            })>>>;
+        })>;
+    });
+};
+export type IFetchDynamicCollectionsDataQueryVariables = Exact<{
+    input: Array<IDynamicCollectionDataInput>;
+}>;
+export type IFetchDynamicCollectionsDataQuery = {
+    fetchDynamicCollectionsData: Array<(Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'> & {
+        collectionAssetsPage?: Maybe<(Pick<ICollectionAssetsPage, 'nextPageToken'> & {
+            collectionAssets?: Maybe<Array<Maybe<(Pick<ICollectionAsset, 'collectionId' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'chainId' | 'creatorsAddresses' | 'originalUrls' | 'name' | 'description' | 'likes' | 'liked' | 'views' | 'visible' | 'createdAt' | 'blurred' | 'rank'> & {
+                medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+            })>>>;
+        })>;
+    })>;
+};
+export type IAddAssetsToGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    assetIds: Array<Scalars['String']>;
+}>;
+export type IAddAssetsToGalleryMutation = Pick<IMutation, 'addAssetsToGallery'>;
+export type IAddAssetsToGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    assetIds: Array<Scalars['String']>;
+}>;
+export type IAddAssetsToGalleryV2Mutation = Pick<IMutation, 'addAssetsToGalleryV2'>;
+export type IUploadGalleryBannerMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    file: Scalars['Upload'];
+}>;
+export type IUploadGalleryBannerMutation = Pick<IMutation, 'uploadGalleryBanner'>;
+export type IAddCollectionsToGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    collectionIds: Array<Scalars['String']>;
+}>;
+export type IAddCollectionsToGalleryMutation = Pick<IMutation, 'addCollectionsToGallery'>;
+export type IAddCollectionsToGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    collectionIds: Array<Scalars['String']>;
+}>;
+export type IAddCollectionsToGalleryV2Mutation = Pick<IMutation, 'addCollectionsToGalleryV2'>;
+export type IAddCreationsToGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationIds: Array<Scalars['String']>;
+}>;
+export type IAddCreationsToGalleryMutation = Pick<IMutation, 'addCreationsToGallery'>;
+export type IAddCreationsToGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationIds: Array<Scalars['String']>;
+}>;
+export type IAddCreationsToGalleryV2Mutation = Pick<IMutation, 'addCreationsToGalleryV2'>;
+export type ICreateFavoriteListV2MutationVariables = Exact<{
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+}>;
+export type ICreateFavoriteListV2Mutation = Pick<IMutation, 'createFavoriteListV2'>;
+export type ICreateFavoritesMutationVariables = Exact<{
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+}>;
+export type ICreateFavoritesMutation = Pick<IMutation, 'createFavorites'>;
+export type ICreateGalleryMutationVariables = Exact<{
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+}>;
+export type ICreateGalleryMutation = Pick<IMutation, 'createGallery'>;
+export type ICreateGalleryV2MutationVariables = Exact<{
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    publicAccessible?: Maybe<Scalars['Boolean']>;
+    creationIds?: Maybe<Array<Maybe<Scalars['String']>>>;
+}>;
+export type ICreateGalleryV2Mutation = Pick<IMutation, 'createGalleryV2'>;
+export type IDeleteGalleryBannerMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+}>;
+export type IDeleteGalleryBannerMutation = Pick<IMutation, 'deleteGalleryBanner'>;
+export type IEditGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+}>;
+export type IEditGalleryMutation = Pick<IMutation, 'editGallery'>;
+export type IRemoveAssetFromGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+}>;
+export type IRemoveAssetFromGalleryMutation = Pick<IMutation, 'removeAssetFromGallery'>;
+export type IRemoveAssetFromGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    assetId: Scalars['String'];
+}>;
+export type IRemoveAssetFromGalleryV2Mutation = Pick<IMutation, 'removeAssetFromGalleryV2'>;
+export type IRemoveCollectionFromGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+}>;
+export type IRemoveCollectionFromGalleryMutation = Pick<IMutation, 'removeCollectionFromGallery'>;
+export type IRemoveCollectionFromGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    collectionId: Scalars['String'];
+}>;
+export type IRemoveCollectionFromGalleryV2Mutation = Pick<IMutation, 'removeCollectionFromGalleryV2'>;
+export type IRemoveCreationFromGalleryMutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+}>;
+export type IRemoveCreationFromGalleryMutation = Pick<IMutation, 'removeCreationFromGallery'>;
+export type IRemoveCreationFromGalleryV2MutationVariables = Exact<{
+    galleryId: Scalars['ID'];
+    creationId: Scalars['String'];
+}>;
+export type IRemoveCreationFromGalleryV2Mutation = Pick<IMutation, 'removeCreationFromGalleryV2'>;
+export type IFetchGalleryQueryVariables = Exact<{
+    galleryId: Scalars['String'];
+}>;
+export type IFetchGalleryQuery = {
+    fetchGallery: Pick<IGallery, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw'>;
+};
+export type IFetchGalleryCreationsQueryVariables = Exact<{
+    galleryId: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchGalleryCreationsQuery = {
+    fetchGalleryCreations: (Pick<IGalleryCreationsPage, 'nextPageToken'> & {
+        galleryCreations: Array<Maybe<(Pick<IGalleryCreation, 'galleryId' | 'creationId' | 'address' | 'tokenId' | 'itemId' | 'itemType' | 'itemOrder' | 'galleryName' | 'blockchain' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+            prices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        })>>;
+    });
+};
+export type IFetchGalleryV2QueryVariables = Exact<{
+    galleryId: Scalars['String'];
+}>;
+export type IFetchGalleryV2Query = {
+    fetchGalleryV2: Pick<IGalleryV2, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw' | 'creationIds'>;
+};
+export type IFetchMyFavoritesQueryVariables = Exact<{
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchMyFavoritesQuery = {
+    fetchMyFavorites: (Pick<IGalleriesPage, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<(Pick<IGallery, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw'> & {
+            galleryCreations?: Maybe<Array<Maybe<(Pick<IGalleryCreation, 'galleryId' | 'creationId' | 'itemId' | 'itemType' | 'itemOrder' | 'galleryName' | 'blockchain' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+                prices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+            })>>>;
+        })>>>;
+    });
+};
+export type IFetchMyFavoritesV2QueryVariables = Exact<{
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchMyFavoritesV2Query = {
+    fetchMyFavoritesV2: (Pick<IGalleriesPageV2, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<Pick<IGalleryV2, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw' | 'creationIds'>>>>;
+    });
+};
+export type IFetchUserFavoritesQueryVariables = Exact<{
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchUserFavoritesQuery = {
+    fetchUserFavorites: (Pick<IGalleriesPage, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<(Pick<IGallery, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw'> & {
+            userWallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>>;
+            galleryCreations?: Maybe<Array<Maybe<(Pick<IGalleryCreation, 'galleryId' | 'creationId' | 'itemId' | 'itemType' | 'itemOrder' | 'galleryName' | 'blockchain' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+                prices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+            })>>>;
+        })>>>;
+    });
+};
+export type IFetchUserFavoritesV2QueryVariables = Exact<{
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchUserFavoritesV2Query = {
+    fetchUserFavoritesV2: (Pick<IGalleriesPageV2, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<(Pick<IGalleryV2, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw' | 'creationIds'> & {
+            userWallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>>;
+        })>>>;
+    });
+};
+export type IFetchUserGalleriesQueryVariables = Exact<{
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchUserGalleriesQuery = {
+    fetchUserGalleries: (Pick<IGalleriesPage, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<(Pick<IGallery, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw'> & {
+            userWallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>>;
+            galleryCreations?: Maybe<Array<Maybe<(Pick<IGalleryCreation, 'galleryId' | 'creationId' | 'itemId' | 'itemType' | 'itemOrder' | 'galleryName' | 'blockchain' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+                prices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+            })>>>;
+        })>>>;
+    });
+};
+export type IFetchUserGalleriesV2QueryVariables = Exact<{
+    userId: Scalars['ID'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchUserGalleriesV2Query = {
+    fetchUserGalleriesV2: (Pick<IGalleriesPageV2, 'nextPageToken'> & {
+        galleries?: Maybe<Array<Maybe<(Pick<IGalleryV2, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw' | 'creationIds'> & {
+            userWallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>>;
+        })>>>;
+    });
+};
+export type ISignInMetamaskMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    chainId: Scalars['String'];
+}>;
+export type ISignInMetamaskMutation = {
+    signInMetamask: Pick<IIdentity, 'userId' | 'wallets' | 'authToken' | 'refreshToken' | 'newUser'>;
+};
+export type IAddWalletElrondMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+}>;
+export type IAddWalletElrondMutation = Pick<IMutation, 'addWalletElrond'>;
+export type IAddWalletFlowMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+}>;
+export type IAddWalletFlowMutation = Pick<IMutation, 'addWalletFlow'>;
+export type IAddWalletMetamaskMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+    chainId: Scalars['String'];
+}>;
+export type IAddWalletMetamaskMutation = Pick<IMutation, 'addWalletMetamask'>;
+export type IAddWalletSolanaMutationVariables = Exact<{
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+}>;
+export type IAddWalletSolanaMutation = Pick<IMutation, 'addWalletSolana'>;
+export type IAddWalletTezosMutationVariables = Exact<{
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+}>;
+export type IAddWalletTezosMutation = Pick<IMutation, 'addWalletTezos'>;
+export type ICreateNonceMutationVariables = Exact<{
+    address: Scalars['String'];
+    blockchain: Scalars['String'];
+    chainId?: Maybe<Scalars['String']>;
+}>;
+export type ICreateNonceMutation = Pick<IMutation, 'createNonce'>;
+export type IRefreshTokenMutationVariables = Exact<{
+    refreshToken: Scalars['String'];
+}>;
+export type IRefreshTokenMutation = {
+    refreshToken: Pick<ITokenPair, 'userId' | 'tokenAuth' | 'tokenRefresh' | 'role'>;
+};
+export type IRevokeTokenMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IRevokeTokenMutation = Pick<IMutation, 'revokeToken'>;
+export type ISignInElrondMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+}>;
+export type ISignInElrondMutation = {
+    signInElrond: Pick<IIdentity, 'userId' | 'wallets' | 'authToken' | 'refreshToken' | 'newUser'>;
+};
+export type ISignInFlowMutationVariables = Exact<{
+    signature: Scalars['String'];
+    address: Scalars['String'];
+}>;
+export type ISignInFlowMutation = {
+    signInFlow: Pick<IIdentity, 'userId' | 'wallets' | 'authToken' | 'refreshToken' | 'newUser'>;
+};
+export type ISignInSolanaMutationVariables = Exact<{
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+}>;
+export type ISignInSolanaMutation = {
+    signInSolana: Pick<IIdentity, 'userId' | 'wallets' | 'authToken' | 'refreshToken' | 'newUser'>;
+};
+export type ISignInTezosMutationVariables = Exact<{
+    signature: Scalars['String'];
+    pubkey: Scalars['String'];
+}>;
+export type ISignInTezosMutation = {
+    signInTezos: Pick<IIdentity, 'userId' | 'wallets' | 'authToken' | 'refreshToken' | 'newUser'>;
+};
+export type IUpdateProfileMutationVariables = Exact<{
+    username?: Maybe<Scalars['String']>;
+    about?: Maybe<Scalars['String']>;
+    facebook?: Maybe<Scalars['String']>;
+    twitter?: Maybe<Scalars['String']>;
+    instagram?: Maybe<Scalars['String']>;
+    website?: Maybe<Scalars['String']>;
+    showNsfw?: Maybe<Scalars['Boolean']>;
+}>;
+export type IUpdateProfileMutation = Pick<IMutation, 'updateProfile'>;
+export type IFetchProfileQueryVariables = Exact<{
+    userId: Scalars['ID'];
+}>;
+export type IFetchProfileQuery = {
+    fetchProfile: (Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'following' | 'followings' | 'followers' | 'rank' | 'views' | 'createdAt' | 'deletedAt' | 'visible' | 'deleted' | 'showNsfw'> & {
+        social?: Maybe<Pick<ISocial, 'facebook' | 'twitter' | 'instagram' | 'website'>>;
+        wallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>>;
+    });
+};
+export type IFetchUserWalletsQueryVariables = Exact<{
+    userId: Scalars['ID'];
+}>;
+export type IFetchUserWalletsQuery = {
+    fetchUserWallets: Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>;
+};
+export type IFetchUserpicQueryVariables = Exact<{
+    userId: Scalars['ID'];
+}>;
+export type IFetchUserpicQuery = Pick<IQuery, 'fetchUserpic'>;
+export type ISaveUserExpectationsMutationVariables = Exact<{
+    expectations: Array<Maybe<Scalars['String']>>;
+}>;
+export type ISaveUserExpectationsMutation = Pick<IMutation, 'saveUserExpectations'>;
+export type ISaveUserInterestsMutationVariables = Exact<{
+    interests: Array<Maybe<Scalars['String']>>;
+}>;
+export type ISaveUserInterestsMutation = Pick<IMutation, 'saveUserInterests'>;
+export type IFetchExpectationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchExpectationsQuery = {
+    fetchExpectations: Array<Maybe<Pick<IExpectation, 'name' | 'imageUrl'>>>;
+};
+export type IFetchInterestsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchInterestsQuery = {
+    fetchInterests: Array<Maybe<Pick<IInterest, 'name' | 'imageUrl'>>>;
+};
+export type IFetchSearchResultTimeSelectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchSearchResultTimeSelectionsQuery = {
+    fetchSearchResultTimeSelections: Array<Maybe<Pick<ISelection, 'id' | 'label'>>>;
+};
+export type IFetchUserExpectationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchUserExpectationsQuery = {
+    fetchUserExpectations: Array<Maybe<Pick<IUserExpectation, 'userId' | 'name' | 'imageUrl'>>>;
+};
+export type IFetchUserInterestsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchUserInterestsQuery = {
+    fetchUserInterests: Array<Maybe<Pick<IUserInterest, 'userId' | 'name' | 'imageUrl' | 'percents'>>>;
+};
+export type IFetchSearchResultBlockchainSelectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchSearchResultBlockchainSelectionsQuery = {
+    fetchSearchResultBlockchainSelections: Array<Maybe<Pick<ISelection, 'id' | 'label'>>>;
+};
+export type IFetchSearchResultCategorySelectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchSearchResultCategorySelectionsQuery = {
+    fetchSearchResultCategorySelections: Array<Maybe<Pick<ISelection, 'id' | 'label'>>>;
+};
+export type IFetchSearchResultStatusSelectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchSearchResultStatusSelectionsQuery = {
+    fetchSearchResultStatusSelections: Array<Maybe<Pick<ISelection, 'id' | 'label'>>>;
+};
+export type IFetchSetsSearchResultTypeSelectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchSetsSearchResultTypeSelectionsQuery = {
+    fetchSetsSearchResultTypeSelections: Array<Maybe<Pick<ISelection, 'id' | 'label'>>>;
+};
+export type IFetchAssetsCountQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchAssetsCountQuery = Pick<IQuery, 'fetchAssetsCount'>;
+export type IFindCollectionsQueryVariables = Exact<{
+    term: Scalars['String'];
+    input: ICollectionFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindCollectionsQuery = {
+    findCollections: (Pick<ICollectionPage, 'nextPageToken' | 'results'> & {
+        collections: Array<Maybe<(Pick<ICollection, 'collectionId' | 'collectionTitle' | 'blockchain' | 'tokenId' | 'rank'> & {
+            medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>;
+        })>>;
+    });
+};
+export type IFetchCreationsQueryVariables = Exact<{
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchCreationsQuery = {
+    fetchCreations: (Pick<ICreationsPage, 'nextPageToken'> & {
+        creations?: Maybe<Array<Maybe<(Pick<ICreation, 'itemType' | 'itemId' | 'rank' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+            creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+            ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+        })>>>;
+    });
+};
+export type IFetchCreationsByItemTypeQueryVariables = Exact<{
+    itemType: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFetchCreationsByItemTypeQuery = {
+    fetchCreationsByItemType: (Pick<ICreationsPage, 'nextPageToken'> & {
+        creations?: Maybe<Array<Maybe<(Pick<ICreation, 'itemType' | 'itemId' | 'address' | 'tokenId' | 'blockchain' | 'name' | 'rank' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'views' | 'visible' | 'blurred'> & {
+            creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+            ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+        })>>>;
+    });
+};
+export type IFindAllTopEntitiesByNameQueryVariables = Exact<{
+    name: Scalars['String'];
+    pageSize: Scalars['Int'];
+}>;
+export type IFindAllTopEntitiesByNameQuery = {
+    findAllTopEntitiesByName: {
+        assets: Array<Maybe<(Pick<IAsset, 'assetId' | 'address' | 'tokenId' | 'blockchain' | 'chainId' | 'blockHeight' | 'blockTimestamp' | 'name' | 'description' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'likes' | 'views' | 'visible' | 'blurred' | 'rank' | 'rankRaw' | 'rankMax' | 'rankUpdatedAt'> & {
+            medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw'>>>>;
+            ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+            creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+            attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>>;
+        })>>;
+        collections: Array<Maybe<(Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'collectionTitle' | 'likes' | 'liked' | 'verified' | 'rank'> & {
+            totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+            floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>;
+        })>>;
+        profiles: Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>;
+    };
+};
+export type IFetchUserPortfolioQueryVariables = Exact<{
+    ownerId: Scalars['String'];
+}>;
+export type IFetchUserPortfolioQuery = {
+    fetchUserPortfolio: Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>;
+};
+export type IFindCreationsQueryVariables = Exact<{
+    term: Scalars['String'];
+    input: ICreationFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindCreationsQuery = {
+    findCreations: (Pick<ICreationsPage, 'nextPageToken' | 'results'> & {
+        creations?: Maybe<Array<Maybe<(Pick<ICreation, 'itemType' | 'address' | 'tokenId' | 'itemId' | 'blockchain' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'rank' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'liked' | 'views' | 'visible' | 'blurred'> & {
+            creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'views' | 'createdAt' | 'deletedAt' | 'visible' | 'deleted'>>>>;
+            ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followings' | 'followers' | 'views' | 'createdAt' | 'deletedAt' | 'visible' | 'deleted'>>>>;
+        })>>>;
+    });
+};
+export type IFindProfilesByNameQueryVariables = Exact<{
+    name: Scalars['String'];
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindProfilesByNameQuery = {
+    findProfilesByName: (Pick<IProfilePage, 'nextPageToken'> & {
+        profiles: Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>;
+    });
+};
+export type IFindSetsQueryVariables = Exact<{
+    term: Scalars['String'];
+    input: IGallerySearchFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindSetsQuery = {
+    findSets: (Pick<IGalleryPage, 'nextPageToken' | 'results'> & {
+        galleries: Array<Maybe<Pick<IGallery, 'galleryId' | 'galleryType' | 'name' | 'description' | 'userId' | 'username' | 'userpic' | 'banner' | 'createdAt' | 'items' | 'views' | 'publiclyAccessible' | 'nsfw'>>>;
+    });
+};
+export type IFindShowcaseItemsQueryVariables = Exact<{
+    term: Scalars['String'];
+    input: IShowcaseItemFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindShowcaseItemsQuery = {
+    findShowcaseItems: (Pick<IShowcaseItemPage, 'nextPageToken' | 'results'> & {
+        showcaseItems: Array<Maybe<Pick<IShowcaseItem, 'itemType' | 'itemId' | 'blockchain' | 'name' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'likes' | 'visible' | 'blurred'>>>;
+    });
+};
+export type IFindUserCreationsQueryVariables = Exact<{
+    ownerId: Scalars['String'];
+    input: ICreationFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindUserCreationsQuery = {
+    findUserCreations: (Pick<ICreationsPage, 'nextPageToken' | 'results'> & {
+        creations?: Maybe<Array<Maybe<(Pick<ICreation, 'id' | 'itemType' | 'tokenId' | 'address' | 'itemId' | 'blockchain' | 'name' | 'creatorsAddresses' | 'ownersAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'likes' | 'views' | 'visible' | 'blurred'> & {
+            creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+            ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>;
+        })>>>;
+    });
+};
+export type IFindUserShowcaseItemsQueryVariables = Exact<{
+    ownerId: Scalars['String'];
+    input: IShowcaseItemFilterInput;
+    pageSize: Scalars['Int'];
+    pageToken?: Maybe<Scalars['String']>;
+}>;
+export type IFindUserShowcaseItemsQuery = {
+    findUserShowcaseItems: (Pick<IShowcaseItemPage, 'nextPageToken' | 'results'> & {
+        showcaseItems: Array<Maybe<Pick<IShowcaseItem, 'itemType' | 'itemId' | 'blockchain' | 'name' | 'media' | 'mediaPreview' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'likes' | 'visible' | 'blurred' | 'creatorsAddresses'>>>;
+    });
+};
+export declare const DislikeAssetDocument: Apollo.DocumentNode;
+export type IDislikeAssetMutationFn = Apollo.MutationFunction<IDislikeAssetMutation, IDislikeAssetMutationVariables>;
+/**
+ * __useDislikeAssetMutation__
+ *
+ * To run a mutation, you first call `useDislikeAssetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDislikeAssetMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [dislikeAssetMutation, { data, loading, error }] = useDislikeAssetMutation({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useDislikeAssetMutation(baseOptions?: Apollo.MutationHookOptions<IDislikeAssetMutation, IDislikeAssetMutationVariables>): Apollo.MutationTuple<IDislikeAssetMutation, Exact<{
+    assetId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DislikeAssetMutationHookResult = ReturnType<typeof useDislikeAssetMutation>;
+export type DislikeAssetMutationResult = Apollo.MutationResult<IDislikeAssetMutation>;
+export type DislikeAssetMutationOptions = Apollo.BaseMutationOptions<IDislikeAssetMutation, IDislikeAssetMutationVariables>;
+export declare const LikeAssetDocument: Apollo.DocumentNode;
+export type ILikeAssetMutationFn = Apollo.MutationFunction<ILikeAssetMutation, ILikeAssetMutationVariables>;
+/**
+ * __useLikeAssetMutation__
+ *
+ * To run a mutation, you first call `useLikeAssetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLikeAssetMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [likeAssetMutation, { data, loading, error }] = useLikeAssetMutation({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useLikeAssetMutation(baseOptions?: Apollo.MutationHookOptions<ILikeAssetMutation, ILikeAssetMutationVariables>): Apollo.MutationTuple<ILikeAssetMutation, Exact<{
+    assetId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type LikeAssetMutationHookResult = ReturnType<typeof useLikeAssetMutation>;
+export type LikeAssetMutationResult = Apollo.MutationResult<ILikeAssetMutation>;
+export type LikeAssetMutationOptions = Apollo.BaseMutationOptions<ILikeAssetMutation, ILikeAssetMutationVariables>;
+export declare const FetchAssetDocument: Apollo.DocumentNode;
+/**
+ * __useFetchAssetQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchAssetQuery({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useFetchAssetQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetQuery, IFetchAssetQueryVariables>): Apollo.QueryResult<IFetchAssetQuery, Exact<{
+    assetId: string;
+}>>;
+export declare function useFetchAssetLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetQuery, IFetchAssetQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAssetQuery, Exact<{
+    assetId: string;
+}>>;
+export type FetchAssetQueryHookResult = ReturnType<typeof useFetchAssetQuery>;
+export type FetchAssetLazyQueryHookResult = ReturnType<typeof useFetchAssetLazyQuery>;
+export type FetchAssetQueryResult = Apollo.QueryResult<IFetchAssetQuery, IFetchAssetQueryVariables>;
+export declare const FetchAssetByBlockchainDocument: Apollo.DocumentNode;
+/**
+ * __useFetchAssetByBlockchainQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetByBlockchainQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetByBlockchainQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchAssetByBlockchainQuery({
+ *   variables: {
+ *      blockchain: // value for 'blockchain'
+ *      address: // value for 'address'
+ *      tokenId: // value for 'tokenId'
+ *      elrondId: // value for 'elrondId'
+ *   },
+ * });
+ */
+export declare function useFetchAssetByBlockchainQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>): Apollo.QueryResult<IFetchAssetByBlockchainQuery, Exact<{
+    blockchain: string;
+    address?: Maybe<string> | undefined;
+    tokenId?: Maybe<string> | undefined;
+    elrondId?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchAssetByBlockchainLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAssetByBlockchainQuery, Exact<{
+    blockchain: string;
+    address?: Maybe<string> | undefined;
+    tokenId?: Maybe<string> | undefined;
+    elrondId?: Maybe<string> | undefined;
+}>>;
+export type FetchAssetByBlockchainQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainQuery>;
+export type FetchAssetByBlockchainLazyQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainLazyQuery>;
+export type FetchAssetByBlockchainQueryResult = Apollo.QueryResult<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>;
+export declare const FetchAssetsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchAssetsQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchAssetsQuery({
+ *   variables: {
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export declare function useFetchAssetsQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetsQuery, IFetchAssetsQueryVariables>): Apollo.QueryResult<IFetchAssetsQuery, Exact<{
+    assetIds: string[];
+}>>;
+export declare function useFetchAssetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetsQuery, IFetchAssetsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAssetsQuery, Exact<{
+    assetIds: string[];
+}>>;
+export type FetchAssetsQueryHookResult = ReturnType<typeof useFetchAssetsQuery>;
+export type FetchAssetsLazyQueryHookResult = ReturnType<typeof useFetchAssetsLazyQuery>;
+export type FetchAssetsQueryResult = Apollo.QueryResult<IFetchAssetsQuery, IFetchAssetsQueryVariables>;
+export declare const FetchDynamicAssetLikesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchDynamicAssetLikesQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicAssetLikesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicAssetLikesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchDynamicAssetLikesQuery({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useFetchDynamicAssetLikesQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>): Apollo.QueryResult<IFetchDynamicAssetLikesQuery, Exact<{
+    assetId: string;
+}>>;
+export declare function useFetchDynamicAssetLikesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchDynamicAssetLikesQuery, Exact<{
+    assetId: string;
+}>>;
+export type FetchDynamicAssetLikesQueryHookResult = ReturnType<typeof useFetchDynamicAssetLikesQuery>;
+export type FetchDynamicAssetLikesLazyQueryHookResult = ReturnType<typeof useFetchDynamicAssetLikesLazyQuery>;
+export type FetchDynamicAssetLikesQueryResult = Apollo.QueryResult<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>;
+export declare const FetchDynamicAssetsLikesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchDynamicAssetsLikesQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicAssetsLikesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicAssetsLikesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchDynamicAssetsLikesQuery({
+ *   variables: {
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export declare function useFetchDynamicAssetsLikesQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>): Apollo.QueryResult<IFetchDynamicAssetsLikesQuery, Exact<{
+    assetIds: string[];
+}>>;
+export declare function useFetchDynamicAssetsLikesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchDynamicAssetsLikesQuery, Exact<{
+    assetIds: string[];
+}>>;
+export type FetchDynamicAssetsLikesQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesQuery>;
+export type FetchDynamicAssetsLikesLazyQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesLazyQuery>;
+export type FetchDynamicAssetsLikesQueryResult = Apollo.QueryResult<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>;
+export declare const FetchLikedDocument: Apollo.DocumentNode;
+/**
+ * __useFetchLikedQuery__
+ *
+ * To run a query within a React component, call `useFetchLikedQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchLikedQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchLikedQuery({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useFetchLikedQuery(baseOptions: Apollo.QueryHookOptions<IFetchLikedQuery, IFetchLikedQueryVariables>): Apollo.QueryResult<IFetchLikedQuery, Exact<{
+    assetId: string;
+}>>;
+export declare function useFetchLikedLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchLikedQuery, IFetchLikedQueryVariables>): Apollo.LazyQueryResultTuple<IFetchLikedQuery, Exact<{
+    assetId: string;
+}>>;
+export type FetchLikedQueryHookResult = ReturnType<typeof useFetchLikedQuery>;
+export type FetchLikedLazyQueryHookResult = ReturnType<typeof useFetchLikedLazyQuery>;
+export type FetchLikedQueryResult = Apollo.QueryResult<IFetchLikedQuery, IFetchLikedQueryVariables>;
+export declare const DislikeCollectionDocument: Apollo.DocumentNode;
+export type IDislikeCollectionMutationFn = Apollo.MutationFunction<IDislikeCollectionMutation, IDislikeCollectionMutationVariables>;
+/**
+ * __useDislikeCollectionMutation__
+ *
+ * To run a mutation, you first call `useDislikeCollectionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDislikeCollectionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [dislikeCollectionMutation, { data, loading, error }] = useDislikeCollectionMutation({
+ *   variables: {
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export declare function useDislikeCollectionMutation(baseOptions?: Apollo.MutationHookOptions<IDislikeCollectionMutation, IDislikeCollectionMutationVariables>): Apollo.MutationTuple<IDislikeCollectionMutation, Exact<{
+    collectionId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DislikeCollectionMutationHookResult = ReturnType<typeof useDislikeCollectionMutation>;
+export type DislikeCollectionMutationResult = Apollo.MutationResult<IDislikeCollectionMutation>;
+export type DislikeCollectionMutationOptions = Apollo.BaseMutationOptions<IDislikeCollectionMutation, IDislikeCollectionMutationVariables>;
+export declare const LikeCollectionDocument: Apollo.DocumentNode;
+export type ILikeCollectionMutationFn = Apollo.MutationFunction<ILikeCollectionMutation, ILikeCollectionMutationVariables>;
+/**
+ * __useLikeCollectionMutation__
+ *
+ * To run a mutation, you first call `useLikeCollectionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLikeCollectionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [likeCollectionMutation, { data, loading, error }] = useLikeCollectionMutation({
+ *   variables: {
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export declare function useLikeCollectionMutation(baseOptions?: Apollo.MutationHookOptions<ILikeCollectionMutation, ILikeCollectionMutationVariables>): Apollo.MutationTuple<ILikeCollectionMutation, Exact<{
+    collectionId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type LikeCollectionMutationHookResult = ReturnType<typeof useLikeCollectionMutation>;
+export type LikeCollectionMutationResult = Apollo.MutationResult<ILikeCollectionMutation>;
+export type LikeCollectionMutationOptions = Apollo.BaseMutationOptions<ILikeCollectionMutation, ILikeCollectionMutationVariables>;
+export declare const FetchCollectionDocument: Apollo.DocumentNode;
+/**
+ * __useFetchCollectionQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchCollectionQuery({
+ *   variables: {
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export declare function useFetchCollectionQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>): Apollo.QueryResult<IFetchCollectionQuery, Exact<{
+    collectionId: string;
+}>>;
+export declare function useFetchCollectionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>): Apollo.LazyQueryResultTuple<IFetchCollectionQuery, Exact<{
+    collectionId: string;
+}>>;
+export type FetchCollectionQueryHookResult = ReturnType<typeof useFetchCollectionQuery>;
+export type FetchCollectionLazyQueryHookResult = ReturnType<typeof useFetchCollectionLazyQuery>;
+export type FetchCollectionQueryResult = Apollo.QueryResult<IFetchCollectionQuery, IFetchCollectionQueryVariables>;
+export declare const FetchCollectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchCollectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchCollectionsQuery({
+ *   variables: {
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export declare function useFetchCollectionsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionsQuery, IFetchCollectionsQueryVariables>): Apollo.QueryResult<IFetchCollectionsQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+    collectionId: string;
+}>>;
+export declare function useFetchCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionsQuery, IFetchCollectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchCollectionsQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+    collectionId: string;
+}>>;
+export type FetchCollectionsQueryHookResult = ReturnType<typeof useFetchCollectionsQuery>;
+export type FetchCollectionsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsLazyQuery>;
+export type FetchCollectionsQueryResult = Apollo.QueryResult<IFetchCollectionsQuery, IFetchCollectionsQueryVariables>;
+export declare const FetchCollectionsByIdsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchCollectionsByIdsQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionsByIdsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionsByIdsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchCollectionsByIdsQuery({
+ *   variables: {
+ *      collectionIds: // value for 'collectionIds'
+ *   },
+ * });
+ */
+export declare function useFetchCollectionsByIdsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>): Apollo.QueryResult<IFetchCollectionsByIdsQuery, Exact<{
+    collectionIds: string[];
+}>>;
+export declare function useFetchCollectionsByIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchCollectionsByIdsQuery, Exact<{
+    collectionIds: string[];
+}>>;
+export type FetchCollectionsByIdsQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsQuery>;
+export type FetchCollectionsByIdsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsLazyQuery>;
+export type FetchCollectionsByIdsQueryResult = Apollo.QueryResult<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>;
+export declare const FetchDynamicCollectionDataDocument: Apollo.DocumentNode;
+/**
+ * __useFetchDynamicCollectionDataQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicCollectionDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicCollectionDataQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchDynamicCollectionDataQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useFetchDynamicCollectionDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>): Apollo.QueryResult<IFetchDynamicCollectionDataQuery, Exact<{
+    input: IDynamicCollectionDataInput;
+}>>;
+export declare function useFetchDynamicCollectionDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>): Apollo.LazyQueryResultTuple<IFetchDynamicCollectionDataQuery, Exact<{
+    input: IDynamicCollectionDataInput;
+}>>;
+export type FetchDynamicCollectionDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataQuery>;
+export type FetchDynamicCollectionDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataLazyQuery>;
+export type FetchDynamicCollectionDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>;
+export declare const FetchDynamicCollectionsDataDocument: Apollo.DocumentNode;
+/**
+ * __useFetchDynamicCollectionsDataQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicCollectionsDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicCollectionsDataQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchDynamicCollectionsDataQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useFetchDynamicCollectionsDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>): Apollo.QueryResult<IFetchDynamicCollectionsDataQuery, Exact<{
+    input: IDynamicCollectionDataInput[];
+}>>;
+export declare function useFetchDynamicCollectionsDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>): Apollo.LazyQueryResultTuple<IFetchDynamicCollectionsDataQuery, Exact<{
+    input: IDynamicCollectionDataInput[];
+}>>;
+export type FetchDynamicCollectionsDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataQuery>;
+export type FetchDynamicCollectionsDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataLazyQuery>;
+export type FetchDynamicCollectionsDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>;
+export declare const AddAssetsToGalleryDocument: Apollo.DocumentNode;
+export type IAddAssetsToGalleryMutationFn = Apollo.MutationFunction<IAddAssetsToGalleryMutation, IAddAssetsToGalleryMutationVariables>;
+/**
+ * __useAddAssetsToGalleryMutation__
+ *
+ * To run a mutation, you first call `useAddAssetsToGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddAssetsToGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addAssetsToGalleryMutation, { data, loading, error }] = useAddAssetsToGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export declare function useAddAssetsToGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IAddAssetsToGalleryMutation, IAddAssetsToGalleryMutationVariables>): Apollo.MutationTuple<IAddAssetsToGalleryMutation, Exact<{
+    galleryId: string;
+    assetIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddAssetsToGalleryMutationHookResult = ReturnType<typeof useAddAssetsToGalleryMutation>;
+export type AddAssetsToGalleryMutationResult = Apollo.MutationResult<IAddAssetsToGalleryMutation>;
+export type AddAssetsToGalleryMutationOptions = Apollo.BaseMutationOptions<IAddAssetsToGalleryMutation, IAddAssetsToGalleryMutationVariables>;
+export declare const AddAssetsToGalleryV2Document: Apollo.DocumentNode;
+export type IAddAssetsToGalleryV2MutationFn = Apollo.MutationFunction<IAddAssetsToGalleryV2Mutation, IAddAssetsToGalleryV2MutationVariables>;
+/**
+ * __useAddAssetsToGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useAddAssetsToGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddAssetsToGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addAssetsToGalleryV2Mutation, { data, loading, error }] = useAddAssetsToGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export declare function useAddAssetsToGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IAddAssetsToGalleryV2Mutation, IAddAssetsToGalleryV2MutationVariables>): Apollo.MutationTuple<IAddAssetsToGalleryV2Mutation, Exact<{
+    galleryId: string;
+    assetIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddAssetsToGalleryV2MutationHookResult = ReturnType<typeof useAddAssetsToGalleryV2Mutation>;
+export type AddAssetsToGalleryV2MutationResult = Apollo.MutationResult<IAddAssetsToGalleryV2Mutation>;
+export type AddAssetsToGalleryV2MutationOptions = Apollo.BaseMutationOptions<IAddAssetsToGalleryV2Mutation, IAddAssetsToGalleryV2MutationVariables>;
+export declare const UploadGalleryBannerDocument: Apollo.DocumentNode;
+export type IUploadGalleryBannerMutationFn = Apollo.MutationFunction<IUploadGalleryBannerMutation, IUploadGalleryBannerMutationVariables>;
+/**
+ * __useUploadGalleryBannerMutation__
+ *
+ * To run a mutation, you first call `useUploadGalleryBannerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUploadGalleryBannerMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [uploadGalleryBannerMutation, { data, loading, error }] = useUploadGalleryBannerMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      file: // value for 'file'
+ *   },
+ * });
+ */
+export declare function useUploadGalleryBannerMutation(baseOptions?: Apollo.MutationHookOptions<IUploadGalleryBannerMutation, IUploadGalleryBannerMutationVariables>): Apollo.MutationTuple<IUploadGalleryBannerMutation, Exact<{
+    galleryId: string;
+    file: any;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UploadGalleryBannerMutationHookResult = ReturnType<typeof useUploadGalleryBannerMutation>;
+export type UploadGalleryBannerMutationResult = Apollo.MutationResult<IUploadGalleryBannerMutation>;
+export type UploadGalleryBannerMutationOptions = Apollo.BaseMutationOptions<IUploadGalleryBannerMutation, IUploadGalleryBannerMutationVariables>;
+export declare const AddCollectionsToGalleryDocument: Apollo.DocumentNode;
+export type IAddCollectionsToGalleryMutationFn = Apollo.MutationFunction<IAddCollectionsToGalleryMutation, IAddCollectionsToGalleryMutationVariables>;
+/**
+ * __useAddCollectionsToGalleryMutation__
+ *
+ * To run a mutation, you first call `useAddCollectionsToGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddCollectionsToGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addCollectionsToGalleryMutation, { data, loading, error }] = useAddCollectionsToGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      collectionIds: // value for 'collectionIds'
+ *   },
+ * });
+ */
+export declare function useAddCollectionsToGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IAddCollectionsToGalleryMutation, IAddCollectionsToGalleryMutationVariables>): Apollo.MutationTuple<IAddCollectionsToGalleryMutation, Exact<{
+    galleryId: string;
+    collectionIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddCollectionsToGalleryMutationHookResult = ReturnType<typeof useAddCollectionsToGalleryMutation>;
+export type AddCollectionsToGalleryMutationResult = Apollo.MutationResult<IAddCollectionsToGalleryMutation>;
+export type AddCollectionsToGalleryMutationOptions = Apollo.BaseMutationOptions<IAddCollectionsToGalleryMutation, IAddCollectionsToGalleryMutationVariables>;
+export declare const AddCollectionsToGalleryV2Document: Apollo.DocumentNode;
+export type IAddCollectionsToGalleryV2MutationFn = Apollo.MutationFunction<IAddCollectionsToGalleryV2Mutation, IAddCollectionsToGalleryV2MutationVariables>;
+/**
+ * __useAddCollectionsToGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useAddCollectionsToGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddCollectionsToGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addCollectionsToGalleryV2Mutation, { data, loading, error }] = useAddCollectionsToGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      collectionIds: // value for 'collectionIds'
+ *   },
+ * });
+ */
+export declare function useAddCollectionsToGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IAddCollectionsToGalleryV2Mutation, IAddCollectionsToGalleryV2MutationVariables>): Apollo.MutationTuple<IAddCollectionsToGalleryV2Mutation, Exact<{
+    galleryId: string;
+    collectionIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddCollectionsToGalleryV2MutationHookResult = ReturnType<typeof useAddCollectionsToGalleryV2Mutation>;
+export type AddCollectionsToGalleryV2MutationResult = Apollo.MutationResult<IAddCollectionsToGalleryV2Mutation>;
+export type AddCollectionsToGalleryV2MutationOptions = Apollo.BaseMutationOptions<IAddCollectionsToGalleryV2Mutation, IAddCollectionsToGalleryV2MutationVariables>;
+export declare const AddCreationsToGalleryDocument: Apollo.DocumentNode;
+export type IAddCreationsToGalleryMutationFn = Apollo.MutationFunction<IAddCreationsToGalleryMutation, IAddCreationsToGalleryMutationVariables>;
+/**
+ * __useAddCreationsToGalleryMutation__
+ *
+ * To run a mutation, you first call `useAddCreationsToGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddCreationsToGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addCreationsToGalleryMutation, { data, loading, error }] = useAddCreationsToGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useAddCreationsToGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IAddCreationsToGalleryMutation, IAddCreationsToGalleryMutationVariables>): Apollo.MutationTuple<IAddCreationsToGalleryMutation, Exact<{
+    galleryId: string;
+    creationIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddCreationsToGalleryMutationHookResult = ReturnType<typeof useAddCreationsToGalleryMutation>;
+export type AddCreationsToGalleryMutationResult = Apollo.MutationResult<IAddCreationsToGalleryMutation>;
+export type AddCreationsToGalleryMutationOptions = Apollo.BaseMutationOptions<IAddCreationsToGalleryMutation, IAddCreationsToGalleryMutationVariables>;
+export declare const AddCreationsToGalleryV2Document: Apollo.DocumentNode;
+export type IAddCreationsToGalleryV2MutationFn = Apollo.MutationFunction<IAddCreationsToGalleryV2Mutation, IAddCreationsToGalleryV2MutationVariables>;
+/**
+ * __useAddCreationsToGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useAddCreationsToGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddCreationsToGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addCreationsToGalleryV2Mutation, { data, loading, error }] = useAddCreationsToGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useAddCreationsToGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IAddCreationsToGalleryV2Mutation, IAddCreationsToGalleryV2MutationVariables>): Apollo.MutationTuple<IAddCreationsToGalleryV2Mutation, Exact<{
+    galleryId: string;
+    creationIds: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddCreationsToGalleryV2MutationHookResult = ReturnType<typeof useAddCreationsToGalleryV2Mutation>;
+export type AddCreationsToGalleryV2MutationResult = Apollo.MutationResult<IAddCreationsToGalleryV2Mutation>;
+export type AddCreationsToGalleryV2MutationOptions = Apollo.BaseMutationOptions<IAddCreationsToGalleryV2Mutation, IAddCreationsToGalleryV2MutationVariables>;
+export declare const CreateFavoriteListV2Document: Apollo.DocumentNode;
+export type ICreateFavoriteListV2MutationFn = Apollo.MutationFunction<ICreateFavoriteListV2Mutation, ICreateFavoriteListV2MutationVariables>;
+/**
+ * __useCreateFavoriteListV2Mutation__
+ *
+ * To run a mutation, you first call `useCreateFavoriteListV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFavoriteListV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createFavoriteListV2Mutation, { data, loading, error }] = useCreateFavoriteListV2Mutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      description: // value for 'description'
+ *      publicAccessible: // value for 'publicAccessible'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useCreateFavoriteListV2Mutation(baseOptions?: Apollo.MutationHookOptions<ICreateFavoriteListV2Mutation, ICreateFavoriteListV2MutationVariables>): Apollo.MutationTuple<ICreateFavoriteListV2Mutation, Exact<{
+    name: string;
+    description?: Maybe<string> | undefined;
+    publicAccessible?: Maybe<boolean> | undefined;
+    creationIds?: Maybe<Maybe<string>[]> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateFavoriteListV2MutationHookResult = ReturnType<typeof useCreateFavoriteListV2Mutation>;
+export type CreateFavoriteListV2MutationResult = Apollo.MutationResult<ICreateFavoriteListV2Mutation>;
+export type CreateFavoriteListV2MutationOptions = Apollo.BaseMutationOptions<ICreateFavoriteListV2Mutation, ICreateFavoriteListV2MutationVariables>;
+export declare const CreateFavoritesDocument: Apollo.DocumentNode;
+export type ICreateFavoritesMutationFn = Apollo.MutationFunction<ICreateFavoritesMutation, ICreateFavoritesMutationVariables>;
+/**
+ * __useCreateFavoritesMutation__
+ *
+ * To run a mutation, you first call `useCreateFavoritesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFavoritesMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createFavoritesMutation, { data, loading, error }] = useCreateFavoritesMutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      description: // value for 'description'
+ *      publicAccessible: // value for 'publicAccessible'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useCreateFavoritesMutation(baseOptions?: Apollo.MutationHookOptions<ICreateFavoritesMutation, ICreateFavoritesMutationVariables>): Apollo.MutationTuple<ICreateFavoritesMutation, Exact<{
+    name: string;
+    description?: Maybe<string> | undefined;
+    publicAccessible?: Maybe<boolean> | undefined;
+    creationIds?: Maybe<Maybe<string>[]> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateFavoritesMutationHookResult = ReturnType<typeof useCreateFavoritesMutation>;
+export type CreateFavoritesMutationResult = Apollo.MutationResult<ICreateFavoritesMutation>;
+export type CreateFavoritesMutationOptions = Apollo.BaseMutationOptions<ICreateFavoritesMutation, ICreateFavoritesMutationVariables>;
+export declare const CreateGalleryDocument: Apollo.DocumentNode;
+export type ICreateGalleryMutationFn = Apollo.MutationFunction<ICreateGalleryMutation, ICreateGalleryMutationVariables>;
+/**
+ * __useCreateGalleryMutation__
+ *
+ * To run a mutation, you first call `useCreateGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createGalleryMutation, { data, loading, error }] = useCreateGalleryMutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      description: // value for 'description'
+ *      publicAccessible: // value for 'publicAccessible'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useCreateGalleryMutation(baseOptions?: Apollo.MutationHookOptions<ICreateGalleryMutation, ICreateGalleryMutationVariables>): Apollo.MutationTuple<ICreateGalleryMutation, Exact<{
+    name: string;
+    description?: Maybe<string> | undefined;
+    publicAccessible?: Maybe<boolean> | undefined;
+    creationIds?: Maybe<Maybe<string>[]> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateGalleryMutationHookResult = ReturnType<typeof useCreateGalleryMutation>;
+export type CreateGalleryMutationResult = Apollo.MutationResult<ICreateGalleryMutation>;
+export type CreateGalleryMutationOptions = Apollo.BaseMutationOptions<ICreateGalleryMutation, ICreateGalleryMutationVariables>;
+export declare const CreateGalleryV2Document: Apollo.DocumentNode;
+export type ICreateGalleryV2MutationFn = Apollo.MutationFunction<ICreateGalleryV2Mutation, ICreateGalleryV2MutationVariables>;
+/**
+ * __useCreateGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useCreateGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createGalleryV2Mutation, { data, loading, error }] = useCreateGalleryV2Mutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      description: // value for 'description'
+ *      publicAccessible: // value for 'publicAccessible'
+ *      creationIds: // value for 'creationIds'
+ *   },
+ * });
+ */
+export declare function useCreateGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<ICreateGalleryV2Mutation, ICreateGalleryV2MutationVariables>): Apollo.MutationTuple<ICreateGalleryV2Mutation, Exact<{
+    name: string;
+    description?: Maybe<string> | undefined;
+    publicAccessible?: Maybe<boolean> | undefined;
+    creationIds?: Maybe<Maybe<string>[]> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateGalleryV2MutationHookResult = ReturnType<typeof useCreateGalleryV2Mutation>;
+export type CreateGalleryV2MutationResult = Apollo.MutationResult<ICreateGalleryV2Mutation>;
+export type CreateGalleryV2MutationOptions = Apollo.BaseMutationOptions<ICreateGalleryV2Mutation, ICreateGalleryV2MutationVariables>;
+export declare const DeleteGalleryBannerDocument: Apollo.DocumentNode;
+export type IDeleteGalleryBannerMutationFn = Apollo.MutationFunction<IDeleteGalleryBannerMutation, IDeleteGalleryBannerMutationVariables>;
+/**
+ * __useDeleteGalleryBannerMutation__
+ *
+ * To run a mutation, you first call `useDeleteGalleryBannerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteGalleryBannerMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteGalleryBannerMutation, { data, loading, error }] = useDeleteGalleryBannerMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *   },
+ * });
+ */
+export declare function useDeleteGalleryBannerMutation(baseOptions?: Apollo.MutationHookOptions<IDeleteGalleryBannerMutation, IDeleteGalleryBannerMutationVariables>): Apollo.MutationTuple<IDeleteGalleryBannerMutation, Exact<{
+    galleryId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DeleteGalleryBannerMutationHookResult = ReturnType<typeof useDeleteGalleryBannerMutation>;
+export type DeleteGalleryBannerMutationResult = Apollo.MutationResult<IDeleteGalleryBannerMutation>;
+export type DeleteGalleryBannerMutationOptions = Apollo.BaseMutationOptions<IDeleteGalleryBannerMutation, IDeleteGalleryBannerMutationVariables>;
+export declare const EditGalleryDocument: Apollo.DocumentNode;
+export type IEditGalleryMutationFn = Apollo.MutationFunction<IEditGalleryMutation, IEditGalleryMutationVariables>;
+/**
+ * __useEditGalleryMutation__
+ *
+ * To run a mutation, you first call `useEditGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useEditGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [editGalleryMutation, { data, loading, error }] = useEditGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      name: // value for 'name'
+ *      description: // value for 'description'
+ *   },
+ * });
+ */
+export declare function useEditGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IEditGalleryMutation, IEditGalleryMutationVariables>): Apollo.MutationTuple<IEditGalleryMutation, Exact<{
+    galleryId: string;
+    name?: Maybe<string> | undefined;
+    description?: Maybe<string> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type EditGalleryMutationHookResult = ReturnType<typeof useEditGalleryMutation>;
+export type EditGalleryMutationResult = Apollo.MutationResult<IEditGalleryMutation>;
+export type EditGalleryMutationOptions = Apollo.BaseMutationOptions<IEditGalleryMutation, IEditGalleryMutationVariables>;
+export declare const RemoveAssetFromGalleryDocument: Apollo.DocumentNode;
+export type IRemoveAssetFromGalleryMutationFn = Apollo.MutationFunction<IRemoveAssetFromGalleryMutation, IRemoveAssetFromGalleryMutationVariables>;
+/**
+ * __useRemoveAssetFromGalleryMutation__
+ *
+ * To run a mutation, you first call `useRemoveAssetFromGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveAssetFromGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeAssetFromGalleryMutation, { data, loading, error }] = useRemoveAssetFromGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationId: // value for 'creationId'
+ *   },
+ * });
+ */
+export declare function useRemoveAssetFromGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveAssetFromGalleryMutation, IRemoveAssetFromGalleryMutationVariables>): Apollo.MutationTuple<IRemoveAssetFromGalleryMutation, Exact<{
+    galleryId: string;
+    creationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveAssetFromGalleryMutationHookResult = ReturnType<typeof useRemoveAssetFromGalleryMutation>;
+export type RemoveAssetFromGalleryMutationResult = Apollo.MutationResult<IRemoveAssetFromGalleryMutation>;
+export type RemoveAssetFromGalleryMutationOptions = Apollo.BaseMutationOptions<IRemoveAssetFromGalleryMutation, IRemoveAssetFromGalleryMutationVariables>;
+export declare const RemoveAssetFromGalleryV2Document: Apollo.DocumentNode;
+export type IRemoveAssetFromGalleryV2MutationFn = Apollo.MutationFunction<IRemoveAssetFromGalleryV2Mutation, IRemoveAssetFromGalleryV2MutationVariables>;
+/**
+ * __useRemoveAssetFromGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useRemoveAssetFromGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveAssetFromGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeAssetFromGalleryV2Mutation, { data, loading, error }] = useRemoveAssetFromGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export declare function useRemoveAssetFromGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IRemoveAssetFromGalleryV2Mutation, IRemoveAssetFromGalleryV2MutationVariables>): Apollo.MutationTuple<IRemoveAssetFromGalleryV2Mutation, Exact<{
+    galleryId: string;
+    assetId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveAssetFromGalleryV2MutationHookResult = ReturnType<typeof useRemoveAssetFromGalleryV2Mutation>;
+export type RemoveAssetFromGalleryV2MutationResult = Apollo.MutationResult<IRemoveAssetFromGalleryV2Mutation>;
+export type RemoveAssetFromGalleryV2MutationOptions = Apollo.BaseMutationOptions<IRemoveAssetFromGalleryV2Mutation, IRemoveAssetFromGalleryV2MutationVariables>;
+export declare const RemoveCollectionFromGalleryDocument: Apollo.DocumentNode;
+export type IRemoveCollectionFromGalleryMutationFn = Apollo.MutationFunction<IRemoveCollectionFromGalleryMutation, IRemoveCollectionFromGalleryMutationVariables>;
+/**
+ * __useRemoveCollectionFromGalleryMutation__
+ *
+ * To run a mutation, you first call `useRemoveCollectionFromGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveCollectionFromGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeCollectionFromGalleryMutation, { data, loading, error }] = useRemoveCollectionFromGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationId: // value for 'creationId'
+ *   },
+ * });
+ */
+export declare function useRemoveCollectionFromGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveCollectionFromGalleryMutation, IRemoveCollectionFromGalleryMutationVariables>): Apollo.MutationTuple<IRemoveCollectionFromGalleryMutation, Exact<{
+    galleryId: string;
+    creationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveCollectionFromGalleryMutationHookResult = ReturnType<typeof useRemoveCollectionFromGalleryMutation>;
+export type RemoveCollectionFromGalleryMutationResult = Apollo.MutationResult<IRemoveCollectionFromGalleryMutation>;
+export type RemoveCollectionFromGalleryMutationOptions = Apollo.BaseMutationOptions<IRemoveCollectionFromGalleryMutation, IRemoveCollectionFromGalleryMutationVariables>;
+export declare const RemoveCollectionFromGalleryV2Document: Apollo.DocumentNode;
+export type IRemoveCollectionFromGalleryV2MutationFn = Apollo.MutationFunction<IRemoveCollectionFromGalleryV2Mutation, IRemoveCollectionFromGalleryV2MutationVariables>;
+/**
+ * __useRemoveCollectionFromGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useRemoveCollectionFromGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveCollectionFromGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeCollectionFromGalleryV2Mutation, { data, loading, error }] = useRemoveCollectionFromGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export declare function useRemoveCollectionFromGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IRemoveCollectionFromGalleryV2Mutation, IRemoveCollectionFromGalleryV2MutationVariables>): Apollo.MutationTuple<IRemoveCollectionFromGalleryV2Mutation, Exact<{
+    galleryId: string;
+    collectionId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveCollectionFromGalleryV2MutationHookResult = ReturnType<typeof useRemoveCollectionFromGalleryV2Mutation>;
+export type RemoveCollectionFromGalleryV2MutationResult = Apollo.MutationResult<IRemoveCollectionFromGalleryV2Mutation>;
+export type RemoveCollectionFromGalleryV2MutationOptions = Apollo.BaseMutationOptions<IRemoveCollectionFromGalleryV2Mutation, IRemoveCollectionFromGalleryV2MutationVariables>;
+export declare const RemoveCreationFromGalleryDocument: Apollo.DocumentNode;
+export type IRemoveCreationFromGalleryMutationFn = Apollo.MutationFunction<IRemoveCreationFromGalleryMutation, IRemoveCreationFromGalleryMutationVariables>;
+/**
+ * __useRemoveCreationFromGalleryMutation__
+ *
+ * To run a mutation, you first call `useRemoveCreationFromGalleryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveCreationFromGalleryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeCreationFromGalleryMutation, { data, loading, error }] = useRemoveCreationFromGalleryMutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationId: // value for 'creationId'
+ *   },
+ * });
+ */
+export declare function useRemoveCreationFromGalleryMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveCreationFromGalleryMutation, IRemoveCreationFromGalleryMutationVariables>): Apollo.MutationTuple<IRemoveCreationFromGalleryMutation, Exact<{
+    galleryId: string;
+    creationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveCreationFromGalleryMutationHookResult = ReturnType<typeof useRemoveCreationFromGalleryMutation>;
+export type RemoveCreationFromGalleryMutationResult = Apollo.MutationResult<IRemoveCreationFromGalleryMutation>;
+export type RemoveCreationFromGalleryMutationOptions = Apollo.BaseMutationOptions<IRemoveCreationFromGalleryMutation, IRemoveCreationFromGalleryMutationVariables>;
+export declare const RemoveCreationFromGalleryV2Document: Apollo.DocumentNode;
+export type IRemoveCreationFromGalleryV2MutationFn = Apollo.MutationFunction<IRemoveCreationFromGalleryV2Mutation, IRemoveCreationFromGalleryV2MutationVariables>;
+/**
+ * __useRemoveCreationFromGalleryV2Mutation__
+ *
+ * To run a mutation, you first call `useRemoveCreationFromGalleryV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveCreationFromGalleryV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeCreationFromGalleryV2Mutation, { data, loading, error }] = useRemoveCreationFromGalleryV2Mutation({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      creationId: // value for 'creationId'
+ *   },
+ * });
+ */
+export declare function useRemoveCreationFromGalleryV2Mutation(baseOptions?: Apollo.MutationHookOptions<IRemoveCreationFromGalleryV2Mutation, IRemoveCreationFromGalleryV2MutationVariables>): Apollo.MutationTuple<IRemoveCreationFromGalleryV2Mutation, Exact<{
+    galleryId: string;
+    creationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveCreationFromGalleryV2MutationHookResult = ReturnType<typeof useRemoveCreationFromGalleryV2Mutation>;
+export type RemoveCreationFromGalleryV2MutationResult = Apollo.MutationResult<IRemoveCreationFromGalleryV2Mutation>;
+export type RemoveCreationFromGalleryV2MutationOptions = Apollo.BaseMutationOptions<IRemoveCreationFromGalleryV2Mutation, IRemoveCreationFromGalleryV2MutationVariables>;
+export declare const FetchGalleryDocument: Apollo.DocumentNode;
+/**
+ * __useFetchGalleryQuery__
+ *
+ * To run a query within a React component, call `useFetchGalleryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchGalleryQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchGalleryQuery({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *   },
+ * });
+ */
+export declare function useFetchGalleryQuery(baseOptions: Apollo.QueryHookOptions<IFetchGalleryQuery, IFetchGalleryQueryVariables>): Apollo.QueryResult<IFetchGalleryQuery, Exact<{
+    galleryId: string;
+}>>;
+export declare function useFetchGalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchGalleryQuery, IFetchGalleryQueryVariables>): Apollo.LazyQueryResultTuple<IFetchGalleryQuery, Exact<{
+    galleryId: string;
+}>>;
+export type FetchGalleryQueryHookResult = ReturnType<typeof useFetchGalleryQuery>;
+export type FetchGalleryLazyQueryHookResult = ReturnType<typeof useFetchGalleryLazyQuery>;
+export type FetchGalleryQueryResult = Apollo.QueryResult<IFetchGalleryQuery, IFetchGalleryQueryVariables>;
+export declare const FetchGalleryCreationsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchGalleryCreationsQuery__
+ *
+ * To run a query within a React component, call `useFetchGalleryCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchGalleryCreationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchGalleryCreationsQuery({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchGalleryCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFetchGalleryCreationsQuery, IFetchGalleryCreationsQueryVariables>): Apollo.QueryResult<IFetchGalleryCreationsQuery, Exact<{
+    galleryId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchGalleryCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchGalleryCreationsQuery, IFetchGalleryCreationsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchGalleryCreationsQuery, Exact<{
+    galleryId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchGalleryCreationsQueryHookResult = ReturnType<typeof useFetchGalleryCreationsQuery>;
+export type FetchGalleryCreationsLazyQueryHookResult = ReturnType<typeof useFetchGalleryCreationsLazyQuery>;
+export type FetchGalleryCreationsQueryResult = Apollo.QueryResult<IFetchGalleryCreationsQuery, IFetchGalleryCreationsQueryVariables>;
+export declare const FetchGalleryV2Document: Apollo.DocumentNode;
+/**
+ * __useFetchGalleryV2Query__
+ *
+ * To run a query within a React component, call `useFetchGalleryV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchGalleryV2Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchGalleryV2Query({
+ *   variables: {
+ *      galleryId: // value for 'galleryId'
+ *   },
+ * });
+ */
+export declare function useFetchGalleryV2Query(baseOptions: Apollo.QueryHookOptions<IFetchGalleryV2Query, IFetchGalleryV2QueryVariables>): Apollo.QueryResult<IFetchGalleryV2Query, Exact<{
+    galleryId: string;
+}>>;
+export declare function useFetchGalleryV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchGalleryV2Query, IFetchGalleryV2QueryVariables>): Apollo.LazyQueryResultTuple<IFetchGalleryV2Query, Exact<{
+    galleryId: string;
+}>>;
+export type FetchGalleryV2QueryHookResult = ReturnType<typeof useFetchGalleryV2Query>;
+export type FetchGalleryV2LazyQueryHookResult = ReturnType<typeof useFetchGalleryV2LazyQuery>;
+export type FetchGalleryV2QueryResult = Apollo.QueryResult<IFetchGalleryV2Query, IFetchGalleryV2QueryVariables>;
+export declare const FetchMyFavoritesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchMyFavoritesQuery__
+ *
+ * To run a query within a React component, call `useFetchMyFavoritesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyFavoritesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchMyFavoritesQuery({
+ *   variables: {
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchMyFavoritesQuery(baseOptions: Apollo.QueryHookOptions<IFetchMyFavoritesQuery, IFetchMyFavoritesQueryVariables>): Apollo.QueryResult<IFetchMyFavoritesQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchMyFavoritesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyFavoritesQuery, IFetchMyFavoritesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchMyFavoritesQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchMyFavoritesQueryHookResult = ReturnType<typeof useFetchMyFavoritesQuery>;
+export type FetchMyFavoritesLazyQueryHookResult = ReturnType<typeof useFetchMyFavoritesLazyQuery>;
+export type FetchMyFavoritesQueryResult = Apollo.QueryResult<IFetchMyFavoritesQuery, IFetchMyFavoritesQueryVariables>;
+export declare const FetchMyFavoritesV2Document: Apollo.DocumentNode;
+/**
+ * __useFetchMyFavoritesV2Query__
+ *
+ * To run a query within a React component, call `useFetchMyFavoritesV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyFavoritesV2Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchMyFavoritesV2Query({
+ *   variables: {
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchMyFavoritesV2Query(baseOptions: Apollo.QueryHookOptions<IFetchMyFavoritesV2Query, IFetchMyFavoritesV2QueryVariables>): Apollo.QueryResult<IFetchMyFavoritesV2Query, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchMyFavoritesV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyFavoritesV2Query, IFetchMyFavoritesV2QueryVariables>): Apollo.LazyQueryResultTuple<IFetchMyFavoritesV2Query, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchMyFavoritesV2QueryHookResult = ReturnType<typeof useFetchMyFavoritesV2Query>;
+export type FetchMyFavoritesV2LazyQueryHookResult = ReturnType<typeof useFetchMyFavoritesV2LazyQuery>;
+export type FetchMyFavoritesV2QueryResult = Apollo.QueryResult<IFetchMyFavoritesV2Query, IFetchMyFavoritesV2QueryVariables>;
+export declare const FetchUserFavoritesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserFavoritesQuery__
+ *
+ * To run a query within a React component, call `useFetchUserFavoritesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserFavoritesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserFavoritesQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchUserFavoritesQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserFavoritesQuery, IFetchUserFavoritesQueryVariables>): Apollo.QueryResult<IFetchUserFavoritesQuery, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchUserFavoritesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserFavoritesQuery, IFetchUserFavoritesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserFavoritesQuery, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchUserFavoritesQueryHookResult = ReturnType<typeof useFetchUserFavoritesQuery>;
+export type FetchUserFavoritesLazyQueryHookResult = ReturnType<typeof useFetchUserFavoritesLazyQuery>;
+export type FetchUserFavoritesQueryResult = Apollo.QueryResult<IFetchUserFavoritesQuery, IFetchUserFavoritesQueryVariables>;
+export declare const FetchUserFavoritesV2Document: Apollo.DocumentNode;
+/**
+ * __useFetchUserFavoritesV2Query__
+ *
+ * To run a query within a React component, call `useFetchUserFavoritesV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserFavoritesV2Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserFavoritesV2Query({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchUserFavoritesV2Query(baseOptions: Apollo.QueryHookOptions<IFetchUserFavoritesV2Query, IFetchUserFavoritesV2QueryVariables>): Apollo.QueryResult<IFetchUserFavoritesV2Query, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchUserFavoritesV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserFavoritesV2Query, IFetchUserFavoritesV2QueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserFavoritesV2Query, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchUserFavoritesV2QueryHookResult = ReturnType<typeof useFetchUserFavoritesV2Query>;
+export type FetchUserFavoritesV2LazyQueryHookResult = ReturnType<typeof useFetchUserFavoritesV2LazyQuery>;
+export type FetchUserFavoritesV2QueryResult = Apollo.QueryResult<IFetchUserFavoritesV2Query, IFetchUserFavoritesV2QueryVariables>;
+export declare const FetchUserGalleriesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserGalleriesQuery__
+ *
+ * To run a query within a React component, call `useFetchUserGalleriesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserGalleriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserGalleriesQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchUserGalleriesQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserGalleriesQuery, IFetchUserGalleriesQueryVariables>): Apollo.QueryResult<IFetchUserGalleriesQuery, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchUserGalleriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserGalleriesQuery, IFetchUserGalleriesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserGalleriesQuery, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchUserGalleriesQueryHookResult = ReturnType<typeof useFetchUserGalleriesQuery>;
+export type FetchUserGalleriesLazyQueryHookResult = ReturnType<typeof useFetchUserGalleriesLazyQuery>;
+export type FetchUserGalleriesQueryResult = Apollo.QueryResult<IFetchUserGalleriesQuery, IFetchUserGalleriesQueryVariables>;
+export declare const FetchUserGalleriesV2Document: Apollo.DocumentNode;
+/**
+ * __useFetchUserGalleriesV2Query__
+ *
+ * To run a query within a React component, call `useFetchUserGalleriesV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserGalleriesV2Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserGalleriesV2Query({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchUserGalleriesV2Query(baseOptions: Apollo.QueryHookOptions<IFetchUserGalleriesV2Query, IFetchUserGalleriesV2QueryVariables>): Apollo.QueryResult<IFetchUserGalleriesV2Query, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchUserGalleriesV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserGalleriesV2Query, IFetchUserGalleriesV2QueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserGalleriesV2Query, Exact<{
+    userId: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchUserGalleriesV2QueryHookResult = ReturnType<typeof useFetchUserGalleriesV2Query>;
+export type FetchUserGalleriesV2LazyQueryHookResult = ReturnType<typeof useFetchUserGalleriesV2LazyQuery>;
+export type FetchUserGalleriesV2QueryResult = Apollo.QueryResult<IFetchUserGalleriesV2Query, IFetchUserGalleriesV2QueryVariables>;
+export declare const SignInMetamaskDocument: Apollo.DocumentNode;
+export type ISignInMetamaskMutationFn = Apollo.MutationFunction<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>;
+/**
+ * __useSignInMetamaskMutation__
+ *
+ * To run a mutation, you first call `useSignInMetamaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInMetamaskMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [signInMetamaskMutation, { data, loading, error }] = useSignInMetamaskMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export declare function useSignInMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>): Apollo.MutationTuple<ISignInMetamaskMutation, Exact<{
+    signature: string;
+    address: string;
+    chainId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInMetamaskMutationHookResult = ReturnType<typeof useSignInMetamaskMutation>;
+export type SignInMetamaskMutationResult = Apollo.MutationResult<ISignInMetamaskMutation>;
+export type SignInMetamaskMutationOptions = Apollo.BaseMutationOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>;
+export declare const AddWalletElrondDocument: Apollo.DocumentNode;
+export type IAddWalletElrondMutationFn = Apollo.MutationFunction<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>;
+/**
+ * __useAddWalletElrondMutation__
+ *
+ * To run a mutation, you first call `useAddWalletElrondMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletElrondMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWalletElrondMutation, { data, loading, error }] = useAddWalletElrondMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export declare function useAddWalletElrondMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>): Apollo.MutationTuple<IAddWalletElrondMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletElrondMutationHookResult = ReturnType<typeof useAddWalletElrondMutation>;
+export type AddWalletElrondMutationResult = Apollo.MutationResult<IAddWalletElrondMutation>;
+export type AddWalletElrondMutationOptions = Apollo.BaseMutationOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>;
+export declare const AddWalletFlowDocument: Apollo.DocumentNode;
+export type IAddWalletFlowMutationFn = Apollo.MutationFunction<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>;
+/**
+ * __useAddWalletFlowMutation__
+ *
+ * To run a mutation, you first call `useAddWalletFlowMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletFlowMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWalletFlowMutation, { data, loading, error }] = useAddWalletFlowMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export declare function useAddWalletFlowMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>): Apollo.MutationTuple<IAddWalletFlowMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletFlowMutationHookResult = ReturnType<typeof useAddWalletFlowMutation>;
+export type AddWalletFlowMutationResult = Apollo.MutationResult<IAddWalletFlowMutation>;
+export type AddWalletFlowMutationOptions = Apollo.BaseMutationOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>;
+export declare const AddWalletMetamaskDocument: Apollo.DocumentNode;
+export type IAddWalletMetamaskMutationFn = Apollo.MutationFunction<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>;
+/**
+ * __useAddWalletMetamaskMutation__
+ *
+ * To run a mutation, you first call `useAddWalletMetamaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletMetamaskMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWalletMetamaskMutation, { data, loading, error }] = useAddWalletMetamaskMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export declare function useAddWalletMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>): Apollo.MutationTuple<IAddWalletMetamaskMutation, Exact<{
+    signature: string;
+    address: string;
+    chainId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletMetamaskMutationHookResult = ReturnType<typeof useAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationResult = Apollo.MutationResult<IAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationOptions = Apollo.BaseMutationOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>;
+export declare const AddWalletSolanaDocument: Apollo.DocumentNode;
+export type IAddWalletSolanaMutationFn = Apollo.MutationFunction<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>;
+/**
+ * __useAddWalletSolanaMutation__
+ *
+ * To run a mutation, you first call `useAddWalletSolanaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletSolanaMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWalletSolanaMutation, { data, loading, error }] = useAddWalletSolanaMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export declare function useAddWalletSolanaMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>): Apollo.MutationTuple<IAddWalletSolanaMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletSolanaMutationHookResult = ReturnType<typeof useAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationResult = Apollo.MutationResult<IAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationOptions = Apollo.BaseMutationOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>;
+export declare const AddWalletTezosDocument: Apollo.DocumentNode;
+export type IAddWalletTezosMutationFn = Apollo.MutationFunction<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>;
+/**
+ * __useAddWalletTezosMutation__
+ *
+ * To run a mutation, you first call `useAddWalletTezosMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletTezosMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWalletTezosMutation, { data, loading, error }] = useAddWalletTezosMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export declare function useAddWalletTezosMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>): Apollo.MutationTuple<IAddWalletTezosMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletTezosMutationHookResult = ReturnType<typeof useAddWalletTezosMutation>;
+export type AddWalletTezosMutationResult = Apollo.MutationResult<IAddWalletTezosMutation>;
+export type AddWalletTezosMutationOptions = Apollo.BaseMutationOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>;
+export declare const CreateNonceDocument: Apollo.DocumentNode;
+export type ICreateNonceMutationFn = Apollo.MutationFunction<ICreateNonceMutation, ICreateNonceMutationVariables>;
+/**
+ * __useCreateNonceMutation__
+ *
+ * To run a mutation, you first call `useCreateNonceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateNonceMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createNonceMutation, { data, loading, error }] = useCreateNonceMutation({
+ *   variables: {
+ *      address: // value for 'address'
+ *      blockchain: // value for 'blockchain'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export declare function useCreateNonceMutation(baseOptions?: Apollo.MutationHookOptions<ICreateNonceMutation, ICreateNonceMutationVariables>): Apollo.MutationTuple<ICreateNonceMutation, Exact<{
+    address: string;
+    blockchain: string;
+    chainId?: Maybe<string> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateNonceMutationHookResult = ReturnType<typeof useCreateNonceMutation>;
+export type CreateNonceMutationResult = Apollo.MutationResult<ICreateNonceMutation>;
+export type CreateNonceMutationOptions = Apollo.BaseMutationOptions<ICreateNonceMutation, ICreateNonceMutationVariables>;
+export declare const RefreshTokenDocument: Apollo.DocumentNode;
+export type IRefreshTokenMutationFn = Apollo.MutationFunction<IRefreshTokenMutation, IRefreshTokenMutationVariables>;
+/**
+ * __useRefreshTokenMutation__
+ *
+ * To run a mutation, you first call `useRefreshTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRefreshTokenMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [refreshTokenMutation, { data, loading, error }] = useRefreshTokenMutation({
+ *   variables: {
+ *      refreshToken: // value for 'refreshToken'
+ *   },
+ * });
+ */
+export declare function useRefreshTokenMutation(baseOptions?: Apollo.MutationHookOptions<IRefreshTokenMutation, IRefreshTokenMutationVariables>): Apollo.MutationTuple<IRefreshTokenMutation, Exact<{
+    refreshToken: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RefreshTokenMutationHookResult = ReturnType<typeof useRefreshTokenMutation>;
+export type RefreshTokenMutationResult = Apollo.MutationResult<IRefreshTokenMutation>;
+export type RefreshTokenMutationOptions = Apollo.BaseMutationOptions<IRefreshTokenMutation, IRefreshTokenMutationVariables>;
+export declare const RevokeTokenDocument: Apollo.DocumentNode;
+export type IRevokeTokenMutationFn = Apollo.MutationFunction<IRevokeTokenMutation, IRevokeTokenMutationVariables>;
+/**
+ * __useRevokeTokenMutation__
+ *
+ * To run a mutation, you first call `useRevokeTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeTokenMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [revokeTokenMutation, { data, loading, error }] = useRevokeTokenMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useRevokeTokenMutation(baseOptions?: Apollo.MutationHookOptions<IRevokeTokenMutation, IRevokeTokenMutationVariables>): Apollo.MutationTuple<IRevokeTokenMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RevokeTokenMutationHookResult = ReturnType<typeof useRevokeTokenMutation>;
+export type RevokeTokenMutationResult = Apollo.MutationResult<IRevokeTokenMutation>;
+export type RevokeTokenMutationOptions = Apollo.BaseMutationOptions<IRevokeTokenMutation, IRevokeTokenMutationVariables>;
+export declare const SignInElrondDocument: Apollo.DocumentNode;
+export type ISignInElrondMutationFn = Apollo.MutationFunction<ISignInElrondMutation, ISignInElrondMutationVariables>;
+/**
+ * __useSignInElrondMutation__
+ *
+ * To run a mutation, you first call `useSignInElrondMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInElrondMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [signInElrondMutation, { data, loading, error }] = useSignInElrondMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export declare function useSignInElrondMutation(baseOptions?: Apollo.MutationHookOptions<ISignInElrondMutation, ISignInElrondMutationVariables>): Apollo.MutationTuple<ISignInElrondMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInElrondMutationHookResult = ReturnType<typeof useSignInElrondMutation>;
+export type SignInElrondMutationResult = Apollo.MutationResult<ISignInElrondMutation>;
+export type SignInElrondMutationOptions = Apollo.BaseMutationOptions<ISignInElrondMutation, ISignInElrondMutationVariables>;
+export declare const SignInFlowDocument: Apollo.DocumentNode;
+export type ISignInFlowMutationFn = Apollo.MutationFunction<ISignInFlowMutation, ISignInFlowMutationVariables>;
+/**
+ * __useSignInFlowMutation__
+ *
+ * To run a mutation, you first call `useSignInFlowMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInFlowMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [signInFlowMutation, { data, loading, error }] = useSignInFlowMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export declare function useSignInFlowMutation(baseOptions?: Apollo.MutationHookOptions<ISignInFlowMutation, ISignInFlowMutationVariables>): Apollo.MutationTuple<ISignInFlowMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInFlowMutationHookResult = ReturnType<typeof useSignInFlowMutation>;
+export type SignInFlowMutationResult = Apollo.MutationResult<ISignInFlowMutation>;
+export type SignInFlowMutationOptions = Apollo.BaseMutationOptions<ISignInFlowMutation, ISignInFlowMutationVariables>;
+export declare const SignInSolanaDocument: Apollo.DocumentNode;
+export type ISignInSolanaMutationFn = Apollo.MutationFunction<ISignInSolanaMutation, ISignInSolanaMutationVariables>;
+/**
+ * __useSignInSolanaMutation__
+ *
+ * To run a mutation, you first call `useSignInSolanaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInSolanaMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [signInSolanaMutation, { data, loading, error }] = useSignInSolanaMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export declare function useSignInSolanaMutation(baseOptions?: Apollo.MutationHookOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>): Apollo.MutationTuple<ISignInSolanaMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInSolanaMutationHookResult = ReturnType<typeof useSignInSolanaMutation>;
+export type SignInSolanaMutationResult = Apollo.MutationResult<ISignInSolanaMutation>;
+export type SignInSolanaMutationOptions = Apollo.BaseMutationOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>;
+export declare const SignInTezosDocument: Apollo.DocumentNode;
+export type ISignInTezosMutationFn = Apollo.MutationFunction<ISignInTezosMutation, ISignInTezosMutationVariables>;
+/**
+ * __useSignInTezosMutation__
+ *
+ * To run a mutation, you first call `useSignInTezosMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInTezosMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [signInTezosMutation, { data, loading, error }] = useSignInTezosMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export declare function useSignInTezosMutation(baseOptions?: Apollo.MutationHookOptions<ISignInTezosMutation, ISignInTezosMutationVariables>): Apollo.MutationTuple<ISignInTezosMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInTezosMutationHookResult = ReturnType<typeof useSignInTezosMutation>;
+export type SignInTezosMutationResult = Apollo.MutationResult<ISignInTezosMutation>;
+export type SignInTezosMutationOptions = Apollo.BaseMutationOptions<ISignInTezosMutation, ISignInTezosMutationVariables>;
+export declare const UpdateProfileDocument: Apollo.DocumentNode;
+export type IUpdateProfileMutationFn = Apollo.MutationFunction<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+/**
+ * __useUpdateProfileMutation__
+ *
+ * To run a mutation, you first call `useUpdateProfileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProfileMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateProfileMutation, { data, loading, error }] = useUpdateProfileMutation({
+ *   variables: {
+ *      username: // value for 'username'
+ *      about: // value for 'about'
+ *      facebook: // value for 'facebook'
+ *      twitter: // value for 'twitter'
+ *      instagram: // value for 'instagram'
+ *      website: // value for 'website'
+ *      showNsfw: // value for 'showNsfw'
+ *   },
+ * });
+ */
+export declare function useUpdateProfileMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>): Apollo.MutationTuple<IUpdateProfileMutation, Exact<{
+    username?: Maybe<string> | undefined;
+    about?: Maybe<string> | undefined;
+    facebook?: Maybe<string> | undefined;
+    twitter?: Maybe<string> | undefined;
+    instagram?: Maybe<string> | undefined;
+    website?: Maybe<string> | undefined;
+    showNsfw?: Maybe<boolean> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateProfileMutationHookResult = ReturnType<typeof useUpdateProfileMutation>;
+export type UpdateProfileMutationResult = Apollo.MutationResult<IUpdateProfileMutation>;
+export type UpdateProfileMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+export declare const FetchProfileDocument: Apollo.DocumentNode;
+/**
+ * __useFetchProfileQuery__
+ *
+ * To run a query within a React component, call `useFetchProfileQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchProfileQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useFetchProfileQuery(baseOptions: Apollo.QueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>): Apollo.QueryResult<IFetchProfileQuery, Exact<{
+    userId: string;
+}>>;
+export declare function useFetchProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>): Apollo.LazyQueryResultTuple<IFetchProfileQuery, Exact<{
+    userId: string;
+}>>;
+export type FetchProfileQueryHookResult = ReturnType<typeof useFetchProfileQuery>;
+export type FetchProfileLazyQueryHookResult = ReturnType<typeof useFetchProfileLazyQuery>;
+export type FetchProfileQueryResult = Apollo.QueryResult<IFetchProfileQuery, IFetchProfileQueryVariables>;
+export declare const FetchUserWalletsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserWalletsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserWalletsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserWalletsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserWalletsQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useFetchUserWalletsQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>): Apollo.QueryResult<IFetchUserWalletsQuery, Exact<{
+    userId: string;
+}>>;
+export declare function useFetchUserWalletsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserWalletsQuery, Exact<{
+    userId: string;
+}>>;
+export type FetchUserWalletsQueryHookResult = ReturnType<typeof useFetchUserWalletsQuery>;
+export type FetchUserWalletsLazyQueryHookResult = ReturnType<typeof useFetchUserWalletsLazyQuery>;
+export type FetchUserWalletsQueryResult = Apollo.QueryResult<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>;
+export declare const FetchUserpicDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserpicQuery__
+ *
+ * To run a query within a React component, call `useFetchUserpicQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserpicQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserpicQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useFetchUserpicQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserpicQuery, IFetchUserpicQueryVariables>): Apollo.QueryResult<IFetchUserpicQuery, Exact<{
+    userId: string;
+}>>;
+export declare function useFetchUserpicLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserpicQuery, IFetchUserpicQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserpicQuery, Exact<{
+    userId: string;
+}>>;
+export type FetchUserpicQueryHookResult = ReturnType<typeof useFetchUserpicQuery>;
+export type FetchUserpicLazyQueryHookResult = ReturnType<typeof useFetchUserpicLazyQuery>;
+export type FetchUserpicQueryResult = Apollo.QueryResult<IFetchUserpicQuery, IFetchUserpicQueryVariables>;
+export declare const SaveUserExpectationsDocument: Apollo.DocumentNode;
+export type ISaveUserExpectationsMutationFn = Apollo.MutationFunction<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>;
+/**
+ * __useSaveUserExpectationsMutation__
+ *
+ * To run a mutation, you first call `useSaveUserExpectationsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveUserExpectationsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [saveUserExpectationsMutation, { data, loading, error }] = useSaveUserExpectationsMutation({
+ *   variables: {
+ *      expectations: // value for 'expectations'
+ *   },
+ * });
+ */
+export declare function useSaveUserExpectationsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>): Apollo.MutationTuple<ISaveUserExpectationsMutation, Exact<{
+    expectations: Maybe<string>[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SaveUserExpectationsMutationHookResult = ReturnType<typeof useSaveUserExpectationsMutation>;
+export type SaveUserExpectationsMutationResult = Apollo.MutationResult<ISaveUserExpectationsMutation>;
+export type SaveUserExpectationsMutationOptions = Apollo.BaseMutationOptions<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>;
+export declare const SaveUserInterestsDocument: Apollo.DocumentNode;
+export type ISaveUserInterestsMutationFn = Apollo.MutationFunction<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>;
+/**
+ * __useSaveUserInterestsMutation__
+ *
+ * To run a mutation, you first call `useSaveUserInterestsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveUserInterestsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [saveUserInterestsMutation, { data, loading, error }] = useSaveUserInterestsMutation({
+ *   variables: {
+ *      interests: // value for 'interests'
+ *   },
+ * });
+ */
+export declare function useSaveUserInterestsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>): Apollo.MutationTuple<ISaveUserInterestsMutation, Exact<{
+    interests: Maybe<string>[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SaveUserInterestsMutationHookResult = ReturnType<typeof useSaveUserInterestsMutation>;
+export type SaveUserInterestsMutationResult = Apollo.MutationResult<ISaveUserInterestsMutation>;
+export type SaveUserInterestsMutationOptions = Apollo.BaseMutationOptions<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>;
+export declare const FetchExpectationsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchExpectationsQuery__
+ *
+ * To run a query within a React component, call `useFetchExpectationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchExpectationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchExpectationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchExpectationsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>): Apollo.QueryResult<IFetchExpectationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchExpectationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchExpectationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchExpectationsQueryHookResult = ReturnType<typeof useFetchExpectationsQuery>;
+export type FetchExpectationsLazyQueryHookResult = ReturnType<typeof useFetchExpectationsLazyQuery>;
+export type FetchExpectationsQueryResult = Apollo.QueryResult<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>;
+export declare const FetchInterestsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchInterestsQuery__
+ *
+ * To run a query within a React component, call `useFetchInterestsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchInterestsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchInterestsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchInterestsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchInterestsQuery, IFetchInterestsQueryVariables>): Apollo.QueryResult<IFetchInterestsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchInterestsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchInterestsQuery, IFetchInterestsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchInterestsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchInterestsQueryHookResult = ReturnType<typeof useFetchInterestsQuery>;
+export type FetchInterestsLazyQueryHookResult = ReturnType<typeof useFetchInterestsLazyQuery>;
+export type FetchInterestsQueryResult = Apollo.QueryResult<IFetchInterestsQuery, IFetchInterestsQueryVariables>;
+export declare const FetchSearchResultTimeSelectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchSearchResultTimeSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultTimeSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultTimeSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultTimeSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchSearchResultTimeSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>): Apollo.QueryResult<IFetchSearchResultTimeSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchSearchResultTimeSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchSearchResultTimeSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchSearchResultTimeSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultTimeSelectionsQuery>;
+export type FetchSearchResultTimeSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultTimeSelectionsLazyQuery>;
+export type FetchSearchResultTimeSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>;
+export declare const FetchUserExpectationsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserExpectationsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserExpectationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserExpectationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserExpectationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchUserExpectationsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>): Apollo.QueryResult<IFetchUserExpectationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchUserExpectationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserExpectationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchUserExpectationsQueryHookResult = ReturnType<typeof useFetchUserExpectationsQuery>;
+export type FetchUserExpectationsLazyQueryHookResult = ReturnType<typeof useFetchUserExpectationsLazyQuery>;
+export type FetchUserExpectationsQueryResult = Apollo.QueryResult<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>;
+export declare const FetchUserInterestsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserInterestsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserInterestsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserInterestsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserInterestsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchUserInterestsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>): Apollo.QueryResult<IFetchUserInterestsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchUserInterestsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserInterestsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchUserInterestsQueryHookResult = ReturnType<typeof useFetchUserInterestsQuery>;
+export type FetchUserInterestsLazyQueryHookResult = ReturnType<typeof useFetchUserInterestsLazyQuery>;
+export type FetchUserInterestsQueryResult = Apollo.QueryResult<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>;
+export declare const FetchSearchResultBlockchainSelectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchSearchResultBlockchainSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultBlockchainSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultBlockchainSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultBlockchainSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchSearchResultBlockchainSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>): Apollo.QueryResult<IFetchSearchResultBlockchainSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchSearchResultBlockchainSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchSearchResultBlockchainSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchSearchResultBlockchainSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultBlockchainSelectionsQuery>;
+export type FetchSearchResultBlockchainSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultBlockchainSelectionsLazyQuery>;
+export type FetchSearchResultBlockchainSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>;
+export declare const FetchSearchResultCategorySelectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchSearchResultCategorySelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultCategorySelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultCategorySelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultCategorySelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchSearchResultCategorySelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>): Apollo.QueryResult<IFetchSearchResultCategorySelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchSearchResultCategorySelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchSearchResultCategorySelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchSearchResultCategorySelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultCategorySelectionsQuery>;
+export type FetchSearchResultCategorySelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultCategorySelectionsLazyQuery>;
+export type FetchSearchResultCategorySelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>;
+export declare const FetchSearchResultStatusSelectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchSearchResultStatusSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultStatusSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultStatusSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultStatusSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchSearchResultStatusSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>): Apollo.QueryResult<IFetchSearchResultStatusSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchSearchResultStatusSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchSearchResultStatusSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchSearchResultStatusSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultStatusSelectionsQuery>;
+export type FetchSearchResultStatusSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultStatusSelectionsLazyQuery>;
+export type FetchSearchResultStatusSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>;
+export declare const FetchSetsSearchResultTypeSelectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchSetsSearchResultTypeSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSetsSearchResultTypeSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSetsSearchResultTypeSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSetsSearchResultTypeSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchSetsSearchResultTypeSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>): Apollo.QueryResult<IFetchSetsSearchResultTypeSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchSetsSearchResultTypeSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchSetsSearchResultTypeSelectionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchSetsSearchResultTypeSelectionsQueryHookResult = ReturnType<typeof useFetchSetsSearchResultTypeSelectionsQuery>;
+export type FetchSetsSearchResultTypeSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSetsSearchResultTypeSelectionsLazyQuery>;
+export type FetchSetsSearchResultTypeSelectionsQueryResult = Apollo.QueryResult<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>;
+export declare const FetchAssetsCountDocument: Apollo.DocumentNode;
+/**
+ * __useFetchAssetsCountQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetsCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetsCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchAssetsCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchAssetsCountQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAssetsCountQuery, IFetchAssetsCountQueryVariables>): Apollo.QueryResult<IFetchAssetsCountQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchAssetsCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetsCountQuery, IFetchAssetsCountQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAssetsCountQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchAssetsCountQueryHookResult = ReturnType<typeof useFetchAssetsCountQuery>;
+export type FetchAssetsCountLazyQueryHookResult = ReturnType<typeof useFetchAssetsCountLazyQuery>;
+export type FetchAssetsCountQueryResult = Apollo.QueryResult<IFetchAssetsCountQuery, IFetchAssetsCountQueryVariables>;
+export declare const FindCollectionsDocument: Apollo.DocumentNode;
+/**
+ * __useFindCollectionsQuery__
+ *
+ * To run a query within a React component, call `useFindCollectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindCollectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindCollectionsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindCollectionsQuery(baseOptions: Apollo.QueryHookOptions<IFindCollectionsQuery, IFindCollectionsQueryVariables>): Apollo.QueryResult<IFindCollectionsQuery, Exact<{
+    term: string;
+    input: ICollectionFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindCollectionsQuery, IFindCollectionsQueryVariables>): Apollo.LazyQueryResultTuple<IFindCollectionsQuery, Exact<{
+    term: string;
+    input: ICollectionFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindCollectionsQueryHookResult = ReturnType<typeof useFindCollectionsQuery>;
+export type FindCollectionsLazyQueryHookResult = ReturnType<typeof useFindCollectionsLazyQuery>;
+export type FindCollectionsQueryResult = Apollo.QueryResult<IFindCollectionsQuery, IFindCollectionsQueryVariables>;
+export declare const FetchCreationsDocument: Apollo.DocumentNode;
+/**
+ * __useFetchCreationsQuery__
+ *
+ * To run a query within a React component, call `useFetchCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCreationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchCreationsQuery({
+ *   variables: {
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCreationsQuery, IFetchCreationsQueryVariables>): Apollo.QueryResult<IFetchCreationsQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCreationsQuery, IFetchCreationsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchCreationsQuery, Exact<{
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchCreationsQueryHookResult = ReturnType<typeof useFetchCreationsQuery>;
+export type FetchCreationsLazyQueryHookResult = ReturnType<typeof useFetchCreationsLazyQuery>;
+export type FetchCreationsQueryResult = Apollo.QueryResult<IFetchCreationsQuery, IFetchCreationsQueryVariables>;
+export declare const FetchCreationsByItemTypeDocument: Apollo.DocumentNode;
+/**
+ * __useFetchCreationsByItemTypeQuery__
+ *
+ * To run a query within a React component, call `useFetchCreationsByItemTypeQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCreationsByItemTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchCreationsByItemTypeQuery({
+ *   variables: {
+ *      itemType: // value for 'itemType'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFetchCreationsByItemTypeQuery(baseOptions: Apollo.QueryHookOptions<IFetchCreationsByItemTypeQuery, IFetchCreationsByItemTypeQueryVariables>): Apollo.QueryResult<IFetchCreationsByItemTypeQuery, Exact<{
+    itemType: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchCreationsByItemTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCreationsByItemTypeQuery, IFetchCreationsByItemTypeQueryVariables>): Apollo.LazyQueryResultTuple<IFetchCreationsByItemTypeQuery, Exact<{
+    itemType: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FetchCreationsByItemTypeQueryHookResult = ReturnType<typeof useFetchCreationsByItemTypeQuery>;
+export type FetchCreationsByItemTypeLazyQueryHookResult = ReturnType<typeof useFetchCreationsByItemTypeLazyQuery>;
+export type FetchCreationsByItemTypeQueryResult = Apollo.QueryResult<IFetchCreationsByItemTypeQuery, IFetchCreationsByItemTypeQueryVariables>;
+export declare const FindAllTopEntitiesByNameDocument: Apollo.DocumentNode;
+/**
+ * __useFindAllTopEntitiesByNameQuery__
+ *
+ * To run a query within a React component, call `useFindAllTopEntitiesByNameQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindAllTopEntitiesByNameQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindAllTopEntitiesByNameQuery({
+ *   variables: {
+ *      name: // value for 'name'
+ *      pageSize: // value for 'pageSize'
+ *   },
+ * });
+ */
+export declare function useFindAllTopEntitiesByNameQuery(baseOptions: Apollo.QueryHookOptions<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>): Apollo.QueryResult<IFindAllTopEntitiesByNameQuery, Exact<{
+    name: string;
+    pageSize: number;
+}>>;
+export declare function useFindAllTopEntitiesByNameLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>): Apollo.LazyQueryResultTuple<IFindAllTopEntitiesByNameQuery, Exact<{
+    name: string;
+    pageSize: number;
+}>>;
+export type FindAllTopEntitiesByNameQueryHookResult = ReturnType<typeof useFindAllTopEntitiesByNameQuery>;
+export type FindAllTopEntitiesByNameLazyQueryHookResult = ReturnType<typeof useFindAllTopEntitiesByNameLazyQuery>;
+export type FindAllTopEntitiesByNameQueryResult = Apollo.QueryResult<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>;
+export declare const FetchUserPortfolioDocument: Apollo.DocumentNode;
+/**
+ * __useFetchUserPortfolioQuery__
+ *
+ * To run a query within a React component, call `useFetchUserPortfolioQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserPortfolioQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserPortfolioQuery({
+ *   variables: {
+ *      ownerId: // value for 'ownerId'
+ *   },
+ * });
+ */
+export declare function useFetchUserPortfolioQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>): Apollo.QueryResult<IFetchUserPortfolioQuery, Exact<{
+    ownerId: string;
+}>>;
+export declare function useFetchUserPortfolioLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserPortfolioQuery, Exact<{
+    ownerId: string;
+}>>;
+export type FetchUserPortfolioQueryHookResult = ReturnType<typeof useFetchUserPortfolioQuery>;
+export type FetchUserPortfolioLazyQueryHookResult = ReturnType<typeof useFetchUserPortfolioLazyQuery>;
+export type FetchUserPortfolioQueryResult = Apollo.QueryResult<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>;
+export declare const FindCreationsDocument: Apollo.DocumentNode;
+/**
+ * __useFindCreationsQuery__
+ *
+ * To run a query within a React component, call `useFindCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindCreationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindCreationsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFindCreationsQuery, IFindCreationsQueryVariables>): Apollo.QueryResult<IFindCreationsQuery, Exact<{
+    term: string;
+    input: ICreationFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindCreationsQuery, IFindCreationsQueryVariables>): Apollo.LazyQueryResultTuple<IFindCreationsQuery, Exact<{
+    term: string;
+    input: ICreationFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindCreationsQueryHookResult = ReturnType<typeof useFindCreationsQuery>;
+export type FindCreationsLazyQueryHookResult = ReturnType<typeof useFindCreationsLazyQuery>;
+export type FindCreationsQueryResult = Apollo.QueryResult<IFindCreationsQuery, IFindCreationsQueryVariables>;
+export declare const FindProfilesByNameDocument: Apollo.DocumentNode;
+/**
+ * __useFindProfilesByNameQuery__
+ *
+ * To run a query within a React component, call `useFindProfilesByNameQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindProfilesByNameQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindProfilesByNameQuery({
+ *   variables: {
+ *      name: // value for 'name'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindProfilesByNameQuery(baseOptions: Apollo.QueryHookOptions<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>): Apollo.QueryResult<IFindProfilesByNameQuery, Exact<{
+    name: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindProfilesByNameLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>): Apollo.LazyQueryResultTuple<IFindProfilesByNameQuery, Exact<{
+    name: string;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindProfilesByNameQueryHookResult = ReturnType<typeof useFindProfilesByNameQuery>;
+export type FindProfilesByNameLazyQueryHookResult = ReturnType<typeof useFindProfilesByNameLazyQuery>;
+export type FindProfilesByNameQueryResult = Apollo.QueryResult<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>;
+export declare const FindSetsDocument: Apollo.DocumentNode;
+/**
+ * __useFindSetsQuery__
+ *
+ * To run a query within a React component, call `useFindSetsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindSetsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindSetsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindSetsQuery(baseOptions: Apollo.QueryHookOptions<IFindSetsQuery, IFindSetsQueryVariables>): Apollo.QueryResult<IFindSetsQuery, Exact<{
+    term: string;
+    input: IGallerySearchFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindSetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindSetsQuery, IFindSetsQueryVariables>): Apollo.LazyQueryResultTuple<IFindSetsQuery, Exact<{
+    term: string;
+    input: IGallerySearchFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindSetsQueryHookResult = ReturnType<typeof useFindSetsQuery>;
+export type FindSetsLazyQueryHookResult = ReturnType<typeof useFindSetsLazyQuery>;
+export type FindSetsQueryResult = Apollo.QueryResult<IFindSetsQuery, IFindSetsQueryVariables>;
+export declare const FindShowcaseItemsDocument: Apollo.DocumentNode;
+/**
+ * __useFindShowcaseItemsQuery__
+ *
+ * To run a query within a React component, call `useFindShowcaseItemsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindShowcaseItemsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindShowcaseItemsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindShowcaseItemsQuery(baseOptions: Apollo.QueryHookOptions<IFindShowcaseItemsQuery, IFindShowcaseItemsQueryVariables>): Apollo.QueryResult<IFindShowcaseItemsQuery, Exact<{
+    term: string;
+    input: IShowcaseItemFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindShowcaseItemsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindShowcaseItemsQuery, IFindShowcaseItemsQueryVariables>): Apollo.LazyQueryResultTuple<IFindShowcaseItemsQuery, Exact<{
+    term: string;
+    input: IShowcaseItemFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindShowcaseItemsQueryHookResult = ReturnType<typeof useFindShowcaseItemsQuery>;
+export type FindShowcaseItemsLazyQueryHookResult = ReturnType<typeof useFindShowcaseItemsLazyQuery>;
+export type FindShowcaseItemsQueryResult = Apollo.QueryResult<IFindShowcaseItemsQuery, IFindShowcaseItemsQueryVariables>;
+export declare const FindUserCreationsDocument: Apollo.DocumentNode;
+/**
+ * __useFindUserCreationsQuery__
+ *
+ * To run a query within a React component, call `useFindUserCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindUserCreationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindUserCreationsQuery({
+ *   variables: {
+ *      ownerId: // value for 'ownerId'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindUserCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>): Apollo.QueryResult<IFindUserCreationsQuery, Exact<{
+    ownerId: string;
+    input: ICreationFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindUserCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>): Apollo.LazyQueryResultTuple<IFindUserCreationsQuery, Exact<{
+    ownerId: string;
+    input: ICreationFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindUserCreationsQueryHookResult = ReturnType<typeof useFindUserCreationsQuery>;
+export type FindUserCreationsLazyQueryHookResult = ReturnType<typeof useFindUserCreationsLazyQuery>;
+export type FindUserCreationsQueryResult = Apollo.QueryResult<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>;
+export declare const FindUserShowcaseItemsDocument: Apollo.DocumentNode;
+/**
+ * __useFindUserShowcaseItemsQuery__
+ *
+ * To run a query within a React component, call `useFindUserShowcaseItemsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindUserShowcaseItemsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFindUserShowcaseItemsQuery({
+ *   variables: {
+ *      ownerId: // value for 'ownerId'
+ *      input: // value for 'input'
+ *      pageSize: // value for 'pageSize'
+ *      pageToken: // value for 'pageToken'
+ *   },
+ * });
+ */
+export declare function useFindUserShowcaseItemsQuery(baseOptions: Apollo.QueryHookOptions<IFindUserShowcaseItemsQuery, IFindUserShowcaseItemsQueryVariables>): Apollo.QueryResult<IFindUserShowcaseItemsQuery, Exact<{
+    ownerId: string;
+    input: IShowcaseItemFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export declare function useFindUserShowcaseItemsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindUserShowcaseItemsQuery, IFindUserShowcaseItemsQueryVariables>): Apollo.LazyQueryResultTuple<IFindUserShowcaseItemsQuery, Exact<{
+    ownerId: string;
+    input: IShowcaseItemFilterInput;
+    pageSize: number;
+    pageToken?: Maybe<string> | undefined;
+}>>;
+export type FindUserShowcaseItemsQueryHookResult = ReturnType<typeof useFindUserShowcaseItemsQuery>;
+export type FindUserShowcaseItemsLazyQueryHookResult = ReturnType<typeof useFindUserShowcaseItemsLazyQuery>;
+export type FindUserShowcaseItemsQueryResult = Apollo.QueryResult<IFindUserShowcaseItemsQuery, IFindUserShowcaseItemsQueryVariables>;