export type Maybe = T | null; export type InputMaybe = Maybe; export type Exact = { [K in keyof T]: T[K]; }; export type MakeOptional = Omit & { [SubKey in K]?: Maybe; }; export type MakeMaybe = Omit & { [SubKey in K]: Maybe; }; export type MakeEmpty = { [_ in K]?: never; }; export type Incremental = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never; }; /** All built-in and custom scalars, mapped to their actual values */ export type Scalars = { ID: string; String: string; Boolean: boolean; Int: number; Float: number; /** Ethereum address */ Address: string; /** A string that cannot be passed as an empty value */ CountryCode: string; /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */ DateTime: string; /** Ethereum name service value with `.eth` suffix */ ENS: any; /** A field whose value is a JSON Web Token (JWT): https://jwt.io/introduction. */ JWT: any; /** A string that cannot be passed as an empty value */ NonEmptyString: string; /** Integers that will have a value of 0 or more. */ NonNegativeInt: number; /** Integers that will have a value greater than 0. */ PositiveInt: number; /** Semantic version string */ SemanticVersion: any; /** The javascript `Date` as integer. Type represents date and time as number of milliseconds from start of UNIX epoch. */ Timestamp: number; /** UUID v4 */ UUID: string; /** Represents NULL values */ Void: null; }; /** Filter activity feed */ export type ActivityFeedFilterArgs = { /** Only get activity feed of certain type */ activityFeedType?: ActivityFeedType; }; /** Filter activity feed groups */ export type ActivityFeedGroupFilterArgs = { /** Only get activity feed groups of certain type */ types?: Array; }; /** Activity feed group filter option */ export declare const ActivityFeedGroupFilterOption: { readonly ADDED_TO_PLAYLIST: "ADDED_TO_PLAYLIST"; readonly ALL: "ALL"; readonly COLLECTED: "COLLECTED"; readonly LIKES: "LIKES"; readonly POSTS: "POSTS"; readonly RELEASE_DROPPED: "RELEASE_DROPPED"; }; export type ActivityFeedGroupFilterOption = (typeof ActivityFeedGroupFilterOption)[keyof typeof ActivityFeedGroupFilterOption]; /** Activity feed type */ export declare const ActivityFeedType: { readonly GLOBAL: "GLOBAL"; readonly NOTABLE_COLLECTORS: "NOTABLE_COLLECTORS"; readonly USER: "USER"; }; export type ActivityFeedType = (typeof ActivityFeedType)[keyof typeof ActivityFeedType]; /** Pagination parameters for allCollectors */ export type AllCollectorsCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: AllCollectorsCursorConnectionSort; }; /** Customize sort of collectors */ export type AllCollectorsCursorConnectionSort = { /** Sort by date of user first being connected in platform */ createdAt?: InputMaybe; }; /** Filter the allCollectors result */ export type AllCollectorsFilter = { /** Genre names to filter on for collector's releases */ genres?: InputMaybe>; /** Should it include artists as collectors */ includeArtists?: Scalars['Boolean']; /** Location ids to filter on for collector's releases */ locationIds?: InputMaybe>; /** Should it only include collectors with a valid username (twitterHandle, ens or displayName) */ onlyWithUsername?: Scalars['Boolean']; }; /** Input for allCollectors query */ export type AllCollectorsInput = { /** Filter the collectors */ filter?: AllCollectorsFilter; /** Pagination parameters of collectors */ pagination?: AllCollectorsCursorConnectionArgs; }; /** Pagination parameters for allShelves */ export type AllShelvesCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: AllShelvesCursorConnectionSort; }; /** Customize sort of shelves */ export type AllShelvesCursorConnectionSort = { /** Sort by date of playlist being created */ createdAt?: InputMaybe; }; /** Filter the shelves of allShelves query */ export type AllShelvesFilter = { /** Genre names to filter on for shelf songs */ genres?: InputMaybe>; /** Filter the shelves based on the expected types */ type?: Array; }; /** Input for allShelves query */ export type AllShelvesInput = { /** Filter the shelves, by default it gives all the user created shelves */ filter?: AllShelvesFilter; /** Pagination parameters, by default it gives the last 10 shelves created */ pagination?: AllShelvesCursorConnectionArgs; }; /** Artist activity feed action type filter option */ export declare const ArtistActivityFeedActivityTypeFilterOption: { readonly ALL: "ALL"; readonly COLLECTIONS: "COLLECTIONS"; readonly LIKES: "LIKES"; readonly PLAYLISTS: "PLAYLISTS"; readonly POSTS: "POSTS"; readonly RELEASES: "RELEASES"; }; export type ArtistActivityFeedActivityTypeFilterOption = (typeof ArtistActivityFeedActivityTypeFilterOption)[keyof typeof ArtistActivityFeedActivityTypeFilterOption]; /** Filter artist activity types */ export type ArtistActivityFeedFilterArgs = { /** Only get activity of given action type */ activityTypes?: Array; /** Only get activity by the given group */ types?: Array; }; /** Artist activity feed type filter option */ export declare const ArtistActivityFeedTypeFilterOption: { readonly ALL: "ALL"; readonly ARTIST: "ARTIST"; readonly COLLECTOR: "COLLECTOR"; readonly RELEASE: "RELEASE"; }; export type ArtistActivityFeedTypeFilterOption = (typeof ArtistActivityFeedTypeFilterOption)[keyof typeof ArtistActivityFeedTypeFilterOption]; /** Artist application status */ export declare const ArtistApplicationStatus: { readonly ACCEPTED: "ACCEPTED"; readonly PENDING: "PENDING"; readonly REJECTED: "REJECTED"; }; export type ArtistApplicationStatus = (typeof ArtistApplicationStatus)[keyof typeof ArtistApplicationStatus]; /** Pagination paramaters for artist collectors */ export type ArtistCollectorCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ArtistCollectorCursorConnectionSort; }; /** Customize sort of collectors */ export type ArtistCollectorCursorConnectionSort = { /** Sort by first nft collected date */ firstNftCollectedDate?: InputMaybe; /** Sort by amount nfts collected, with tie-breaker of earliest collector first */ nftsCount?: InputMaybe; }; /** Filter for paginated artists */ export type ArtistCursorFilterArgs = { /** Genre names to filter on for artist's releases */ genres?: InputMaybe>; /** Specify whether artist already has at least one collector (minted release) */ hasCollector?: InputMaybe; /** Specify whether artist already has at least one release */ hasMintedRelease?: InputMaybe; /** Specify whether artist already has at least one release */ hasRelease?: InputMaybe; /** Location IDs from Google Places API to filter on for artist's releases */ locationIds?: InputMaybe>; /** Specify season to be filtered */ season?: InputMaybe; }; /** Artist releases author filter option */ export declare const ArtistReleasesAuthorFilterOption: { readonly ALL: "ALL"; readonly ONLY_APPEARS_ON: "ONLY_APPEARS_ON"; readonly ONLY_AUTHORED_RELEASES: "ONLY_AUTHORED_RELEASES"; }; export type ArtistReleasesAuthorFilterOption = (typeof ArtistReleasesAuthorFilterOption)[keyof typeof ArtistReleasesAuthorFilterOption]; /** Artist releases credit split filter option */ export declare const ArtistReleasesCreditSplitFilterOption: { readonly ALL: "ALL"; readonly ONLY_CREDIT_SPLITS: "ONLY_CREDIT_SPLITS"; readonly ONLY_NO_CREDIT_SPLITS: "ONLY_NO_CREDIT_SPLITS"; }; export type ArtistReleasesCreditSplitFilterOption = (typeof ArtistReleasesCreditSplitFilterOption)[keyof typeof ArtistReleasesCreditSplitFilterOption]; /** Filter for artist releases. Default is only for artist sounds. */ export type ArtistReleasesFilter = { /** Filters on release credit split status */ creditSplit?: ArtistReleasesCreditSplitFilterOption; /** Excludes specific releaseIds */ excludeReleaseIds?: Array; /** Filters on release with specified mint time status */ mintTimeStatus?: Array; /** Filters on whether album releases have been revealed or not */ releaseAlbumRevealStatus?: ReleaseAlbumRevealFilterOption; /** Filters on release author status */ releaseAuthor?: ArtistReleasesAuthorFilterOption; /** Filters on release type */ releaseType?: Array; }; /** Filter the artists to be searched */ export type ArtistSearchFilter = { /** Genre names to filter on for artist's releases */ genres?: InputMaybe>; /** Only include artists that either have or don't have collectors */ hasCollectors?: InputMaybe; /** Location IDs from Google Places API to filter on for artist's releases */ locationIds?: InputMaybe>; }; /** Customize sort of releases */ export type ArtistSearchSort = { /** Sort by creation date */ createdAt?: InputMaybe; /** Sort by number of mints of each release */ totalMinted?: InputMaybe; /** Sort by total volume of all artist releases */ totalVolume?: InputMaybe; }; /** Types of seasons for artists */ export declare const ArtistSeason: { readonly GENESIS: "GENESIS"; readonly SEASON_FOUR: "SEASON_FOUR"; readonly SEASON_ONE: "SEASON_ONE"; readonly SEASON_THREE: "SEASON_THREE"; readonly SEASON_TWO: "SEASON_TWO"; }; export type ArtistSeason = (typeof ArtistSeason)[keyof typeof ArtistSeason]; /** Defines sort order of Artist fields, array index defines tiebreaking */ export type ArtistSortInput = { /** Field to be sorted */ field: SearchArtistsSortEnum; /** Sort ascending or descending */ order: SortOrder; }; /** Types of release sales */ export declare const AuctionType: { readonly FIXED_QUANTITY: "FIXED_QUANTITY"; readonly FIXED_QUANTITY_WITH_GA: "FIXED_QUANTITY_WITH_GA"; readonly OPEN_EDITION: "OPEN_EDITION"; readonly OPEN_EDITION_WITH_GA: "OPEN_EDITION_WITH_GA"; readonly OPEN_EDITION_WITH_SAM: "OPEN_EDITION_WITH_SAM"; readonly RANGE_BOUND: "RANGE_BOUND"; }; export type AuctionType = (typeof AuctionType)[keyof typeof AuctionType]; /** Chain name supported on the platform */ export declare const ChainType: { readonly GOERLI: "GOERLI"; readonly MAINNET: "MAINNET"; readonly OPTIMISM: "OPTIMISM"; readonly OPTIMISM_GOERLI: "OPTIMISM_GOERLI"; }; export type ChainType = (typeof ChainType)[keyof typeof ChainType]; /** Name of the collection market */ export declare const CollectionMarketType: { readonly AIRDROP: "AIRDROP"; readonly BONDING_CURVE_SALE: "BONDING_CURVE_SALE"; readonly PRIMARY_SALE: "PRIMARY_SALE"; readonly SECONDARY_SALE: "SECONDARY_SALE"; }; export type CollectionMarketType = (typeof CollectionMarketType)[keyof typeof CollectionMarketType]; /** Filter collector feed activity types */ export type CollectorActivityFeedFilterArgs = { /** Only get activity of given type */ types?: Array; }; /** Collector activity feed type filter option */ export declare const CollectorActivityFeedTypeFilterOption: { readonly ALL: "ALL"; readonly COLLECTIONS: "COLLECTIONS"; readonly LIKES: "LIKES"; readonly PLAYLISTS: "PLAYLISTS"; }; export type CollectorActivityFeedTypeFilterOption = (typeof CollectorActivityFeedTypeFilterOption)[keyof typeof CollectorActivityFeedTypeFilterOption]; /** Pagination parameters of collector comments */ export type CollectorCommentCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: CollectorCommentCursorConnectionSort; }; /** Customize sort of release shelves */ export type CollectorCommentCursorConnectionSort = { /** Sort by date of comment creation */ createdAt?: InputMaybe; }; /** Filter the releases to be searched */ export type CollectorSearchFilter = { /** Genre names to filter on for collector's releases */ genres?: InputMaybe>; /** Location ids to filter on for collector's releases */ locationIds?: InputMaybe>; }; /** Customize sort of collectors */ export type CollectorSearchSort = { /** Sort by number of distinct artists the collector backed */ artistsBacked?: InputMaybe; /** Sort by creation date */ createdAt?: InputMaybe; /** Sort by number of nfts */ nftsCount?: InputMaybe; /** Sort by number of mints of each release */ totalMinted?: InputMaybe; /** Sort by total volume of all collector releases */ totalVolume?: InputMaybe; }; /** Defines sort order of Collector fields, array index defines tiebreaking */ export type CollectorSortInput = { /** Field to be sorted */ field: SearchCollectorsSortEnum; /** Sort ascending or descending */ order: SortOrder; }; /** Input for release by contract */ export type ContractReleaseInput = { /** Contract address */ contractAddress: Scalars['Address']; /** Optional edition identifier */ editionId?: InputMaybe; }; /** Contract type on chain */ export declare const ContractType: { readonly ARTIST: "ARTIST"; readonly EDITION: "EDITION"; readonly TIERED_EDITION: "TIERED_EDITION"; }; export type ContractType = (typeof ContractType)[keyof typeof ContractType]; /** Credit role type */ export declare const CreditRoleType: { readonly ARTIST: "ARTIST"; readonly CURATOR: "CURATOR"; readonly OTHER: "OTHER"; readonly PRODUCER: "PRODUCER"; readonly REMIXER: "REMIXER"; readonly SONGWRITER: "SONGWRITER"; readonly VISUAL_ARTIST: "VISUAL_ARTIST"; }; export type CreditRoleType = (typeof CreditRoleType)[keyof typeof CreditRoleType]; /** Base cursor connection arguments */ export type CursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Sort the connection ascending or descending */ sort?: SortOrder; }; /** Input for draftAllowListFromRelease query */ export type DraftAllowlistFromReleaseInput = { /** Merkle tree root */ merkleRoot: Scalars['String']; /** Release identifier */ releaseId: Scalars['UUID']; }; /** Different draft allow list types */ export declare const DraftAllowlistType: { readonly ARTIST_COLLECTORS: "ARTIST_COLLECTORS"; readonly MANUALLY_ADDED_COLLECTORS: "MANUALLY_ADDED_COLLECTORS"; readonly RELEASE_COLLECTORS: "RELEASE_COLLECTORS"; }; export type DraftAllowlistType = (typeof DraftAllowlistType)[keyof typeof DraftAllowlistType]; /** Filter the edition owned tokenIds result */ export type EditionOwnedTokenIdsFilter = { /** Should it include golden egg */ includeGoldenEgg?: Scalars['Boolean']; }; /** Input for editionOwnedTokenIds query */ export type EditionOwnedTokenIdsInput = { /** Edition contract address */ editionContractAddress: Scalars['Address']; /** Filter the tokenIds */ filter?: EditionOwnedTokenIdsFilter; /** Limit the amount of token ids to be returned. By default there is no limit */ limit?: InputMaybe; /** Public address of owner */ ownerPublicAddress: Scalars['Address']; /** Customize sort behavior */ sort?: NftCursorConnectionSort; }; /** List of genres available on the platform */ export declare const Genres: { readonly AFROBEAT: "AFROBEAT"; readonly ALTERNATIVE_ROCK: "ALTERNATIVE_ROCK"; readonly AMBIENT: "AMBIENT"; readonly BOUNCE: "BOUNCE"; readonly CLASSICAL: "CLASSICAL"; readonly COUNTRY: "COUNTRY"; readonly DANCEHALL: "DANCEHALL"; readonly DANCE_EDM: "DANCE_EDM"; readonly DEEP_HOUSE: "DEEP_HOUSE"; readonly DISCO: "DISCO"; readonly DOWNTEMPO: "DOWNTEMPO"; readonly DRUM_BASS: "DRUM_BASS"; readonly DUBSTEP: "DUBSTEP"; readonly ELECTRONIC: "ELECTRONIC"; readonly EXPERIMENTAL: "EXPERIMENTAL"; readonly FOLK_SINGER_SONGWRITER: "FOLK_SINGER_SONGWRITER"; readonly HIP_HOP_RAP: "HIP_HOP_RAP"; readonly HOUSE: "HOUSE"; readonly INDIE: "INDIE"; readonly JAZZ_BLUES: "JAZZ_BLUES"; readonly LATIN: "LATIN"; readonly LOFI: "LOFI"; readonly METAL: "METAL"; readonly PIANO: "PIANO"; readonly POP: "POP"; readonly REGGAE: "REGGAE"; readonly REGGAETON: "REGGAETON"; readonly ROCK: "ROCK"; readonly R_B_SOUL: "R_B_SOUL"; readonly SOUNDTRACK: "SOUNDTRACK"; readonly TECHNO: "TECHNO"; readonly TRANCE: "TRANCE"; readonly TRAP: "TRAP"; readonly TRIPHOP: "TRIPHOP"; readonly WORLD: "WORLD"; }; export type Genres = (typeof Genres)[keyof typeof Genres]; /** Customize iframe html parameters */ export type IframeHtmlParameters = { /** Customize height */ height: Scalars['String']; /** Customize style */ style: Scalars['String']; /** Customize width */ width: Scalars['String']; }; /** Status of Key Client */ export declare const KeyClientStatus: { readonly ACTIVE: "ACTIVE"; readonly INACTIVE: "INACTIVE"; }; export type KeyClientStatus = (typeof KeyClientStatus)[keyof typeof KeyClientStatus]; /** License for the release */ export declare const LicenseType: { readonly ALL_RIGHTS_RESERVED: "ALL_RIGHTS_RESERVED"; readonly CREATIVE_COMMONS: "CREATIVE_COMMONS"; }; export type LicenseType = (typeof LicenseType)[keyof typeof LicenseType]; /** Input used for link query */ export type LinkInput = { /** Link slug */ slug: Scalars['NonEmptyString']; }; /** Type of media entity, either Images or Audio */ export declare const MediaType: { readonly ARTIST_BANNER_IMAGE: "ARTIST_BANNER_IMAGE"; readonly ARTIST_COLLECTORS_CSV: "ARTIST_COLLECTORS_CSV"; readonly ARTIST_FREE_SALE_ALLOWLIST: "ARTIST_FREE_SALE_ALLOWLIST"; readonly ARTIST_PRESALE_ALLOWLIST: "ARTIST_PRESALE_ALLOWLIST"; readonly AUDIO: "AUDIO"; readonly AUDIO_128K: "AUDIO_128K"; readonly AUDIO_192K: "AUDIO_192K"; readonly AUDIO_256K: "AUDIO_256K"; readonly AUDIO_HLS: "AUDIO_HLS"; readonly AVATAR_IMAGE: "AVATAR_IMAGE"; readonly DRAFT_ALLOWLISTED_ADDRESSES_CSV: "DRAFT_ALLOWLISTED_ADDRESSES_CSV"; readonly MERKLE_TREE_CSV: "MERKLE_TREE_CSV"; readonly RELEASE_BANNER_IMAGE: "RELEASE_BANNER_IMAGE"; readonly RELEASE_COVER_IMAGE: "RELEASE_COVER_IMAGE"; readonly RELEASE_GA_COVER_IMAGE: "RELEASE_GA_COVER_IMAGE"; readonly RELEASE_GA_WEB_ANIMATED_IMAGE: "RELEASE_GA_WEB_ANIMATED_IMAGE"; readonly RELEASE_GA_WEB_STATIC_AUTOGEN_IMAGE: "RELEASE_GA_WEB_STATIC_AUTOGEN_IMAGE"; readonly RELEASE_GA_WEB_STATIC_IMAGE: "RELEASE_GA_WEB_STATIC_IMAGE"; readonly RELEASE_GOLDEN_EGG_IMAGE: "RELEASE_GOLDEN_EGG_IMAGE"; readonly RELEASE_HOLDERS_CSV: "RELEASE_HOLDERS_CSV"; readonly RELEASE_WEB_ANIMATED_GOLDEN_EGG_IMAGE: "RELEASE_WEB_ANIMATED_GOLDEN_EGG_IMAGE"; readonly RELEASE_WEB_ANIMATED_IMAGE: "RELEASE_WEB_ANIMATED_IMAGE"; readonly RELEASE_WEB_STATIC_AUTOGEN_IMAGE: "RELEASE_WEB_STATIC_AUTOGEN_IMAGE"; readonly RELEASE_WEB_STATIC_IMAGE: "RELEASE_WEB_STATIC_IMAGE"; readonly SHELF_COVER_IMAGE: "SHELF_COVER_IMAGE"; readonly TMP_ARTIST_BANNER_AUTOGEN_IMAGE: "TMP_ARTIST_BANNER_AUTOGEN_IMAGE"; readonly TMP_AVATAR_AUTOGEN_IMAGE: "TMP_AVATAR_AUTOGEN_IMAGE"; readonly TMP_USER_BANNER_AUTOGEN_IMAGE: "TMP_USER_BANNER_AUTOGEN_IMAGE"; readonly USER_BANNER_IMAGE: "USER_BANNER_IMAGE"; }; export type MediaType = (typeof MediaType)[keyof typeof MediaType]; /** Mint current time status */ export declare const MintTimeStatus: { readonly PAST: "PAST"; readonly UPCOMING: "UPCOMING"; }; export type MintTimeStatus = (typeof MintTimeStatus)[keyof typeof MintTimeStatus]; /** Filter minted releases */ export type MintedReleasesCursorFilterArgs = { /** Specify up to 50 contracts to filter the releases */ contracts?: InputMaybe>; /** Only get releases from specified genres */ genre?: InputMaybe>; /** Only get releases from specified genres */ genres?: InputMaybe>; /** Remove currently-featured releases from results */ hideFeatured?: InputMaybe; /** Location ids to filter on for releases */ locationIds?: InputMaybe>; /** Only get releases less or equal to than specified mint time */ mintTimeMaxDate?: InputMaybe; /** Only get releases greater than or equal to specified mint time */ mintTimeMinDate?: InputMaybe; /** Only get release with specified mint time status */ mintTimeStatus?: InputMaybe>; /** Filters on whether album releases have been revealed or not */ releaseAlbumRevealStatus?: InputMaybe; /** Only get release with specified status */ releaseStatus?: InputMaybe>; /** Filters on release type */ releaseType?: Array; /** Only get releases from specified seasons */ season?: InputMaybe>; }; /** Cursor connection parameters for NFTs */ export type NftCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: NftCursorConnectionSort; }; /** Customize the sort behavior of Nfts pagination */ export type NftCursorConnectionSort = { /** Sort by date of primary sale */ primarySaleDate?: InputMaybe; /** Sort by date of last secondary sale with default value of primary sale date */ secondarySaleDate?: InputMaybe; /** Sort by serial number */ serialNumber?: InputMaybe; }; /** Input for "nft" Query */ export type NftInput = { /** Contract address of edition */ contractAddress: Scalars['Address']; /** Token unique identifier within edition */ tokenId: Scalars['String']; }; /** Platform type */ export declare const PlatformType: { readonly ANDROID: "ANDROID"; readonly IOS: "IOS"; readonly WEB: "WEB"; }; export type PlatformType = (typeof PlatformType)[keyof typeof PlatformType]; /** Filter PlaylistAction details */ export type PlaylistActionFilterArgs = { /** If set, only show artist owned releases in paginated release results. Does not apply if the playlist is owned by the artist */ releaseArtistId?: InputMaybe; }; /** Cursor connection parameters */ export type PlaylistActionReleasesCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the number of nodes to be fetched, to be used with "after", with a maximum of 25 nodes */ first?: InputMaybe; /** Limit the number of nodes to be fetched, to be used with "before", with a maximum of 25 nodes */ last?: InputMaybe; /** Sort the releases ascending or descending by release creation date */ sort?: SortOrder; }; /** Pagination paramaters for release chart ranks */ export type PlaylistChartRankCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: PlaylistChartRankCursorConnectionSort; }; /** Customize sort of collectors */ export type PlaylistChartRankCursorConnectionSort = { /** Sort by playlist chart current rank */ currentRank?: InputMaybe; }; /** Playlist input */ export type PlaylistInput = { /** Association ID based on type of playlist */ associationId?: InputMaybe; /** Type of playlist */ type: PlaylistType; }; /** Currently supported playlists */ export declare const PlaylistType: { readonly ARTIST: "ARTIST"; readonly HOLDER: "HOLDER"; readonly HOME: "HOME"; }; export type PlaylistType = (typeof PlaylistType)[keyof typeof PlaylistType]; /** Cursor connection parameters for Post Comments */ export type PostCommentCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: PostCommentCursorConnectionSort; }; /** Customize the sort behavior of Post Comments pagination */ export type PostCommentCursorConnectionSort = { /** Sort by created date */ createdAt?: InputMaybe; }; /** Pagination parameters of referred users */ export type ReferredUsersCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 25 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 25 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ReferredUsersCursorConnectionSort; }; /** Customize the sort behavior of release affiliates total purchases */ export type ReferredUsersCursorConnectionSort = { /** Sort by purchase block number */ blockNumber?: InputMaybe; }; /** Input for referred users within release affiliate total purchases */ export type ReferredUsersInput = { /** Pagination parameters */ pagination?: ReferredUsersCursorConnectionArgs; }; /** Filter release activity types */ export type ReleaseActivityFeedFilterArgs = { /** Only get activity of given type */ types?: Array; }; /** Release activity feed input parameters */ export type ReleaseActivityFeedInput = { /** Only get activities of given types */ filter?: ReleaseActivityFeedFilterArgs; /** Pagination parameters */ pagination?: CursorConnectionArgs; }; /** Release activity feed type filter option */ export declare const ReleaseActivityFeedTypeFilterOption: { readonly ALL: "ALL"; readonly COLLECTIONS: "COLLECTIONS"; readonly LIKES: "LIKES"; readonly PLAYLISTS: "PLAYLISTS"; readonly RELEASES: "RELEASES"; }; export type ReleaseActivityFeedTypeFilterOption = (typeof ReleaseActivityFeedTypeFilterOption)[keyof typeof ReleaseActivityFeedTypeFilterOption]; /** Release album reveal filter option */ export declare const ReleaseAlbumRevealFilterOption: { readonly ALL: "ALL"; readonly ONLY_NOT_REVEALED_ALBUMS: "ONLY_NOT_REVEALED_ALBUMS"; readonly ONLY_REVEALED_ALBUMS: "ONLY_REVEALED_ALBUMS"; }; export type ReleaseAlbumRevealFilterOption = (typeof ReleaseAlbumRevealFilterOption)[keyof typeof ReleaseAlbumRevealFilterOption]; /** Input for releaseAllowlist query */ export type ReleaseAllowlistInput = { /** Merkle tree root */ merkleRoot: Scalars['String']; /** Release identifier */ releaseId: Scalars['UUID']; }; /** Input for releaseChart query */ export type ReleaseChartByLastDayInput = { /** Locate chart using the last date of the period (inclusive) */ lastDayOfChartInclusive: Scalars['DateTime']; }; /** Pagination paramaters for release charts */ export type ReleaseChartCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ReleaseChartCursorConnectionSort; }; /** Customize sort of release charts */ export type ReleaseChartCursorConnectionSort = { /** Sort by release chart period end exclusive */ periodEndExclusive?: InputMaybe; }; /** Input for releaseChart query */ export type ReleaseChartInput = { /** Filter on periodEnd date */ periodEndExclusive: Scalars['DateTime']; }; /** Pagination paramaters for release chart ranks */ export type ReleaseChartRankCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ReleaseChartRankCursorConnectionSort; }; /** Customize sort of collectors */ export type ReleaseChartRankCursorConnectionSort = { /** Sort by release chart current rank */ currentRank?: InputMaybe; }; /** Input for releaseChartRank query */ export type ReleaseChartRankInput = { /** Release Chart Rank entity id */ id: Scalars['UUID']; }; /** Input for releaseChart query */ export type ReleaseChartsInput = { /** Cursor connection parameters */ pagination?: ReleaseChartCursorConnectionArgs; }; /** Pagination parameters for release collectors */ export type ReleaseCollectorCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ReleaseCollectorCursorConnectionSort; /** The NFT tier you want to select for ReleaseCollectors, defaults All */ tier?: InputMaybe; }; /** Customize sort of collectors */ export type ReleaseCollectorCursorConnectionSort = { /** Sort by first nft collected date */ firstNftCollectedDate?: InputMaybe; /** Sort by amount ga nfts collected, with tie-breaker of earliest collector first */ gaNftsCount?: InputMaybe; /** Sort by lowest owned serial number */ lowestOwnedSerialNumber?: InputMaybe; /** Sort by amount nfts collected, with tie-breaker of earliest collector first */ nftsCount?: InputMaybe; /** Sort by vips first, then ga, tie-breaker of first nft collected date */ priorityFirstNftDate?: InputMaybe; /** Sort by vips first, then ga, tie-breaker most nfts collected */ priorityTop?: InputMaybe; /** Sort by amount vip nfts collected, with tie-breaker of earliest collector first */ vipNftsCount?: InputMaybe; }; /** Release featured status */ export declare const ReleaseFeaturedStatus: { readonly ALL: "ALL"; readonly HOT: "HOT"; }; export type ReleaseFeaturedStatus = (typeof ReleaseFeaturedStatus)[keyof typeof ReleaseFeaturedStatus]; /** Input for "releaseFromToken" query */ export type ReleaseFromTokenInput = { /** Contract address of release */ contractAddress: Scalars['Address']; /** Token chain identifier */ tokenId: Scalars['String']; }; /** Filter the releases to be searched */ export type ReleaseSearchFilter = { /** Filter releases that are made by specified artists. You can only specify up to 51 artists. */ artistIds?: InputMaybe>; /** Genre names to filter on for releases */ genres?: InputMaybe>; /** Only include releases that either have or don't have collectors */ hasCollectors?: InputMaybe; /** Location ids to filter on for releases */ locationIds?: InputMaybe>; /** Only get release with specified status */ releaseStatus?: InputMaybe>; /** Filters on release type */ type?: InputMaybe>; }; /** Customize sort of releases */ export type ReleaseSearchSort = { /** Sort by time the release was minted */ mintStartTime?: InputMaybe; /** Sort by number of mints of each release */ totalMinted?: InputMaybe; /** Sort by total volume of each release */ totalVolume?: InputMaybe; }; /** Pagination parameters of release shelves */ export type ReleaseShelvesCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ReleaseShelvesCursorConnectionSort; }; /** Customize sort of release shelves */ export type ReleaseShelvesCursorConnectionSort = { /** Sort by date of release being added in the shelf */ addedAtDate?: InputMaybe; /** Sort by shelf score */ score?: InputMaybe; }; /** Filter release shelves */ export type ReleaseShelvesFilter = { /** Filter shelves to be included by identifier. You can only specify up to 51 shelves. */ shelfIds?: InputMaybe>; /** Filter shelves types to be included */ type?: InputMaybe>; }; /** Defines sort order of Release fields, array index defines tiebreaking */ export type ReleaseSortInput = { /** Field to be sorted */ field: SearchReleasesSortEnum; /** Sort ascending or descending */ order: SortOrder; }; /** Release current status type */ export declare const ReleaseStatus: { readonly AVAILABLE_TO_MINT: "AVAILABLE_TO_MINT"; readonly SOLD_OUT: "SOLD_OUT"; readonly UPCOMING: "UPCOMING"; }; export type ReleaseStatus = (typeof ReleaseStatus)[keyof typeof ReleaseStatus]; /** Release type, currently the platform only supports "SINGLE" */ export declare const ReleaseType: { readonly ALBUM: "ALBUM"; readonly ALBUM_TRACK: "ALBUM_TRACK"; readonly SINGLE: "SINGLE"; }; export type ReleaseType = (typeof ReleaseType)[keyof typeof ReleaseType]; /** Input for Release.webEmbed */ export type ReleaseWebEmbedInput = { /** Customize html parameters */ html?: IframeHtmlParameters; /** Referral address */ referralAddress?: InputMaybe; }; /** Customize webapp uri parameters of release */ export type ReleaseWebappUriInput = { /** Referral address */ referralAddress?: InputMaybe; }; export declare const ReleasesCollectorSortEnum: { readonly FIRST_NFT_COLLECTED_DATE: "FIRST_NFT_COLLECTED_DATE"; readonly NFTS_COUNT: "NFTS_COUNT"; }; export type ReleasesCollectorSortEnum = (typeof ReleasesCollectorSortEnum)[keyof typeof ReleasesCollectorSortEnum]; /** Pagination parameters for releases connection */ export type ReleasesCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Start after the first "skip" entities based. It can't be specified alongside "after" or "before" */ skip?: InputMaybe; /** Customize sort behavior of releases pagination */ sort?: ReleasesCursorConnectionSort; }; /** Customize sort behavior of releases pagination */ export type ReleasesCursorConnectionSort = { /** Sort by createdAt of release */ createdAt?: InputMaybe; /** Sort by mintStartTime of release */ mintStartTime?: InputMaybe; }; /** Filter releases */ export type ReleasesCursorFilterArgs = { /** Filter by getting releases of the artists followed by the specified user identifier */ artistFollowedByUser?: InputMaybe; /** Specify up to 50 contracts to filter the releases */ contracts?: InputMaybe>; /** Filters on release featured status */ featuredStatus?: InputMaybe; /** Only get releases from specified genres */ genre?: InputMaybe>; /** Only get releases from specified genres */ genres?: InputMaybe>; /** Remove currently-featured releases from results */ hideFeatured?: InputMaybe; /** Location ids to filter on for releases */ locationIds?: InputMaybe>; /** Only get releases less or equal to than specified mint time */ mintTimeMaxDate?: InputMaybe; /** Only get releases greater than or equal to specified mint time */ mintTimeMinDate?: InputMaybe; /** Only get release with specified mint time status */ mintTimeStatus?: InputMaybe>; /** Filters on whether album releases have been revealed or not */ releaseAlbumRevealStatus?: InputMaybe; /** Only get release with specified status */ releaseStatus?: InputMaybe>; /** Filters on release type */ releaseType?: InputMaybe>; /** Only get releases from specified seasons */ season?: InputMaybe>; }; /** Input for reportPlayStopped mutation */ export type ReportPlayStoppedInput = { /** End of play session */ finish: Scalars['Timestamp']; /** Duration of play in seconds */ listenDuration: Scalars['Int']; /** Amount of pauses on the same session */ pauseCount: Scalars['Int']; /** Start of play session */ start: Scalars['Timestamp']; /** Track UUID */ trackId: Scalars['UUID']; /** Random UUID generated by client-side */ uuid: Scalars['String']; }; export declare const SearchArtistsSortEnum: { readonly CREATED_AT: "CREATED_AT"; readonly TOTAL_MINTED: "TOTAL_MINTED"; readonly TOTAL_VOLUME: "TOTAL_VOLUME"; }; export type SearchArtistsSortEnum = (typeof SearchArtistsSortEnum)[keyof typeof SearchArtistsSortEnum]; export declare const SearchCollectorsSortEnum: { readonly ARTISTS_BACKED: "ARTISTS_BACKED"; readonly CREATED_AT: "CREATED_AT"; readonly NFTS_COUNT: "NFTS_COUNT"; readonly TOTAL_MINTED: "TOTAL_MINTED"; readonly TOTAL_VOLUME: "TOTAL_VOLUME"; }; export type SearchCollectorsSortEnum = (typeof SearchCollectorsSortEnum)[keyof typeof SearchCollectorsSortEnum]; /** Pagination arguments for search */ export type SearchConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 20 nodes. */ first?: Scalars['PositiveInt']; }; /** Input for "search" query */ export type SearchInput = { /** How many entities to be fetched for fixed lists, maximum of 20 */ limit?: Scalars['PositiveInt']; /** Text search */ text?: InputMaybe; }; export declare const SearchReleasesSortEnum: { readonly MINT_START_TIME: "MINT_START_TIME"; readonly TOTAL_MINTED: "TOTAL_MINTED"; readonly TOTAL_VOLUME: "TOTAL_VOLUME"; }; export type SearchReleasesSortEnum = (typeof SearchReleasesSortEnum)[keyof typeof SearchReleasesSortEnum]; export declare const SearchShelvesSortEnum: { readonly CREATED_AT: "CREATED_AT"; readonly NUM_LIKES: "NUM_LIKES"; readonly NUM_REFERRAL_PURCHASES: "NUM_REFERRAL_PURCHASES"; }; export type SearchShelvesSortEnum = (typeof SearchShelvesSortEnum)[keyof typeof SearchShelvesSortEnum]; /** Cursor connection parameters for shelves */ export type ShelfCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Customize sort behavior */ sort?: ShelfCursorConnectionSort; }; /** Customize the sort behavior of shelves pagination */ export type ShelfCursorConnectionSort = { /** Sort by created at date */ createdAt?: InputMaybe; /** Sort by shelf index value */ index?: InputMaybe; }; /** Cursor connection parameters for shelf ordered releases */ export type ShelfOrderedReleaseCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; }; /** Customize sort behavior of shelf releases */ export type ShelfReleasesSort = { /** Sort by release added to shelf date */ addedToShelfDate?: InputMaybe; /** Sort by release index of shelf */ index?: SortOrder; }; /** Filter the shelf to be searched */ export type ShelfSearchFilter = { /** Genre names to filter on for shelf songs */ genres?: InputMaybe>; }; /** Customize sorting of shelves */ export type ShelfSearchSort = { /** Sort by time playlist was created */ createdAt?: InputMaybe; /** Sort by number of likes */ numLikes?: InputMaybe; /** Sort by number of referral purchases (Mints Driven) */ numReferralPurchases?: InputMaybe; }; /** Defines sort order of Shelf fields, array index defines tiebreaking */ export type ShelfSortInput = { /** Field to be sorted */ field: SearchShelvesSortEnum; /** Sort ascending or descending */ order: SortOrder; }; /** Shelf type */ export declare const ShelfType: { readonly DEFAULT: "DEFAULT"; readonly USER_LIKED_SOUNDS: "USER_LIKED_SOUNDS"; }; export type ShelfType = (typeof ShelfType)[keyof typeof ShelfType]; /** Filter based the type of shelf */ export declare const ShelfTypeFilter: { readonly ALL: "ALL"; readonly LIKED: "LIKED"; readonly USER_CREATED: "USER_CREATED"; }; export type ShelfTypeFilter = (typeof ShelfTypeFilter)[keyof typeof ShelfTypeFilter]; /** Input for Shelf.webEmbed */ export type ShelfWebEmbedInput = { /** Customize html parameters */ html?: IframeHtmlParameters; }; /** Key the release was written in */ export declare const SongKeyType: { readonly A_FLAT_MAJOR: "A_FLAT_MAJOR"; readonly A_MAJOR: "A_MAJOR"; readonly A_MINOR: "A_MINOR"; readonly B_FLAT_MAJOR: "B_FLAT_MAJOR"; readonly B_FLAT_MINOR: "B_FLAT_MINOR"; readonly B_MAJOR: "B_MAJOR"; readonly B_MINOR: "B_MINOR"; readonly C_MAJOR: "C_MAJOR"; readonly C_MINOR: "C_MINOR"; readonly C_SHARP_MINOR: "C_SHARP_MINOR"; readonly D_FLAT_MAJOR: "D_FLAT_MAJOR"; readonly D_MAJOR: "D_MAJOR"; readonly D_MINOR: "D_MINOR"; readonly E_FLAT_MAJOR: "E_FLAT_MAJOR"; readonly E_FLAT_MINOR: "E_FLAT_MINOR"; readonly E_MAJOR: "E_MAJOR"; readonly E_MINOR: "E_MINOR"; readonly F_MAJOR: "F_MAJOR"; readonly F_MINOR: "F_MINOR"; readonly F_SHARP_MAJOR: "F_SHARP_MAJOR"; readonly F_SHARP_MINOR: "F_SHARP_MINOR"; readonly G_MAJOR: "G_MAJOR"; readonly G_MINOR: "G_MINOR"; readonly G_SHARP_MINOR: "G_SHARP_MINOR"; }; export type SongKeyType = (typeof SongKeyType)[keyof typeof SongKeyType]; /** Ascending or Descending sort */ export declare const SortOrder: { readonly ASC: "ASC"; readonly DESC: "DESC"; }; export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]; /** The Tier of the NFT owned by ReleaseCollector */ export declare const TierNFT: { readonly ALL: "ALL"; readonly GA: "GA"; readonly VIP: "VIP"; }; export type TierNFT = (typeof TierNFT)[keyof typeof TierNFT]; /** Mode that differentiates behavior of tier schedule */ export declare const TierScheduleMode: { readonly DEFAULT: "DEFAULT"; readonly VERIFY_MERKLE: "VERIFY_MERKLE"; readonly VERIFY_SIGNATURE: "VERIFY_SIGNATURE"; }; export type TierScheduleMode = (typeof TierScheduleMode)[keyof typeof TierScheduleMode]; /** Time period to aggregate trending table queries */ export declare const TimePeriodAggEnum: { readonly ALL_TIME: "ALL_TIME"; readonly ONE_DAY: "ONE_DAY"; readonly ONE_MONTH: "ONE_MONTH"; readonly SEVEN_DAY: "SEVEN_DAY"; }; export type TimePeriodAggEnum = (typeof TimePeriodAggEnum)[keyof typeof TimePeriodAggEnum]; /** Input for top affiliate curators query */ export type TopAffiliateCuratorsInput = { /** Limit the amount to be returned, Up to 100 */ limit?: Scalars['PositiveInt']; /** Sort logic used */ sort: TopCuratorsSortEnum; /** For what time period the data should come from */ timePeriod: TopChartTimePeriodEnum; }; /** Input for top artists query */ export type TopArtistsInput = { /** Limit the amount to be returned, Up to 100 */ limit?: Scalars['PositiveInt']; /** Sort logic used */ sort: TrendingArtistsSortEnum; /** For what time period the data should come from */ timePeriod: TopChartTimePeriodEnum; }; /** Time period to aggregate top chart queries */ export declare const TopChartTimePeriodEnum: { readonly ALL_TIME: "ALL_TIME"; readonly SEVEN_DAY: "SEVEN_DAY"; readonly THIRTY_DAY: "THIRTY_DAY"; }; export type TopChartTimePeriodEnum = (typeof TopChartTimePeriodEnum)[keyof typeof TopChartTimePeriodEnum]; export declare const TopCuratorsSortEnum: { readonly MINTS: "MINTS"; readonly SOUNDS_REFERRED: "SOUNDS_REFERRED"; readonly TOTAL_AFFILIATE_EARNED: "TOTAL_AFFILIATE_EARNED"; readonly TOTAL_VOLUME: "TOTAL_VOLUME"; }; export type TopCuratorsSortEnum = (typeof TopCuratorsSortEnum)[keyof typeof TopCuratorsSortEnum]; /** Input for topPlaylists query */ export type TopPlaylistsInput = { /** Limit the amount to be returned, Up to 100 */ limit?: Scalars['PositiveInt']; /** Sort logic used */ sort: TrendingPlaylistsSortEnum; /** For what time period the data should come from */ timePeriod: TimePeriodAggEnum; }; /** Type of sort parameter used for trending artists */ export declare const TrendingArtistsSortEnum: { readonly NFTS_SOLD: "NFTS_SOLD"; readonly PRIMARY_SALES: "PRIMARY_SALES"; readonly SECONDARY_SALES: "SECONDARY_SALES"; readonly TOTAL_SALES: "TOTAL_SALES"; readonly UNIQUE_COLLECTORS: "UNIQUE_COLLECTORS"; }; export type TrendingArtistsSortEnum = (typeof TrendingArtistsSortEnum)[keyof typeof TrendingArtistsSortEnum]; /** Type of sort paratemer used for trending collectors */ export declare const TrendingCollectorsSortEnum: { readonly CREATORS_SUPPORTED: "CREATORS_SUPPORTED"; readonly NFTS_BOUGHT: "NFTS_BOUGHT"; readonly TOTAL_SPENT: "TOTAL_SPENT"; }; export type TrendingCollectorsSortEnum = (typeof TrendingCollectorsSortEnum)[keyof typeof TrendingCollectorsSortEnum]; /** Trending indicator type */ export declare const TrendingIndicator: { readonly DOWN: "DOWN"; readonly NEW: "NEW"; readonly SAME: "SAME"; readonly UP: "UP"; }; export type TrendingIndicator = (typeof TrendingIndicator)[keyof typeof TrendingIndicator]; /** Type of sort paratemer used for trending playlists */ export declare const TrendingPlaylistsSortEnum: { readonly LIKES: "LIKES"; }; export type TrendingPlaylistsSortEnum = (typeof TrendingPlaylistsSortEnum)[keyof typeof TrendingPlaylistsSortEnum]; /** Type of sort paratemer used for trending releases */ export declare const TrendingReleasesSortEnum: { readonly NFTS_SOLD: "NFTS_SOLD"; readonly PRIMARY_SALES: "PRIMARY_SALES"; readonly SECONDARY_SALES: "SECONDARY_SALES"; readonly TOTAL_SALES: "TOTAL_SALES"; readonly UNIQUE_COLLECTORS: "UNIQUE_COLLECTORS"; }; export type TrendingReleasesSortEnum = (typeof TrendingReleasesSortEnum)[keyof typeof TrendingReleasesSortEnum]; /** User relation type */ export declare const TypeOfRelation: { readonly FOLLOWING: "FOLLOWING"; }; export type TypeOfRelation = (typeof TypeOfRelation)[keyof typeof TypeOfRelation]; /** Filter of User.collectedReleases paginated field */ export type UserCollectedReleasesFilter = { /** Filters on a list of specified genres */ genres?: InputMaybe>; /** Filters on whether album releases have been revealed or not */ releaseAlbumRevealStatus?: ReleaseAlbumRevealFilterOption; /** Filter on a list of specified release ids */ releaseIds?: InputMaybe>; /** Text search on release title or artist's name or handle */ text?: InputMaybe; /** Filters on release type */ type?: InputMaybe>; }; /** Cursor connection parameters */ export type UserCursorConnectionArgs = { /** Start forwards pagination since "after" cursor */ after?: InputMaybe; /** Start backwards pagination since "before" cursor */ before?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "after", with a maximum of 51 nodes. */ first?: InputMaybe; /** Limit the amount of nodes to be fetched, to be used with "before", with a maximum of 51 nodes. */ last?: InputMaybe; /** Sort the users ascending or descending relative to the user creation date */ sort?: SortOrder; }; /** Filter the NFTs of User */ export type UserNftsConnectionFilters = { /** Only include Nfts from specified releases */ releases?: InputMaybe>; }; /** Filter the shelves of a user */ export type UserShelvesFilter = { /** Case-insensitive text search on shelves names */ text?: InputMaybe; /** Filter by different types of shelves available for users. */ type?: ShelfTypeFilter; }; /** Input of VersionSupported query */ export type VersionStatusInput = { /** Platform type */ platform: PlatformType; /** Semantic version */ version: Scalars['SemanticVersion']; }; export type MerkleProofQueryVariables = Exact<{ root: Scalars['String']; unhashedLeaf: Scalars['String']; }>; export type MerkleProofQuery = { merkleTreeProof: { proof: Array; } | null; }; export type ReleaseInfoQueryVariables = Exact<{ contractAddress: Scalars['Address']; editionId?: InputMaybe; }>; export type ReleaseInfoQuery = { release: { id: string; contractAddress: string; editionId: string | null; type: ReleaseType; mintStartTime: number; mintStartTimestamp: number; webappUri: string; externalUrl: string | null; marketPlaceUrl: string | null; title: string; behindTheMusic: string; season: string | null; scheduleIds: Array<{ mintIds: Array; minterAddress: string; }> | null; genre: { id: string; name: string; }; track: { id: string; duration: number; audio: { audio128k: { id: string; url: string; } | null; audio192k: { id: string; url: string; } | null; audio256k: { id: string; url: string; } | null; audioOriginal: { id: string; url: string; }; }; }; artist: { id: string; webappUri: string; season: string | null; soundHandle: string; bannerImage: { id: string; url: string; } | null; user: { id: string; publicAddress: string; description: string | null; displayName: string | null; twitterHandle: string | null; avatar: { id: string; url: string; } | null; }; }; rewards: Array<{ id: string; description: string; title: string; }>; coverImage: { id: string; url: string; }; goldenEggImage: { id: string; url: string; }; eggGame: { id: string; winningSerialNum: number; } | null; } | null; }; export type ReleaseShareInfoQueryVariables = Exact<{ contractAddress: Scalars['Address']; editionId?: InputMaybe; releaseWebappUriInput?: InputMaybe; releaseEmbedUriInput?: InputMaybe; }>; export type ReleaseShareInfoQuery = { release: { id: string; contractAddress: string; editionId: string | null; type: ReleaseType; mintStartTime: number; mintStartTimestamp: number; webappUri: string; webEmbed: string; coverImage: { id: string; url: string; }; track: { id: string; duration: number; audio: { audio128k: { id: string; url: string; } | null; audio192k: { id: string; url: string; } | null; audio256k: { id: string; url: string; } | null; audioOriginal: { id: string; url: string; }; }; }; } | null; }; export type TestQueryVariables = Exact<{ [key: string]: never; }>; export type TestQuery = { __typename: 'Query'; }; export type EditionOwnedTokenIdsQueryVariables = Exact<{ input: EditionOwnedTokenIdsInput; }>; export type EditionOwnedTokenIdsQuery = { editionOwnedTokenIds: Array; }; export declare const MerkleProof = "query MerkleProof($root:String!$unhashedLeaf:String!){merkleTreeProof(root:$root unhashedLeaf:$unhashedLeaf){proof}}"; export declare const ReleaseInfo = "query ReleaseInfo($contractAddress:Address!$editionId:String){release:releaseFromContract(contractAddress:$contractAddress editionId:$editionId){id contractAddress editionId type mintStartTime mintStartTimestamp webappUri externalUrl marketPlaceUrl title behindTheMusic season scheduleIds{mintIds minterAddress}genre{id name}track{id duration audio{audio128k{id url}audio192k{id url}audio256k{id url}audioOriginal{id url}}}artist{id webappUri season soundHandle bannerImage{id url}user{id publicAddress description displayName twitterHandle avatar{id url}}}rewards{id description title}coverImage{id url}goldenEggImage{id url}eggGame{id winningSerialNum}}}"; export declare const ReleaseShareInfo = "query ReleaseShareInfo($contractAddress:Address!$editionId:String$releaseWebappUriInput:ReleaseWebappUriInput$releaseEmbedUriInput:ReleaseWebEmbedInput){release:releaseFromContract(contractAddress:$contractAddress editionId:$editionId){id contractAddress editionId type mintStartTime mintStartTimestamp webappUri(input:$releaseWebappUriInput)webEmbed(input:$releaseEmbedUriInput)coverImage{id url}track{id duration audio{audio128k{id url}audio192k{id url}audio256k{id url}audioOriginal{id url}}}}}"; export declare const Test = "query Test{__typename}"; export declare const EditionOwnedTokenIds = "query EditionOwnedTokenIds($input:EditionOwnedTokenIdsInput!){editionOwnedTokenIds(input:$input)}";