@ludo.ninja/api 2.8.8 → 2.8.10

package/src/graphql_tools/__generated__/schema.ts

@@ -360,11 +360,14 @@ export type ICategory = {
 };
 
 export type ICollection = {
+  blockHeight?: Maybe<Scalars['Long']>;
+  blockTimestamp?: Maybe<Scalars['Long']>;
   blockchain?: Maybe<Scalars['String']>;
   collectionAssets?: Maybe<Array<Maybe<ICollectionAsset>>>;
-  collectionId?: Maybe<Scalars['String']>;
+  collectionId: Scalars['String'];
   collectionMarkets?: Maybe<Array<Maybe<ICollectionMarket>>>;
   collectionTitle?: Maybe<Scalars['String']>;
+  collectionUrl?: Maybe<Scalars['String']>;
   contractAddress?: Maybe<Scalars['String']>;
   creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
   creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
@@ -515,10 +518,10 @@ export type IDynamicAssetData = {
 };
 
 export type IDynamicCollectionData = {
+  collectionId: Scalars['String'];
   isLikedByUser?: Maybe<Scalars['Boolean']>;
   likesNum?: Maybe<Scalars['Int']>;
-  collectionAssetsPage?: Maybe<ICollectionAssetsPage>;
-  collectionId?: Maybe<Scalars['String']>;
+  collectionAssetsPage?: Maybe<IAssetsPage>;
 };
 
 export type IDynamicCollectionDataInput = {
@@ -893,6 +896,7 @@ export type IMutation = {
   blockUser: Scalars['Boolean'];
   blockUsers: Scalars['Boolean'];
   changeXpPoints: Scalars['Boolean'];
+  createAdminOpportunity: Scalars['Boolean'];
   createBrand: Scalars['Boolean'];
   createCategory: Scalars['Boolean'];
   createFavoriteListV2: Scalars['ID'];
@@ -1120,6 +1124,12 @@ export type IMutationChangeXpPointsArgs = {
 };
 
 
+export type IMutationCreateAdminOpportunityArgs = {
+  input: IOpportunityInput;
+  file?: Maybe<Scalars['Upload']>;
+};
+
+
 export type IMutationCreateBrandArgs = {
   brand: IBrandInput;
   file?: Maybe<Scalars['Upload']>;
@@ -1172,7 +1182,6 @@ export type IMutationCreateNonceArgs = {
 
 
 export type IMutationCreateOpportunityArgs = {
-  file?: Maybe<Scalars['Upload']>;
   input: IOpportunityInput;
 };
 
@@ -2122,7 +2131,7 @@ export type IQueryFetchDynamicCollectionDataArgs = {
 
 
 export type IQueryFetchDynamicCollectionsDataArgs = {
-  input: Array<IDynamicCollectionDataInput>;
+  inputs: Array<IDynamicCollectionDataInput>;
 };
 
 
@@ -2963,6 +2972,30 @@ export type IChangeXpPointsMutationVariables = Exact<{
 
 export type IChangeXpPointsMutation = Pick<IMutation, 'changeXpPoints'>;
 
+export type ICreateCategoryMutationVariables = Exact<{
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+}>;
+
+
+export type ICreateCategoryMutation = Pick<IMutation, 'createCategory'>;
+
+export type ICreateBrandMutationVariables = Exact<{
+  brand: IBrandInput;
+  file?: Maybe<Scalars['Upload']>;
+}>;
+
+
+export type ICreateBrandMutation = Pick<IMutation, 'createBrand'>;
+
+export type ICreateAdminOpportunityMutationVariables = Exact<{
+  file?: Maybe<Scalars['Upload']>;
+  input: IOpportunityInput;
+}>;
+
+
+export type ICreateAdminOpportunityMutation = Pick<IMutation, 'createAdminOpportunity'>;
+
 export type IAddInviteCodesMutationVariables = Exact<{
   userId: Scalars['String'];
   codesNum: Scalars['Int'];
@@ -3088,16 +3121,6 @@ export type ILikeCollectionMutationVariables = Exact<{
 
 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']>;
@@ -3113,48 +3136,6 @@ export type IFetchCollectionsQuery = { fetchCollectionAssets: (
     )>>> }
   ) };
 
-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, 'id' | '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, 'id' | '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 IFetchMyExperienceV2QueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -3914,6 +3895,16 @@ export type IFetchAssetsCountQueryVariables = Exact<{ [key: string]: never; }>;
 
 export type IFetchAssetsCountQuery = Pick<IQuery, 'fetchAssetsCount'>;
 
+export type IFetchCollectionQueryVariables = Exact<{
+  collectionId: Scalars['String'];
+}>;
+
+
+export type IFetchCollectionQuery = { fetchCollection: (
+    Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'blockHeight' | 'blockTimestamp' | 'collectionTitle' | 'collectionUrl' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank' | 'nsfw'>
+    & { 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'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+  ) };
+
 export type IFindCollectionsQueryVariables = Exact<{
   term: Scalars['String'];
   input: ICollectionFilterInput;
@@ -3926,6 +3917,16 @@ export type IFindCollectionsQuery = { findCollections: { collections: Array<Mayb
       & { medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>> }
     )>>, nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>> } };
 
+export type IFetchCollectionsByIdsQueryVariables = Exact<{
+  collectionIds: Array<Scalars['String']>;
+}>;
+
+
+export type IFetchCollectionsByIdsQuery = { fetchCollectionsByIds: Array<(
+    Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'blockHeight' | 'blockTimestamp' | 'collectionTitle' | 'collectionUrl' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank' | 'nsfw'>
+    & { 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'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+  )> };
+
 export type IFetchCreationsByTypeQueryVariables = Exact<{
   itemType: Scalars['String'];
   page?: Maybe<IPageInput>;
@@ -3948,6 +3949,38 @@ export type IFetchDynamicAssetsLikesQueryVariables = Exact<{
 
 export type IFetchDynamicAssetsLikesQuery = { fetchDynamicAssetsData: Array<Maybe<Pick<IDynamicAssetData, 'isLikedByUser' | 'likesNum' | 'assetId'>>> };
 
+export type IFetchDynamicCollectionDataQueryVariables = Exact<{
+  input: IDynamicCollectionDataInput;
+}>;
+
+
+export type IFetchDynamicCollectionDataQuery = { fetchDynamicCollectionData: (
+    Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'>
+    & { collectionAssetsPage?: Maybe<(
+      Pick<IAssetsPage, 'nextPageToken'>
+      & { assets: 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 IFetchDynamicCollectionsDataQueryVariables = Exact<{
+  input: Array<IDynamicCollectionDataInput>;
+}>;
+
+
+export type IFetchDynamicCollectionsDataQuery = { fetchDynamicCollectionsData: Array<(
+    Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'>
+    & { collectionAssetsPage?: Maybe<(
+      Pick<IAssetsPage, 'nextPageToken'>
+      & { assets: 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 IFindAllTopEntitiesByNameQueryVariables = Exact<{
   name: Scalars['String'];
   pageSize: Scalars['Int'];
@@ -4066,6 +4099,99 @@ export function useChangeXpPointsMutation(baseOptions?: Apollo.MutationHookOptio
 export type ChangeXpPointsMutationHookResult = ReturnType<typeof useChangeXpPointsMutation>;
 export type ChangeXpPointsMutationResult = Apollo.MutationResult<IChangeXpPointsMutation>;
 export type ChangeXpPointsMutationOptions = Apollo.BaseMutationOptions<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>;
+export const CreateCategoryDocument = gql`
+    mutation CreateCategory($name: String!, $matchingWords: [String!]!) {
+  createCategory(name: $name, matchingWords: $matchingWords)
+}
+    `;
+export type ICreateCategoryMutationFn = Apollo.MutationFunction<ICreateCategoryMutation, ICreateCategoryMutationVariables>;
+
+/**
+ * __useCreateCategoryMutation__
+ *
+ * To run a mutation, you first call `useCreateCategoryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateCategoryMutation` 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 [createCategoryMutation, { data, loading, error }] = useCreateCategoryMutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      matchingWords: // value for 'matchingWords'
+ *   },
+ * });
+ */
+export function useCreateCategoryMutation(baseOptions?: Apollo.MutationHookOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>) {
+        return Apollo.useMutation<ICreateCategoryMutation, ICreateCategoryMutationVariables>(CreateCategoryDocument, baseOptions);
+      }
+export type CreateCategoryMutationHookResult = ReturnType<typeof useCreateCategoryMutation>;
+export type CreateCategoryMutationResult = Apollo.MutationResult<ICreateCategoryMutation>;
+export type CreateCategoryMutationOptions = Apollo.BaseMutationOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>;
+export const CreateBrandDocument = gql`
+    mutation CreateBrand($brand: BrandInput!, $file: Upload) {
+  createBrand(brand: $brand, file: $file)
+}
+    `;
+export type ICreateBrandMutationFn = Apollo.MutationFunction<ICreateBrandMutation, ICreateBrandMutationVariables>;
+
+/**
+ * __useCreateBrandMutation__
+ *
+ * To run a mutation, you first call `useCreateBrandMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateBrandMutation` 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 [createBrandMutation, { data, loading, error }] = useCreateBrandMutation({
+ *   variables: {
+ *      brand: // value for 'brand'
+ *      file: // value for 'file'
+ *   },
+ * });
+ */
+export function useCreateBrandMutation(baseOptions?: Apollo.MutationHookOptions<ICreateBrandMutation, ICreateBrandMutationVariables>) {
+        return Apollo.useMutation<ICreateBrandMutation, ICreateBrandMutationVariables>(CreateBrandDocument, baseOptions);
+      }
+export type CreateBrandMutationHookResult = ReturnType<typeof useCreateBrandMutation>;
+export type CreateBrandMutationResult = Apollo.MutationResult<ICreateBrandMutation>;
+export type CreateBrandMutationOptions = Apollo.BaseMutationOptions<ICreateBrandMutation, ICreateBrandMutationVariables>;
+export const CreateAdminOpportunityDocument = gql`
+    mutation createAdminOpportunity($file: Upload, $input: OpportunityInput!) {
+  createAdminOpportunity(file: $file, input: $input)
+}
+    `;
+export type ICreateAdminOpportunityMutationFn = Apollo.MutationFunction<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>;
+
+/**
+ * __useCreateAdminOpportunityMutation__
+ *
+ * To run a mutation, you first call `useCreateAdminOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateAdminOpportunityMutation` 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 [createAdminOpportunityMutation, { data, loading, error }] = useCreateAdminOpportunityMutation({
+ *   variables: {
+ *      file: // value for 'file'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateAdminOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>) {
+        return Apollo.useMutation<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>(CreateAdminOpportunityDocument, baseOptions);
+      }
+export type CreateAdminOpportunityMutationHookResult = ReturnType<typeof useCreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationResult = Apollo.MutationResult<ICreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationOptions = Apollo.BaseMutationOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>;
 export const AddInviteCodesDocument = gql`
     mutation AddInviteCodes($userId: String!, $codesNum: Int!) {
   addInviteCodes(userId: $userId, codesNum: $codesNum)
@@ -4712,70 +4838,6 @@ export function useLikeCollectionMutation(baseOptions?: Apollo.MutationHookOptio
 export type LikeCollectionMutationHookResult = ReturnType<typeof useLikeCollectionMutation>;
 export type LikeCollectionMutationResult = Apollo.MutationResult<ILikeCollectionMutation>;
 export type LikeCollectionMutationOptions = Apollo.BaseMutationOptions<ILikeCollectionMutation, ILikeCollectionMutationVariables>;
-export const FetchCollectionDocument = gql`
-    query fetchCollection($collectionId: String!) {
-  fetchCollection(collectionId: $collectionId) {
-    collectionId
-    blockchain
-    identifier
-    contractAddress
-    tokenId
-    collectionTitle
-    items
-    owners
-    totalVolumes {
-      currency
-      amount
-    }
-    likes
-    liked
-    collectionMarkets {
-      marketId
-      marketName
-      marketDomain
-      marketUrl
-    }
-    creatorsAddresses
-    creatorsProfiles {
-      username
-      userpic
-    }
-    verified
-    originalUrls
-    rank
-    floorPrices {
-      currency
-      amount
-    }
-  }
-}
-    `;
-
-/**
- * __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 function useFetchCollectionQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
-        return Apollo.useQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
-      }
-export function useFetchCollectionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
-          return Apollo.useLazyQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
-        }
-export type FetchCollectionQueryHookResult = ReturnType<typeof useFetchCollectionQuery>;
-export type FetchCollectionLazyQueryHookResult = ReturnType<typeof useFetchCollectionLazyQuery>;
-export type FetchCollectionQueryResult = Apollo.QueryResult<IFetchCollectionQuery, IFetchCollectionQueryVariables>;
 export const FetchCollectionsDocument = gql`
     query fetchCollections($pageSize: Int!, $pageToken: String, $collectionId: String!) {
   fetchCollectionAssets(
@@ -4844,203 +4906,6 @@ export function useFetchCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookO
 export type FetchCollectionsQueryHookResult = ReturnType<typeof useFetchCollectionsQuery>;
 export type FetchCollectionsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsLazyQuery>;
 export type FetchCollectionsQueryResult = Apollo.QueryResult<IFetchCollectionsQuery, IFetchCollectionsQueryVariables>;
-export const FetchCollectionsByIdsDocument = gql`
-    query FetchCollectionsByIds($collectionIds: [String!]!) {
-  fetchCollectionsByIds(collectionIds: $collectionIds) {
-    collectionId
-    blockchain
-    identifier
-    contractAddress
-    tokenId
-    collectionTitle
-    items
-    owners
-    totalVolumes {
-      currency
-      amount
-    }
-    likes
-    liked
-    collectionMarkets {
-      marketName
-      marketDomain
-      marketUrl
-    }
-    creatorsAddresses
-    creatorsProfiles {
-      username
-      userpic
-    }
-    verified
-    originalUrls
-    rank
-    floorPrices {
-      currency
-      amount
-    }
-  }
-}
-    `;
-
-/**
- * __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 function useFetchCollectionsByIdsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
-        return Apollo.useQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
-      }
-export function useFetchCollectionsByIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
-          return Apollo.useLazyQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
-        }
-export type FetchCollectionsByIdsQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsQuery>;
-export type FetchCollectionsByIdsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsLazyQuery>;
-export type FetchCollectionsByIdsQueryResult = Apollo.QueryResult<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>;
-export const FetchDynamicCollectionDataDocument = gql`
-    query FetchDynamicCollectionData($input: DynamicCollectionDataInput!) {
-  fetchDynamicCollectionData(input: $input) {
-    isLikedByUser
-    likesNum
-    collectionId
-    collectionAssetsPage {
-      nextPageToken
-      collectionAssets {
-        id
-        collectionId
-        collectionTitle
-        assetId
-        blockchain
-        address
-        tokenId
-        chainId
-        creatorsAddresses
-        originalUrls
-        name
-        description
-        likes
-        liked
-        views
-        medias {
-          originalUrl
-          url
-          previewUrl
-          mimeType
-          sizeRatio
-          fileSize
-        }
-        visible
-        createdAt
-        blurred
-        rank
-      }
-    }
-  }
-}
-    `;
-
-/**
- * __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 function useFetchDynamicCollectionDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
-        return Apollo.useQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
-      }
-export function useFetchDynamicCollectionDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
-          return Apollo.useLazyQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
-        }
-export type FetchDynamicCollectionDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataQuery>;
-export type FetchDynamicCollectionDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataLazyQuery>;
-export type FetchDynamicCollectionDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>;
-export const FetchDynamicCollectionsDataDocument = gql`
-    query FetchDynamicCollectionsData($input: [DynamicCollectionDataInput!]!) {
-  fetchDynamicCollectionsData(input: $input) {
-    isLikedByUser
-    likesNum
-    collectionId
-    collectionAssetsPage {
-      nextPageToken
-      collectionAssets {
-        id
-        collectionId
-        collectionTitle
-        assetId
-        blockchain
-        address
-        tokenId
-        chainId
-        creatorsAddresses
-        originalUrls
-        name
-        description
-        likes
-        liked
-        views
-        medias {
-          originalUrl
-          url
-          previewUrl
-          mimeType
-          sizeRatio
-          fileSize
-        }
-        visible
-        createdAt
-        blurred
-        rank
-      }
-    }
-  }
-}
-    `;
-
-/**
- * __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 function useFetchDynamicCollectionsDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
-        return Apollo.useQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
-      }
-export function useFetchDynamicCollectionsDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
-          return Apollo.useLazyQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
-        }
-export type FetchDynamicCollectionsDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataQuery>;
-export type FetchDynamicCollectionsDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataLazyQuery>;
-export type FetchDynamicCollectionsDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>;
 export const FetchMyExperienceV2Document = gql`
     query FetchMyExperienceV2 {
   fetchMyExperienceV2 {
@@ -8710,6 +8575,81 @@ export function useFetchAssetsCountLazyQuery(baseOptions?: Apollo.LazyQueryHookO
 export type FetchAssetsCountQueryHookResult = ReturnType<typeof useFetchAssetsCountQuery>;
 export type FetchAssetsCountLazyQueryHookResult = ReturnType<typeof useFetchAssetsCountLazyQuery>;
 export type FetchAssetsCountQueryResult = Apollo.QueryResult<IFetchAssetsCountQuery, IFetchAssetsCountQueryVariables>;
+export const FetchCollectionDocument = gql`
+    query fetchCollection($collectionId: String!) {
+  fetchCollection(collectionId: $collectionId) {
+    collectionId
+    blockchain
+    identifier
+    contractAddress
+    tokenId
+    blockHeight
+    blockTimestamp
+    collectionTitle
+    collectionUrl
+    items
+    owners
+    totalVolumes {
+      currency
+      amount
+    }
+    likes
+    liked
+    collectionMarkets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      username
+      userpic
+    }
+    verified
+    originalUrls
+    rank
+    nsfw
+    medias {
+      originalUrl
+      url
+      mimeType
+      sizeRatio
+      fileSize
+    }
+    floorPrices {
+      currency
+      amount
+    }
+  }
+}
+    `;
+
+/**
+ * __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 function useFetchCollectionQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
+        return Apollo.useQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
+      }
+export function useFetchCollectionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
+        }
+export type FetchCollectionQueryHookResult = ReturnType<typeof useFetchCollectionQuery>;
+export type FetchCollectionLazyQueryHookResult = ReturnType<typeof useFetchCollectionLazyQuery>;
+export type FetchCollectionQueryResult = Apollo.QueryResult<IFetchCollectionQuery, IFetchCollectionQueryVariables>;
 export const FindCollectionsDocument = gql`
     query FindCollections($term: String!, $input: CollectionFilterInput!, $page: PageInput) {
   findCollections(term: $term, input: $input, page: $page) {
@@ -8767,6 +8707,81 @@ export function useFindCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOp
 export type FindCollectionsQueryHookResult = ReturnType<typeof useFindCollectionsQuery>;
 export type FindCollectionsLazyQueryHookResult = ReturnType<typeof useFindCollectionsLazyQuery>;
 export type FindCollectionsQueryResult = Apollo.QueryResult<IFindCollectionsQuery, IFindCollectionsQueryVariables>;
+export const FetchCollectionsByIdsDocument = gql`
+    query FetchCollectionsByIds($collectionIds: [String!]!) {
+  fetchCollectionsByIds(collectionIds: $collectionIds) {
+    collectionId
+    blockchain
+    identifier
+    contractAddress
+    tokenId
+    blockHeight
+    blockTimestamp
+    collectionTitle
+    collectionUrl
+    items
+    owners
+    totalVolumes {
+      currency
+      amount
+    }
+    likes
+    liked
+    collectionMarkets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      username
+      userpic
+    }
+    verified
+    originalUrls
+    rank
+    nsfw
+    medias {
+      originalUrl
+      url
+      mimeType
+      sizeRatio
+      fileSize
+    }
+    floorPrices {
+      currency
+      amount
+    }
+  }
+}
+    `;
+
+/**
+ * __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 function useFetchCollectionsByIdsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
+        return Apollo.useQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
+      }
+export function useFetchCollectionsByIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
+        }
+export type FetchCollectionsByIdsQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsQuery>;
+export type FetchCollectionsByIdsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsLazyQuery>;
+export type FetchCollectionsByIdsQueryResult = Apollo.QueryResult<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>;
 export const FetchCreationsByTypeDocument = gql`
     query FetchCreationsByType($itemType: String!, $page: PageInput) {
   fetchCreationsByType(itemType: $itemType, page: $page) {
@@ -8892,6 +8907,236 @@ export function useFetchDynamicAssetsLikesLazyQuery(baseOptions?: Apollo.LazyQue
 export type FetchDynamicAssetsLikesQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesQuery>;
 export type FetchDynamicAssetsLikesLazyQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesLazyQuery>;
 export type FetchDynamicAssetsLikesQueryResult = Apollo.QueryResult<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>;
+export const FetchDynamicCollectionDataDocument = gql`
+    query FetchDynamicCollectionData($input: DynamicCollectionDataInput!) {
+  fetchDynamicCollectionData(input: $input) {
+    isLikedByUser
+    likesNum
+    collectionId
+    collectionAssetsPage {
+      nextPageToken
+      assets {
+        latestPriceCurrency
+        latestPriceAmount
+        collectionId
+        collectionOriginalUrls
+        collectionTitle
+        assetId
+        totalVolumes {
+          currency
+          amount
+        }
+        blockchain
+        address
+        tokenId
+        name
+        description
+        rank
+        markets {
+          marketId
+          marketName
+          marketDomain
+          marketUrl
+        }
+        collectionMedias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+          sizeRatio
+          fileSize
+        }
+        originalUrls
+        medias {
+          originalUrl
+          url
+          mimeType
+          sizeRatio
+          fileSize
+          previewUrl
+        }
+        ownersAddresses
+        ownersProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        creatorsAddresses
+        creatorsProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        attributes {
+          name
+          value
+        }
+        views
+        visible
+        blurred
+        medias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+        }
+        creatorsProfiles {
+          username
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __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 function useFetchDynamicCollectionDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
+      }
+export function useFetchDynamicCollectionDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
+        }
+export type FetchDynamicCollectionDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataQuery>;
+export type FetchDynamicCollectionDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataLazyQuery>;
+export type FetchDynamicCollectionDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>;
+export const FetchDynamicCollectionsDataDocument = gql`
+    query FetchDynamicCollectionsData($input: [DynamicCollectionDataInput!]!) {
+  fetchDynamicCollectionsData(inputs: $input) {
+    isLikedByUser
+    likesNum
+    collectionId
+    collectionAssetsPage {
+      nextPageToken
+      assets {
+        latestPriceCurrency
+        latestPriceAmount
+        collectionId
+        collectionOriginalUrls
+        collectionTitle
+        assetId
+        totalVolumes {
+          currency
+          amount
+        }
+        blockchain
+        address
+        tokenId
+        name
+        description
+        rank
+        markets {
+          marketId
+          marketName
+          marketDomain
+          marketUrl
+        }
+        collectionMedias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+          sizeRatio
+          fileSize
+        }
+        originalUrls
+        medias {
+          originalUrl
+          url
+          mimeType
+          sizeRatio
+          fileSize
+          previewUrl
+        }
+        ownersAddresses
+        ownersProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        creatorsAddresses
+        creatorsProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        attributes {
+          name
+          value
+        }
+        views
+        visible
+        blurred
+        medias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+        }
+        creatorsProfiles {
+          username
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __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 function useFetchDynamicCollectionsDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
+      }
+export function useFetchDynamicCollectionsDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
+        }
+export type FetchDynamicCollectionsDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataQuery>;
+export type FetchDynamicCollectionsDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataLazyQuery>;
+export type FetchDynamicCollectionsDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>;
 export const FindAllTopEntitiesByNameDocument = gql`
     query FindAllTopEntitiesByName($name: String!, $pageSize: Int!) {
   findAllTopEntitiesByName(name: $name, pageSize: $pageSize) {