schema.gql

# ------------------------------------------------------
# THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
# ------------------------------------------------------

input AcceptOfferArgs {
  auctionId: Int
  offerId: Int
}

type Account {
  address: ID
  cover: String
  description: String
  herotag: String
  privacy: Privacy
  profile: String
  socialLinks: [SocialLink!]
}

type AccountEdge {
  cursor: String
  node: Account
}

type AccountPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type AccountStats {
  address: ID
  auctions: String
  biddingBalance: String
  biddings: [Price!]
  claimable: String
  collected: String
  collections: String
  creations: String
  likes: String
  marketplaceKey: String
  offers: String
  orders: String
}

input AccountStatsFilter {
  address: String!
  isOwner: Boolean
  marketplaceKey: String
}

input AddLikeArgs {
  identifier: String!
}

type AnalyticsAggregateValue {
  avg: Float
  count: Float
  marketplacesData: [MarketplaceData]
  max: Float
  min: Float
  series: String
  time: String
  value: Float
}

input AnalyticsArgs {
  metric: String!
  series: String
  time: String
}

input AnalyticsInput {
  range: TimeRange
  resolution: TimeResolutionsEnum
}

input ArtistFilters {
  sorting: ArtistSortingEnum!
}

type ArtistResponse {
  edges: [AccountEdge!]
  pageData: PageData
  pageInfo: AccountPageInfo
}

enum ArtistSortingEnum {
  MostActive
  MostFollowed
  Trending
}

type Asset {
  aggregatorUrl: String!
  artist: Account
  attributes: String!

  """This will return only the running query!"""
  auctions(pagination: ConnectionArgs): AuctionResponse
  balance: String
  branding: CollectionBranding
  collection: ID!
  creationDate: Int
  creator: Account
  creatorAddress: String!
  hasAvailableAuctions: Boolean
  hash: String
  identifier: String!
  isLiked(byAddress: String!): Boolean
  isNsfw: Boolean
  isTicket: Boolean
  isWhitelistedStorage: Boolean!
  likesCount: Int
  lowestAuction(filters: MarketplaceFilters): Auction
  marketplaces: [Marketplace!]
  media: [Media!]
  metadata: Metadata
  name: String!
  nonce: Int!
  owner: Account
  ownerAddress: String
  rarity: Rarity
  royalties: String!
  scamInfo: ScamInfo
  supply: String
  tags: [String!]
  thumbnailUrl: String @deprecated(reason: "This field will be removed in the next version")
  totalAvailableTokens: String
  totalRunningAuctions: String
  type: NftTypeEnum!
  uris: [String!]!
  url: String @deprecated(reason: "This field will be removed in the next version")
  verified: Boolean!
  viewsCount: Int
}

enum AssetActionEnum {
  Added
  Bid
  Bought
  ClosedAuction
  Created
  EndedAuction
  PriceUpdated
  Received
  StartedAuction
  Updated
}

type AssetEdge {
  cursor: String
  node: Asset
}

input AssetHistoryFilter {
  identifier: String!
}

type AssetHistoryLog {
  account: Account
  action: AssetActionEnum!
  actionDate: Int!
  address: String!
  itemCount: String
  price: Price
  senderAccount: Account
  senderAddress: String
  transactionHash: String!
}

type AssetHistoryLogEdge {
  cursor: String
  node: AssetHistoryLog
}

type AssetHistoryLogPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type AssetHistoryLogResponse {
  edges: [AssetHistoryLogEdge!]
  pageData: PageData
  pageInfo: AssetHistoryLogPageInfo
}

type AssetPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

input AssetsCollectionFilter {
  """The owner of the collection"""
  ownerAddress: String
}

input AssetsFilter {
  artistAddress: String
  collection: String

  """This will work only with an owner address"""
  collections: [String!]
  creatorAddress: String
  identifier: String
  identifiers: [String!]
  likedByAddress: String
  ownerAddress: String
  searchTerm: String
  tags: [String!]
  traits: [NftTrait]
  type: NftTypeEnum
}

type AssetsResponse {
  edges: [AssetEdge!]
  pageData: PageData
  pageInfo: AssetPageInfo
}

enum AssetsSortingEnum {
  MostLikes
  RankAsc
  RankDesc
}

input AttributeInput {
  description: String!
  tags: [String!]!
}

type AttributeType {
  attribute: [KeyValueType!]!
}

type Auction {
  asset: Asset!
  availableTokens: Int
  collection: String!
  creationDate: Int!
  endDate: Int!
  id: ID!
  identifier: String!
  marketplace: Marketplace
  marketplaceAuctionId: Int!
  marketplaceKey: String!
  maxBid: Price!
  minBid: Price!
  minBidDiff: Price!
  nonce: Int!
  nrAuctionedTokens: Int
  orders(pagination: ConnectionArgs): OrdersResponse
  owner: Account
  ownerAddress: String!
  startDate: Int!
  status: AuctionStatusEnum!
  tags: [String!]
  topBid: Price
  topBidder: Account
  type: AuctionTypeEnum!
}

enum AuctionCustomEnum {
  CURRENTPRICE
}

input AuctionCustomFilter {
  field: AuctionCustomEnum!
  op: Operation!
  sort: AuctionCustomSort
  values: [String]
}

input AuctionCustomSort {
  direction: Sort!
  field: AuctionCustomEnum!
}

type AuctionEdge {
  cursor: String
  node: Auction
}

type AuctionPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type AuctionResponse {
  edges: [AuctionEdge!]
  pageData: PageData
  pageInfo: AuctionPageInfo
  priceRange: PriceRange
}

enum AuctionStatusEnum {
  Claimable
  Closed
  Ended
  None
  Running
}

enum AuctionTypeEnum {
  FixedPrice
  Nft
  NftBid
  None
  SftAll
  SftOnePerPayment
}

input BidActionArgs {
  auctionId: Int!
  identifier: String!
  paymentTokenIdentifier: String! = "EGLD"
  price: String!
}

input BuyRandomNftActionArgs {
  """The campaign id where the user wants to buy the nft/s"""
  campaignId: String!

  """The smart contract address of the campaign"""
  minterAddress: String!

  """
  The total price the user needs to pay in order to buy the number of nfts selected
  """
  price: String!

  """The number of nfts the user wants to buy"""
  quantity: String

  """The tier name on which the user wants to buy the nft"""
  tier: String!
}

input BuySftActionArgs {
  auctionId: Int!
  identifier: String!
  paymentTokenIdentifier: String! = "EGLD"
  price: String!
  quantity: String
}

type Campaign {
  availableNfts: Int!
  campaignId: ID!
  collection: CampaignCollection!
  coverImage: String!
  description: String
  endDate: Int!
  maxNftsPerTransaction: Int!
  mediaType: String!
  minterAddress: String!
  startDate: Int!
  status: CampaignStatusEnum!
  tiers: [Tier!]!
  totalNfts: Int!
  verified: Boolean!

  """This is the timestamp when the whitelist period expires"""
  whitelistExpire: Int!
}

type CampaignCollection {
  collectionHash: String!
  collectionName: String!
  collectionTicker: String!
  royalties: String!
}

type CampaignEdge {
  cursor: String
  node: Campaign
}

type CampaignPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

enum CampaignStatusEnum {
  Ended
  NotStarted
  Running
}

input CampaignsFilter {
  campaignId: String
  minterAddress: String
}

type CampaignsResponse {
  edges: [CampaignEdge!]
  pageData: PageData
  pageInfo: CampaignPageInfo
}

input ChildExpression {
  filters: [ChildFilter!]!
  operator: Operator!
}

input ChildFilter {
  field: String!
  op: Operation!
  relationField: String
  values: [String!]!
}

input ClearReportCollectionInput {
  collectionIdentifier: String!
}

input ClearReportInput {
  identifier: String!
}

type Collection {
  aggregatorUrl: String!
  artist: Account
  artistAddress: String!
  artistFollowersCount: Int!

  """This will return only the first 10 assets"""
  assets(
    filters: AssetsCollectionFilter

    """
    This filter will be removed in the next version, we return the latest 10 assets for this collection
    """
    pagination: ConnectionArgs
  ): AssetsResponse
  canAddQuantity: Boolean
  canBurn: Boolean
  canCreate: Boolean
  canFreeze: Boolean
  canPause: Boolean
  canTransferRole: Boolean
  canWipe: Boolean
  collection: String
  collectionAsset: CollectionAsset!
  creationDate: Int!
  description: String
  name: String!
  nftsCount: Int
  onSaleAssetsCount: Int!
  owner: Account
  ownerAddress: String
  pngUrl: String
  preferredRankAlgorithm: String
  roles: [CollectionRole!]
  scamInfo: ScamInfo
  social: CollectionSocial
  status: String
  svgUrl: String
  ticker: String!
  traits: [CollectionNftTrait]
  type: String
  verified: Boolean!
  website: String
}

input CollectionAnalyticsArgs {
  series: String
}

type CollectionAsset {
  assets(input: CollectionAssetsRetriveCount): [CollectionAssetModel]
  totalCount: String
}

type CollectionAssetModel {
  identifier: String!
  isNsfw: Boolean
  scamInfo: ScamInfo
  thumbnailUrl: String
}

input CollectionAssetsRetriveCount {
  size: Int! = 4
}

type CollectionBranding {
  description: String
  pngUrl: String
  social: CollectionSocial
  status: String
  svgUrl: String
  website: String
}

type CollectionEdge {
  cursor: String
  node: Collection
}

type CollectionNftTrait {
  name: String!
  values: [CollectionNftTraitValues!]!
}

type CollectionNftTraitValues {
  occurrences: Float!
  value: String!
}

type CollectionPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type CollectionResponse {
  edges: [CollectionEdge!]
  pageData: PageData
  pageInfo: CollectionPageInfo
}

type CollectionRole {
  address: String
  canAddQuantity: Boolean
  canAddUri: Boolean
  canBurn: Boolean
  canCreate: Boolean
  canTransferRole: Boolean
  canUpdateAttributes: Boolean
  roles: [String!]!
}

type CollectionSocial {
  blog: String
  email: String
  twiter: String
}

type CollectionStats {
  activeAuctions: Int
  auctionsEnded: Int
  identifier: ID!
  items: Int
  maxPrice: String
  minPrice: String
  saleAverage: String
  volumeTraded: String
}

input CollectionStatsFilter {
  identifier: String!
  marketplaceKey: String
  paymentToken: String
}

type CollectionsAnalyticsModel {
  collectionIdentifier: String!
  details: CollectionsDetailsModel!
  floorPrice: Float!
  floorPriceData(input: AnalyticsArgs!): [AnalyticsAggregateValue!]!
  holders: Int!
  topHolders: [HoldersCount!]!
  transactionsCount(input: AnalyticsInput): [AnalyticsAggregateValue!]!
  volume24h: Float
  volumeData(input: AnalyticsArgs!): [AnalyticsAggregateValue!]!
}

type CollectionsAnalyticsModelEdge {
  cursor: String
  node: CollectionsAnalyticsModel
}

type CollectionsAnalyticsModelPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type CollectionsAnalyticsResponse {
  edges: [CollectionsAnalyticsModelEdge!]
  pageData: PageData
  pageInfo: CollectionsAnalyticsModelPageInfo
}

type CollectionsDetailsModel {
  collectionIdentifier: String!
  collectionName: String!
  items: Int!
  owner: String!
}

input CollectionsFilter {
  """Flag for active last 30 days"""
  activeLast30Days: Boolean

  """The actual artist of the collection"""
  artistAddress: String

  """Flag for can create or not on collection"""
  canCreate: Boolean

  """Collection identifier"""
  collection: String

  """The user that has create role"""
  creatorAddress: String

  """The owner of the collection"""
  ownerAddress: String
  searchTerm: String
  type: NftTypeEnum

  """Flag for verified collections"""
  verified: Boolean

  """Flag for collections where owner address has nfts"""
  withNfts: Boolean
}

enum CollectionsSortingEnum {
  Newest
  Trending
  Verified
}

input ConnectionArgs {
  """Paginate after opaque cursor"""
  after: String

  """Paginate before opaque cursor"""
  before: String

  """Paginate first"""
  first: Int

  """Paginate last"""
  last: Int
}

input CreateAuctionArgs {
  deadline: String!
  identifier: String!
  marketplaceKey: String!
  maxBid: String
  maxOneSftPerPayment: Boolean
  minBid: String!
  paymentToken: String!
  paymentTokenNonce: Int
  quantity: String! = "1"
  startDate: String
}

input CreateNftArgs {
  attributes: AttributeInput!
  collection: String!
  name: String!
  quantity: String! = "1"
  royalties: String! = "0"
}

input CreateOfferArgs {
  auctionId: Int
  deadline: String!
  identifier: String!
  marketplaceKey: String!
  paymentAmount: String!
  paymentToken: String!
  paymentTokenNonce: Int! = 0
  quantity: String! = "1"
}

input CurrentPaymentTokensFilters {
  collectionIdentifier: String
  marketplaceKey: String
}

input DeployBulkArgs {
  ownerAddress: String!
}

input DeployMarketplaceArgs {
  marketplaceFee: String!
  ownerAddress: String!

  """
  The accepted payment tokens for auction on the marketplace. By default, if left empty, accepts all payment tokens
  """
  paymentTokens: [String!]
}

input DeployMinterArgs {
  maxNftsPerTransaction: Int!
  mintClaimAddress: String!
  ownerAddress: String!
  royaltiesClaimAddress: String!
}

type ExploreCollectionsStats {
  activeLast30DaysCount: Int!
  allCollectionsCount: Int!
  verifiedCount: Int!
}

type ExploreNftsStats {
  allNftsCount: Int!
  buyNowCount: Int!
  liveAuctionsCount: Int!
  offersCount: Int!
}

type ExploreStats {
  artists: Int!
  collections: Int!
  nfts: Int!
}

enum FeaturedCollectionTypeEnum {
  Featured
  Hero
  Tickets
}

input FeaturedCollectionsArgs {
  collection: String!
  type: FeaturedCollectionTypeEnum!
}

input FeaturedCollectionsFilter {
  type: FeaturedCollectionTypeEnum!
}

input Filter {
  field: String!
  op: Operation!
  values: [String]
}

input FiltersExpression {
  childExpressions: [ChildExpression!]
  filters: [Filter!]!
  operator: Operator!
}

input FlagCollectionInput {
  collection: String!
  nsfwFlag: Float!
}

input FlagNftInput {
  identifier: String!
  nsfwFlag: Float!
}

type GeneralAnalyticsModel {
  collections: Int!
  holders: Int!
  listing(input: AnalyticsInput!): [AnalyticsAggregateValue!]!
  marketplaces: Int!
  nfts(input: AnalyticsInput!): [AnalyticsAggregateValue!]!
  volume(input: AnalyticsInput!): [AnalyticsAggregateValue!]!
}

enum GroupBy {
  IDENTIFIER
}

input Grouping {
  groupBy: GroupBy!
}

input HandleQuantityArgs {
  addOrBurnRoleAddress: String!
  identifier: String!
  quantity: String!
}

input HistoryPagination {
  """Paginate first"""
  first: Int = 10

  """Timestamp from where to start"""
  timestamp: Int
}

type HoldersCount {
  accountDetails: Account!
  address: String!
  count: Int!
}

input IssueCampaignArgs {
  campaignId: String!
  collectionIpfsHash: String!
  collectionName: String!
  collectionTicker: String!
  mediaTypes: MediaTypeEnum!
  mintEndTime: Int!
  mintPriceToken: String! = "EGLD"
  mintStartTime: Int!
  minterAddress: String!
  ownerAddress: String!
  royalties: String!
  tags: [String!]!
  tiers: [TierArgs!]!
  whitelistEndTime: Int!
}

input IssueCollectionArgs {
  canFreeze: Boolean! = false
  canPause: Boolean! = false
  canTransferNFTCreateRole: Boolean! = false
  canWipe: Boolean! = false
  tokenName: String!
  tokenTicker: String!
}

type KeyValueType {
  key: String!
  value: String!
}

type Marketplace {
  acceptedCollectionIdentifiers: [String!]
  acceptedPaymentTokens: [Token!]
  address: String!
  iconUrl: String!
  isPaused: Boolean
  key: ID!
  marketplaceCutPercentage: String
  name: String!
  state: MarketplaceState!
  type: MarketplaceTypeEnum!
  url: String!
}

type MarketplaceData {
  key: String!
  value: Float
}

type MarketplaceEdge {
  cursor: String
  node: Marketplace
}

input MarketplaceEventsIndexingArgs {
  afterTimestamp: Float
  beforeTimestamp: Float
  marketplaceAddress: String!
  marketplaceLastIndexTimestamp: Float
  stopIfDuplicates: Boolean
}

input MarketplaceFilters {
  marketplaceAddress: String
  marketplaceKey: String
}

type MarketplacePageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

input MarketplaceReindexDataArgs {
  afterTimestamp: Float
  beforeTimestamp: Float
  marketplaceAddress: String!
}

enum MarketplaceState {
  Disable
  Enable
}

enum MarketplaceTypeEnum {
  External
  Internal
}

type MarketplacesResponse {
  edges: [MarketplaceEdge!]
  pageData: PageData
  pageInfo: MarketplacePageInfo
}

type Media {
  fileSize: String
  fileType: String
  originalUrl: String
  thumbnailUrl: String
  url: String
}

enum MediaTypeEnum {
  aac
  flac
  gif
  jpeg
  jpg
  m4a
  mov
  mov2
  mp3
  mp4
  png
  svg
  svgXml
  wav
  webm
  webp
}

type Metadata {
  attributes: [AttributeType!]
  description: String
  interactiveUrl: String
}

type MintPrice {
  amount: String!
  token: ID!
}

type Minter {
  address: ID!
  adminAddress: ID!
}

type MinterEdge {
  cursor: String
  node: Minter
}

input MinterFilters {
  minterAddress: String!
  minterAdminAddress: String!
}

type MinterPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type MintersResponse {
  edges: [MinterEdge!]
  pageData: PageData
  pageInfo: MinterPageInfo
}

type Mutation {
  acceptOffer(input: AcceptOfferArgs!): TransactionNode!
  addBlacklistedCollection(collection: String!): Boolean!
  addFeaturedCollection(input: FeaturedCollectionsArgs!): Boolean!
  addLike(input: AddLikeArgs!): Boolean!
  addReport(
    """This endpoint can be used to report a NFT"""
    input: ReportNftInput!
  ): Boolean!
  addSftQuantity(input: HandleQuantityArgs!): TransactionNode!
  bid(input: BidActionArgs!): TransactionNode!
  burnQuantity(input: HandleQuantityArgs!): TransactionNode!
  buyRandomNft(input: BuyRandomNftActionArgs!): TransactionNode!
  buySft(input: BuySftActionArgs!): TransactionNode!
  clearCollectionScamInfo(collection: String!): Boolean!
  clearNftScamInfo(identifier: String!): Boolean!
  clearReportCollection(input: ClearReportCollectionInput!): Boolean!
  clearReportNft(input: ClearReportInput!): Boolean!
  createAuction(input: CreateAuctionArgs!): TransactionNode!
  createNft(file: Upload!, input: CreateNftArgs!): TransactionNode!
  createNftWithMultipleFiles(files: [Upload!]!, input: CreateNftArgs!): TransactionNode!
  deployBulkSmartContract(input: DeployBulkArgs!): TransactionNode!
  deployMarketplaceContract(input: DeployMarketplaceArgs!): TransactionNode!
  deployMinter(input: DeployMinterArgs!): TransactionNode!
  deployMinterSmartContract(input: DeployMinterArgs!): TransactionNode!
  disableMarketplace(input: UpdateMarketplaceStateArgs!): Boolean!
  enableMarketplace(input: UpdateMarketplaceStateArgs!): Boolean!
  endAuction(auctionId: Int!): TransactionNode!
  flagCollection(input: FlagCollectionInput!): Boolean!
  flagNft(input: FlagNftInput!): Boolean!
  indexTrandingCollections(forTheLastHours: Float!): Boolean!
  issueCampaign(input: IssueCampaignArgs!): TransactionNode!
  issueNftCollection(input: IssueCollectionArgs!): TransactionNode!
  issueSftCollection(input: IssueCollectionArgs!): TransactionNode!
  minters(filters: MinterFilters!, pagination: ConnectionArgs): MintersResponse!
  pauseMinter(input: UpgradeMinterArgs!): TransactionNode!
  reindexMarketplaceData(input: MarketplaceReindexDataArgs!): Boolean!
  reindexMarketplaceEvents(input: MarketplaceEventsIndexingArgs!): Boolean!
  removeBlacklistedCollection(collection: String!): Boolean!
  removeFeaturedCollection(input: FeaturedCollectionsArgs!): Boolean!
  removeLike(input: RemoveLikeArgs!): Boolean!
  removeWhitelistCollection(input: RemoveWhitelistCollectionArgs!): Boolean!
  reportCollection(
    """This endpoint can be used to report a Collection"""
    input: ReportCollectionInput!
  ): Boolean!
  resumeMinter(input: UpgradeMinterArgs!): TransactionNode!
  sendOffer(input: CreateOfferArgs!): TransactionNode!
  setCollectionScamInfo(collection: String!): Boolean!
  setNftScamInfo(identifier: String!, info: String!, type: ScamInfoTypeEnum!): Boolean!
  setRoles(input: SetNftRolesArgs!): TransactionNode!
  stopNftCreate(input: StopNftCreateArgs!): TransactionNode!
  transferNft(input: TransferNftArgs!): TransactionNode!
  transferNftCreateRole(input: TransferNftCreateRoleArgs!): TransactionNode!
  trigerScamUpdate(input: ScamUpdateInput!): Boolean!
  updateCollectionRarities(collectionTicker: String!): Boolean!
  updateCollectionTraits(collectionTicker: String!): Boolean!
  updateMarketplace(input: UpdateMarketplaceArgs!): Boolean!
  updateNftTraits(identifier: String!): UpdateNftTraitsResponse!
  upgradeNftRoyalties(input: UpgradeNftArgs!): TransactionNode!
  validateCollectionRarities(collectionTicker: String!): Boolean!
  validateOrUpdateNftScamInfo(identifier: String!): Boolean!
  verifyContent(file: Upload!): Boolean!
  whitelistCollectionOnMarketplace(input: WhitelistCollectionArgs!): Boolean!
  whitelistMarketplace(input: WhitelistMarketplaceArgs!): Boolean!
  whitelistMinter(input: WhitelistMinterArgs!): Boolean!
  whitelistMinterSmartContract(input: WhitelistMinterArgs!): Boolean!
  withdraw(auctionId: Int!): TransactionNode!
  withdrawOffer(offerId: Int!): TransactionNode!
  xBulkDeployedContracts: [String]
}

input MyClaimableAuctionsFilters {
  marketplaceKey: String!
}

input NftTrait {
  name: String!
  value: String!
}

enum NftTypeEnum {
  NonFungibleESDT
  SemiFungibleESDT
}

type Notification {
  auctionId: Int!
  creationDate: Int
  id: ID!
  identifier: String!
  marketplaceKey: String!
  name: String!
  type: NotificationTypeEnum!
}

type NotificationEdge {
  cursor: String
  node: Notification
}

type NotificationPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

enum NotificationTypeEnum {
  Bought
  Ended
  OfferExpired
  OfferReceived
  Outbidded
  Sold
  Won
}

input NotificationsFilters {
  marketplaceKey: String!
}

type NotificationsResponse {
  edges: [NotificationEdge!]
  pageData: PageData
  pageInfo: NotificationPageInfo
}

type Offer {
  asset: Asset
  creationDate: Int
  endDate: Int
  id: ID!
  identifier: String!
  marketplace: Marketplace!
  marketplaceKey: String!
  owner: Account
  ownerAddress: String!
  price: Price!
  quantity: String
  status: OfferStatusEnum!
}

type OfferEdge {
  cursor: String
  node: Offer
}

type OfferPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

enum OfferStatusEnum {
  Accepted
  Active
  Closed
  Expired
}

input OffersFilters {
  """The collection identifier for the offers"""
  collectionIdentifier: String

  """The nft identifier for the offers"""
  identifier: String

  """The marketplace key for the offers"""
  marketplaceKey: String

  """The owner of the offer"""
  ownerAddress: String

  """The payment token for the offers"""
  priceToken: String

  """The offer status"""
  status: [OfferStatusEnum!]
}

type OffersResponse {
  edges: [OfferEdge!]
  pageData: PageData
  pageInfo: OfferPageInfo
}

enum Operation {
  BETWEEN
  EQ
  GE
  IN
  LE
  LIKE
}

enum Operator {
  AND
  OR
}

type Order {
  auction: Auction
  auctionId: Int!
  boughtTokensNo: String
  creationDate: Int
  endDate: Int
  from: Account
  id: ID!
  marketplaceKey: String!
  ownerAddress: String!
  price: Price!
  status: OrderStatusEnum!
}

type OrderEdge {
  cursor: String
  node: Order
}

type OrderPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

enum OrderStatusEnum {
  Active
  Bought
  Inactive
}

type OrdersResponse {
  edges: [OrderEdge!]
  pageData: PageData
  pageInfo: OrderPageInfo
}

type Owner {
  account: Account
  address: String
  balance: String
  identifier: ID
}

type OwnerEdge {
  cursor: String
  node: Owner
}

type OwnerPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type OwnerResponse {
  edges: [OwnerEdge!]
  pageData: PageData
  pageInfo: OwnerPageInfo
}

input OwnersFilters {
  identifier: String!
}

type PageData {
  count: Int!
  limit: Int!
  offset: Int!
}

type Price {
  amount: String!
  nonce: Int!
  timestamp: Int!
  token: ID!
  tokenData: Token!
  usdAmount: String
}

type PriceRange {
  maxBid: Price!
  minBid: Price!
}

enum Privacy {
  private
  public
}

type Query {
  accountStats(filters: AccountStatsFilter!): AccountStats!
  artists(filters: ArtistFilters!, pagination: ConnectionArgs): ArtistResponse!
  assetHistory(filters: AssetHistoryFilter!, pagination: HistoryPagination): AssetHistoryLogResponse!
  assets(filters: AssetsFilter, pagination: ConnectionArgs, sorting: AssetsSortingEnum): AssetsResponse!
  auctions(
    customFilters: [AuctionCustomFilter]

    """
    The values that can be used for this filters fields are the entity properties
    """
    filters: FiltersExpression
    grouping: Grouping
    pagination: ConnectionArgs

    """
    The values that can be used for this sorting fields are the entity properties
    """
    sorting: [Sorting!]
  ): AuctionResponse!
  auctionsSortByBids(filters: FiltersExpression, grouping: Grouping, pagination: ConnectionArgs): AuctionResponse!
  blacklistedCollections: [String!]!
  campaigns(filters: CampaignsFilter, pagination: ConnectionArgs): CampaignsResponse!
  collectionStats(filters: CollectionStatsFilter!): CollectionStats!
  collections(filters: CollectionsFilter, pagination: ConnectionArgs, sorting: CollectionsSortingEnum): CollectionResponse!
  collectionsAnalytics(input: CollectionAnalyticsArgs, pagination: ConnectionArgs): CollectionsAnalyticsResponse!
  currentPaymentTokens(filters: CurrentPaymentTokensFilters): [Token!]!
  exploreCollectionsStats: ExploreCollectionsStats!
  exploreNftsStats: ExploreNftsStats!
  exploreStats: ExploreStats!
  featuredCollections(filters: FeaturedCollectionsFilter, pagination: ConnectionArgs): CollectionResponse!
  featuredNfts(pagination: ConnectionArgs): AssetsResponse!
  generalAnalytics(input: AnalyticsInput): GeneralAnalyticsModel!
  marketplaces(filters: MarketplaceFilters, pagination: ConnectionArgs): MarketplacesResponse!
  myClaimableAuctions(filters: MyClaimableAuctionsFilters, pagination: ConnectionArgs): AuctionResponse!
  notifications(filters: NotificationsFilters, pagination: ConnectionArgs): NotificationsResponse!
  offers(filters: OffersFilters, pagination: ConnectionArgs): OffersResponse!
  orders(filters: FiltersExpression, pagination: ConnectionArgs, sorting: [Sorting!]): OrdersResponse!
  owners(filters: OwnersFilters!, pagination: ConnectionArgs): OwnerResponse!
  priceRange(filters: TokenFilter): PriceRange!
  search(filters: SearchFilter!): SearchResponse!
  tags(filters: TagsFilter!, pagination: ConnectionArgs): TagsResponse!
  trendingAssets: [Asset!]!
}

type Rarity {
  customRank: Int
  jaccardDistancesRank: Float
  jaccardDistancesScore: Float
  openRarityRank: Float
  openRarityScore: Float
  rank: Int
  score: Float
  statisticalRank: Float
  statisticalScore: Float
  traitRank: Float
  traitScore: Float
}

input RemoveLikeArgs {
  identifier: String!
}

input RemoveWhitelistCollectionArgs {
  collection: String!
  marketplaceKey: String!
}

input ReportCollectionInput {
  collectionIdentifier: String!
}

input ReportNftInput {
  identifier: String!
}

type ScamInfo {
  info: String
  type: ScamInfoTypeEnum
}

enum ScamInfoTypeEnum {
  none
  potentialScam
  scam
}

enum ScamInputEnum {
  allow
  deny
}

input ScamUpdateInput {
  collectionIdentifier: String!
  type: ScamInputEnum!
}

input SearchFilter {
  searchTerm: String!
}

type SearchItemResponse {
  identifier: String!
  name: String
}

type SearchNftCollectionResponse {
  identifier: String!
  name: String
  verified: Boolean!
}

type SearchResponse {
  accounts: [SearchItemResponse!]
  collections: [SearchNftCollectionResponse!]
  nfts: [SearchNftCollectionResponse!]
  searchTerm: ID
  tags: [SearchItemResponse!]
}

input SetNftRolesArgs {
  addressToTransfer: String!
  collection: String!
  roles: [String!]!
}

type SocialLink {
  type: ID
  url: String
}

enum Sort {
  ASC
  DESC
}

input Sorting {
  direction: Sort!
  field: String!
}

input StopNftCreateArgs {
  collection: String!
  ownerAddress: String!
}

type Tag {
  count: Int
  tag: ID!
}

type TagEdge {
  cursor: String
  node: Tag
}

type TagPageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

enum TagTypeEnum {
  Auction
  Nft
}

input TagsFilter {
  searchTerm: String
  tagType: TagTypeEnum! = Nft
}

type TagsResponse {
  edges: [TagEdge!]
  pageData: PageData
  pageInfo: TagPageInfo
}

type Tier {
  availableNfts: Int!
  campaignId: ID!
  description: String
  mintPrice: MintPrice!
  status: TierStatusEnum!
  tierName: String!
  totalNfts: Int!
}

input TierArgs {
  mintPriceAmount: String!
  tierName: String!
  totalNfts: Int!
}

enum TierStatusEnum {
  Running
  Sold
}

enum TimeRange {
  ALL
  DAY
  HOUR
  MONTH
  WEEK
  YEAR
}

enum TimeResolutionsEnum {
  INTERVAL_1_MINUTE
  INTERVAL_10_MINUTES
  INTERVAL_30_MINUTES
  INTERVAL_DAY
  INTERVAL_HOUR
  INTERVAL_MONTH
  INTERVAL_WEEK
}

type Token {
  activeAuctions: Int
  decimals: Float!
  identifier: String!
  name: String!
  priceUsd: String
  symbol: String!
}

input TokenFilter {
  token: String! = "EGLD"
}

type TransactionNode {
  chainID: String!
  data: String!
  gasLimit: Float!
  gasPrice: Float!
  nonce: Int!
  options: Float
  receiver: String!
  sender: String!
  value: String!
  version: Float!
}

input TransferNftArgs {
  destinationAddress: String!
  identifier: String!
  quantity: String! = "1"
}

input TransferNftCreateRoleArgs {
  addressToTransferList: [String!]!
  collection: String!
  ownerAddress: String!
}

input UpdateMarketplaceArgs {
  """This should de a unique key, so choose wisely!"""
  marketplaceKey: String!

  """This field will be shown on external apps like xSpothlight, xPortal!"""
  marketplaceName: String

  """Smart Contract Address, if not sent the default one will be used"""
  marketplaceScAddress: String

  """This will be used to redirect from external apps!"""
  marketplaceUrl: String
}

input UpdateMarketplaceStateArgs {
  """Smart Contract Address"""
  marketplaceScAddress: String!
}

enum UpdateNftTraitsResponse {
  CollectionTraitsUpdated
  NftTraitsUpdated
  NftTraitsValid
}

input UpgradeMinterArgs {
  minterAddress: String!
}

input UpgradeNftArgs {
  """The campaign id where the user wants to buy the nft/s"""
  campaignId: String!

  """The identifier of the nft to be upgraded"""
  identifier: String!

  """The smart contract address of the campaign"""
  minterAddress: String!
}

"""The `Upload` scalar type represents a file upload."""
scalar Upload

input WhitelistCollectionArgs {
  collection: String!
  marketplaceKey: String!
}

input WhitelistMarketplaceArgs {
  """This should de a unique key, so choose wisely!"""
  marketplaceKey: String!

  """This field will be shown on external apps like xSpothlight, xPortal!"""
  marketplaceName: String!

  """Smart Contract Address, if not sent the default one will be used"""
  marketplaceScAddress: String

  """This will be used to redirect from external apps!"""
  marketplaceUrl: String!
}

input WhitelistMinterArgs {
  address: String!
  adminAddress: String!
}