@fxhash/shared 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1501 @@
+import { GPURenderingConfig } from '@fxhash/config';
+import { PromiseResult } from '@fxhash/utils';
+import { JwtPayload } from 'jwt-decode';
+
+interface IPricingFixed<GNumber = number, GDate = Date> {
+    id?: string;
+    price: GNumber;
+    opensAt?: GDate | null;
+    frameMinting?: {
+        enabled?: boolean;
+        mintsPerFid?: number;
+    };
+}
+interface IPricingDutchAuction<N = number> {
+    id?: string;
+    levels: N[];
+    restingPrice?: number;
+    finalPrice?: number;
+    decrementDuration: N;
+    opensAt: Date;
+    refundable: boolean;
+}
+
+interface MediaImage$1 {
+    id: string;
+    width?: number;
+    height?: number;
+    metadata?: {} | null;
+    mimeType?: string;
+    placeholder?: string;
+    processed: boolean;
+}
+
+interface ISplit {
+    address: string;
+    pct: number;
+}
+interface Split {
+    pct: number;
+    user: User;
+}
+
+declare enum ArticleFlag {
+    NONE = "NONE",
+    CLEAN = "CLEAN",
+    REPORTED = "REPORTED",
+    AUTO_DETECT_COPY = "AUTO_DETECT_COPY",
+    MALICIOUS = "MALICIOUS",
+    HIDDEN = "HIDDEN"
+}
+interface NTFArticleLedger {
+    article: NFTArticle;
+    owner: User;
+    amount: number;
+}
+interface NFTArticleRevision {
+    article: NFTArticle;
+    iteration: number;
+    metadataUri: string;
+    createdAt: string;
+    opHash: string;
+}
+interface NFTArticleGenerativeToken {
+    article: NFTArticle;
+    generativeToken: GenerativeToken;
+    line: number;
+}
+type NFTArticleInfos = Pick<NFTArticle, "id" | "title" | "flag" | "slug" | "thumbnailUri" | "thumbnailMedia" | "description" | "tags" | "author" | "createdAt" | "metadataLocked"> & {
+    revisions?: NFTArticleRevision[];
+};
+interface NFTArticle {
+    id: number | string;
+    slug: string;
+    author?: User;
+    ledgers: NTFArticleLedger[];
+    generativeTokenJointures: NFTArticleGenerativeToken[];
+    revisions: NFTArticleRevision[];
+    royaltiesSplits: Split[];
+    actions: Action[];
+    title: string;
+    description: string;
+    body: string;
+    tags: string[];
+    language: string;
+    metadataUri: string;
+    metadata: ArticleMetadata;
+    metadataLocked: boolean;
+    artifactUri: string;
+    displayUri: string;
+    thumbnailUri: string;
+    thumbnailCaption: string;
+    thumbnailMedia?: MediaImage$1;
+    platforms?: string[] | null;
+    createdAt: string;
+    editions: number;
+    royalties: number;
+    mintOpHash: string;
+    relatedArticles: NFTArticle[];
+    flag: ArticleFlag;
+    moderationReason?: string;
+}
+interface NFTArticleFilters {
+    author_eq?: string;
+    metadataLocked_eq?: string;
+    editions_lte?: string;
+    editions_gte?: string;
+    royalties_lte?: string;
+    royalties_gte?: string;
+    searchQuery_eq?: string;
+    flag_in?: ArticleFlag[];
+    flag_eq?: ArticleFlag;
+    flag_ne?: ArticleFlag;
+}
+
+interface ArticleGenerativeTokenMention {
+    line: number;
+    article: NFTArticle;
+    generativeToken: GenerativeToken;
+}
+
+interface Listing {
+    id: string;
+    version: number;
+    amount: number;
+    issuer: User;
+    issuerId: number;
+    objkt: Objkt;
+    price: number;
+    royalties: number;
+    createdAt: Date;
+    updatedAt: Date;
+    article: NFTArticle;
+}
+interface ListingFilters {
+    price_gte?: string;
+    price_lte?: string;
+    fullyMinted_eq?: boolean;
+    authorVerified_eq?: boolean;
+    searchQuery_eq?: string;
+    tokenSupply_lte?: number;
+    tokenSupply_gte?: number;
+}
+
+interface Offer {
+    id: string;
+    version: number;
+    buyer: User;
+    objkt: Objkt;
+    price: number;
+    createdAt: string;
+    cancelledAt: string;
+    acceptedAt: string;
+}
+interface CollectionOffer {
+    id: string;
+    version: number;
+    buyer: User;
+    token: GenerativeToken;
+    price: number;
+    amount: number;
+    createdAt: string;
+    cancelledAt: string;
+    completedAt: string;
+}
+type AnyOffer = Offer | CollectionOffer;
+declare const offerTypeGuard: (offer: AnyOffer) => offer is Offer;
+
+interface EventMedia {
+    s3key: string;
+    name: string;
+    url: string;
+}
+
+interface IAddress {
+    firstName: string;
+    lastName: string;
+    address: string;
+    postalCode: string;
+    city: string;
+    state: string;
+    country: string;
+}
+interface Redeemable {
+    address: string;
+    token: GenerativeToken;
+    baseAmount: number;
+    maxConsumptionsPerToken: number;
+    splits: Split[];
+    redemptions: Redemption[];
+    createdAt: string;
+    redeemedPercentage: number;
+}
+interface RedeemableOptionValue {
+    label: string;
+    amount: number;
+}
+interface RedeemableOption {
+    label: string;
+    values: RedeemableOptionValue[];
+}
+declare enum RedeemableUserActionType {
+    INPUT_ADDRESS = "INPUT_ADDRESS",
+    INPUT_EMAIL = "INPUT_EMAIL",
+    INPUT_PHONE = "INPUT_PHONE",
+    INPUT_LIST = "INPUT_LIST"
+}
+interface RedeemableUserAction {
+    id: string;
+    type: RedeemableUserActionType;
+    options: any;
+}
+interface RedeemablePublicDefinition {
+    userActions: RedeemableUserAction[];
+}
+interface RedeemableDetails {
+    address: string;
+    name: string;
+    active: boolean;
+    amount: number;
+    createdAt: Date;
+    expiresAt: string | null;
+    description: string;
+    successInfos: string;
+    fa2: string;
+    maxConsumptions: number;
+    options: RedeemableOption[];
+    publicDefinition: RedeemablePublicDefinition;
+    splits: ISplit[];
+    medias: {
+        index: number;
+        media: EventMedia;
+    }[];
+}
+type RedeemableUserActionOptions = {
+    [T in RedeemableUserActionType]: {
+        [RedeemableUserActionType.INPUT_ADDRESS]: {
+            label: string;
+            hint?: string;
+        };
+        [RedeemableUserActionType.INPUT_EMAIL]: {
+            label: string;
+            hint?: string;
+        };
+        [RedeemableUserActionType.INPUT_PHONE]: {
+            label: string;
+            hint?: string;
+        };
+        [RedeemableUserActionType.INPUT_LIST]: {
+            label: string;
+            hint?: string;
+            values: string[];
+            multiple: boolean;
+            placeholder?: string;
+        };
+    }[T];
+};
+type RedeemableUserActionInputType = {
+    [T in RedeemableUserActionType]: {
+        [RedeemableUserActionType.INPUT_ADDRESS]: IAddress;
+        [RedeemableUserActionType.INPUT_EMAIL]: string;
+        [RedeemableUserActionType.INPUT_PHONE]: string;
+        [RedeemableUserActionType.INPUT_LIST]: string;
+    }[T];
+};
+
+interface Redemption {
+    id: number;
+    redeemable: Redeemable;
+    objkt: Objkt;
+    redeemer: User;
+    createdAt: string;
+}
+
+interface Objkt {
+    id: string;
+    version: number;
+    issuer: GenerativeToken;
+    owner?: User | null;
+    minter?: User | null;
+    assigned?: boolean;
+    generationHash?: string;
+    inputBytes?: string | null;
+    duplicate?: boolean;
+    iteration?: number;
+    mintedPrice?: number;
+    tags: string[];
+    name?: string;
+    slug?: string;
+    metadata?: ObjktMetadata;
+    features?: TokenFeature[] | null;
+    rarity?: number | null;
+    metadataUri: string;
+    royalties: number;
+    royaltiesSplit: Split[];
+    activeListing?: Listing | null;
+    offers?: Offer[];
+    actions?: Action[];
+    createdAt: string;
+    updatedAt: string;
+    assignedAt: string | null;
+    captureMedia?: MediaImage$1;
+    redemptions: Redemption[];
+    availableRedeemables: Redeemable[];
+}
+interface ObjktFilters {
+    activeListing_exist?: boolean;
+    redeemable_eq?: boolean;
+    redeemed_eq?: boolean;
+}
+declare enum EObjktFeatureType {
+    BOOLEAN = "BOOLEAN",
+    STRING = "STRING",
+    NUMBER = "NUMBER"
+}
+interface IObjktFeatureFilter {
+    name: string;
+    values: string[];
+    type: EObjktFeatureType;
+}
+declare function objktFeatureType(value: any): EObjktFeatureType;
+
+interface Report {
+    id: string;
+    user?: User;
+    token?: GenerativeToken;
+    createdAt: Date;
+}
+
+declare enum EReserveMethod {
+    WHITELIST = "WHITELIST",
+    MINT_PASS = "MINT_PASS"
+}
+interface IWhitelistData<T = number> {
+    address: string;
+    pct: T;
+}
+type ReserveWhiteList<T = number> = {
+    method: EReserveMethod.WHITELIST;
+    data: IWhitelistData<T>[];
+    amount: T;
+};
+declare function isReserveWhiteList(reserve: IReserve): reserve is ReserveWhiteList;
+type ReserveMintPass<T = number> = {
+    method: EReserveMethod.MINT_PASS;
+    data: string;
+    amount: T;
+};
+declare function isReserveMintPass<T = number>(reserve: IReserve<T>): reserve is ReserveMintPass<T>;
+type IReserve<T = number> = ReserveWhiteList<T> | ReserveMintPass<T>;
+interface IReserveMintInput {
+    method: EReserveMethod;
+    data: any;
+}
+
+interface MintTicket {
+    id: number;
+    token: GenerativeToken;
+    owner: User;
+    createdAt: Date;
+    price: number;
+    taxationLocked: string;
+    taxationStart: Date;
+    taxationPaidUntil: Date;
+    settings: MintTicketSettings;
+}
+interface MintTicketSettings {
+    token: GenerativeToken;
+    gracingPeriod: number;
+    metadata: MintTicketMetadata;
+    metadataUri?: string;
+    captureMedia?: MediaImage$1;
+}
+interface MintTicketMetadata {
+}
+
+declare enum GenTokFlag {
+    NONE = "NONE",
+    CLEAN = "CLEAN",
+    REPORTED = "REPORTED",
+    AUTO_DETECT_COPY = "AUTO_DETECT_COPY",
+    MALICIOUS = "MALICIOUS",
+    HIDDEN = "HIDDEN"
+}
+declare enum GenTokPricing {
+    FIXED = "FIXED",
+    DUTCH_AUCTION = "DUTCH_AUCTION"
+}
+declare enum GenTokLabel {
+    EPILEPTIC_TRIGGER = 0,
+    SEXUAL_CONTENT = 1,
+    SENSITIVE = 2,
+    IMAGE_COMPOSITION = 100,
+    ANIMATED = 101,
+    INTERACTIVE = 102,
+    PFP = 103,
+    AUDIO = 104,
+    INCLUDE_PRERENDERED_COMPONENTS = 105,
+    CUSTOM_MINTING_INTERFACE = 106,
+    FXHACKATHON2023 = 302023
+}
+declare enum GenTokLabelGroup {
+    WARNING = "WARNING",
+    DETAILS = "DETAILS",
+    HIGHLIGHT = "HIGHLIGHT"
+}
+interface GenTokLabelDefinition {
+    label: string;
+    shortLabel: string;
+    group: GenTokLabelGroup;
+    description?: string;
+    icon?: string;
+    showWarningSetting?: string;
+    showWarningOn?: "preview" | "run";
+}
+declare const GenTokLabel_Params: GenTokLabelDefinition;
+declare const GenTokLabel_Redeemable: GenTokLabelDefinition;
+interface GenerativeTokenMarketStats {
+    floor: number | null;
+    median: number | null;
+    listed: number | null;
+    highestSold: number | null;
+    lowestSold: number | null;
+    primVolume: number | null;
+    primVolumeFiat: number | null;
+    primVolumeNb: number | null;
+    secVolume: number | null;
+    secVolumeFiat: number | null;
+    secVolumeNb: number | null;
+    secVolume24: number | null;
+    secVolumeFiat24: number | null;
+    secVolumeNb24: number | null;
+    secVolume7d: number | null;
+    secVolumeFiat7d: number | null;
+    secVolumeNb7d: number | null;
+    secVolume30d: number | null;
+    secVolumeFiat30d: number | null;
+    secVolumeNb30d: number | null;
+    generativeToken?: GenerativeToken;
+}
+interface GenerativeTokenMarketStatsHistory {
+    floor: number | null;
+    median: number | null;
+    listed: number | null;
+    highestSold: number | null;
+    lowestSold: number | null;
+    primVolume: number | null;
+    primVolumeFiat: number | null;
+    primVolumeNb: number | null;
+    secVolume: number | null;
+    secVolumeFiat: number | null;
+    secVolumeNb: number | null;
+    from: string;
+    to: string;
+}
+declare enum GenerativeTokenVersion {
+    "PRE_V3" = "PRE_V3",
+    V3 = "V3",
+    ETH_V1 = "ETH_V1",
+    BASE_V1 = "BASE_V1"
+}
+interface GenerativeToken {
+    id: string;
+    version: GenerativeTokenVersion;
+    author: User;
+    name: string;
+    flag: GenTokFlag;
+    reports?: Report[];
+    slug?: string;
+    metadata: GenerativeTokenMetadata;
+    metadataUri?: string;
+    generativeUri?: string;
+    thumbnailUri?: string;
+    displayUri?: string;
+    tags?: string[];
+    labels?: number[];
+    price: number;
+    pricingFixed?: IPricingFixed;
+    pricingDutchAuction?: IPricingDutchAuction;
+    originalSupply: number;
+    supply: number;
+    balance: number;
+    iterationsCount?: number;
+    openEditions: boolean;
+    openEditionsEndsAt?: string | null;
+    enabled: boolean;
+    royalties: number;
+    splitsPrimary: Split[];
+    splitsSecondary: Split[];
+    reserves: IReserve[];
+    lockedSeconds: number;
+    lockEnd: string;
+    mintOpensAt?: string;
+    objkts: Objkt[];
+    actions: Action[];
+    objktsCount?: number;
+    createdAt: string;
+    marketStats?: GenerativeTokenMarketStats;
+    marketStatsHistory?: GenerativeTokenMarketStatsHistory[];
+    features?: GenerativeTokenFeature[];
+    moderationReason?: string | null;
+    entireCollection?: Objkt[];
+    articleMentions?: ArticleGenerativeTokenMention[];
+    captureMedia?: MediaImage$1;
+    redeemables: Redeemable[];
+    underAuctionMintTickets: MintTicket[];
+    mintTickets: MintTicket[];
+    mintTicketSettings: MintTicketSettings | null;
+    inputBytesSize: number;
+    gentkContractAddress: string;
+    collectionOffers: CollectionOffer[];
+    isFrame: boolean;
+    maxMintsPerFid?: number;
+}
+interface GenerativeTokenWithCollection extends GenerativeToken {
+    entireCollection: Objkt[];
+}
+interface GenerativeTokenFilters {
+    id_in?: number[];
+    flag_eq?: GenTokFlag;
+    flag_in?: GenTokFlag[];
+    flag_neq?: GenTokFlag;
+    price_gte?: number;
+    price_lte?: number;
+    mintProgress_eq?: "COMPLETED" | "ONGOING" | "ALMOST";
+    authorVerified_eq?: boolean;
+    searchQuery_eq?: string;
+    supply_lte?: number;
+    supply_gte?: number;
+    pricingMethod_eq?: GenTokPricing;
+    locked_eq?: boolean;
+    mintOpened_eq?: boolean;
+    fxparams_eq?: boolean;
+    redeemable_eq?: boolean;
+}
+interface GenerativeTokenFeatureValue {
+    value: string | boolean | number;
+    occur: number;
+}
+interface GenerativeTokenFeature {
+    name: string;
+    values: GenerativeTokenFeatureValue[];
+}
+
+type Vec2 = {
+    x: number;
+    y: number;
+};
+
+interface GenerativeTokenInformations {
+    metadata: GenerativeTokenMetadata;
+    editions: number;
+    enabled: boolean;
+    price?: number;
+    royaties?: number;
+}
+declare enum CaptureTriggerMode {
+    DELAY = "DELAY",
+    FN_TRIGGER = "FN_TRIGGER"
+}
+declare const CaptureTriggerModeList: CaptureTriggerMode[];
+declare enum CaptureMode {
+    CANVAS = "CANVAS",
+    CUSTOM = "CUSTOM",
+    VIEWPORT = "VIEWPORT"
+}
+declare const CaptureModeList: CaptureMode[];
+interface CaptureSettings {
+    mode?: CaptureMode;
+    triggerMode?: CaptureTriggerMode;
+    canvasSelector?: string;
+    delay?: number;
+    resolution?: Vec2;
+    gpu?: boolean;
+    gif?: boolean;
+    frameCount?: number;
+    captureInterval?: number;
+    playbackFps?: number;
+    gpuVersion?: keyof GPURenderingConfig;
+}
+interface MintGenerativeParams {
+    definition: any;
+    inputBytesSize: number;
+}
+interface MintGenerativeData<N = string> {
+    onChain?: boolean;
+    collaboration?: Collaboration | null;
+    projectZipKey?: string;
+    cidUrlParams?: string;
+    authHash1?: string;
+    previewHash?: string;
+    previewIteration?: string;
+    previewMinter?: string;
+    previewInputBytes?: string | null;
+    cidPreview?: string;
+    cidThumbnail?: string;
+    authHash2?: string;
+    distribution?: GenTokDistributionForm<N>;
+    captureSettings?: CaptureSettings;
+    settings?: GenTokenSettings;
+    params?: MintGenerativeParams;
+    informations?: GenTokenInformationsForm;
+    minted?: boolean;
+    snippetVersion?: string | null;
+}
+/**
+ * This type describes the constraints that can be applied to the minting of a generative token
+ * The different types in order are:
+ * hash: the hash of the project
+ * minter: the minter of the project
+ * iteration: the iteration of the project
+ * inputBytes: the serialized input bytes of the project
+ */
+type ConstraintVariant = [string, string, string, string];
+interface GenTokConstrains {
+    hashConstraints?: string[] | null;
+    minterConstraints?: string[] | null;
+    iterationConstraints?: string[] | null;
+    paramsConstraints?: string[] | null;
+}
+interface ExplorationSettings extends GenTokConstrains {
+    enabled: boolean;
+}
+interface GenTokenSettings {
+    exploration?: {
+        preMint?: ExplorationSettings;
+        postMint?: ExplorationSettings;
+    };
+}
+type FrameMintingFormValues = {
+    enabled: boolean;
+    mintsPerFid: number;
+};
+interface GenTokPricingForm<N> {
+    pricingMethod?: GenTokPricing;
+    pricingFixed: Partial<IPricingFixed<N>>;
+    pricingDutchAuction: Partial<IPricingDutchAuction<N>>;
+    lockForReserves?: boolean;
+    royalties?: N;
+    splitsPrimary: ISplit[];
+    splitsSecondary: ISplit[];
+}
+declare enum GenTokEditions {
+    FIXED = "FIXED",
+    OPENED = "OPENED"
+}
+type GenTokOpenEditionsForm = {
+    closesAt?: Date | null;
+};
+type GenTokFixedEditionsForm<N> = {
+    amount: N;
+};
+type GenTokEditionsForm<N> = {
+    type: GenTokEditions;
+    fixed: GenTokFixedEditionsForm<N>;
+    opened: GenTokOpenEditionsForm;
+};
+interface GenTokDistributionForm<N> {
+    editions: GenTokEditionsForm<N>;
+    enabled: boolean;
+    reserves: IReserve<N>[];
+    gracingPeriod?: N;
+    frameMinting?: FrameMintingFormValues;
+}
+interface GenTokenInformationsForm {
+    name: string;
+    description: string;
+    mintingInstructions: string;
+    childrenDescription: string;
+    tags: string;
+    labels: GenTokLabel[];
+}
+
+interface TokenMetadata {
+    "": string;
+    name: string;
+    symbol: string;
+    decimals: number;
+}
+interface HistoryMetadata {
+    [key: string]: any;
+}
+interface TokenFormat {
+    uri: string;
+    mimeType: string;
+}
+type RawTokenFeatures = Record<string, any>;
+type TokenFeatureValueType = string | number | boolean;
+interface TokenMetadataFeature {
+    name: string;
+    value: TokenFeatureValueType;
+}
+interface TokenFeature {
+    name: string;
+    value: TokenFeatureValueType;
+    rarity?: number;
+}
+declare enum ProcessRawTokenFeatureErrorType {
+    UNKNOWN = "UNKNOWN",
+    INVALID_PROPERTY_TYPE = "INVALID_PROPERTY_TYPE",
+    INVALID_FEATURES_SIGNATURE = "INVALID_FEATURES_SIGNATURE"
+}
+declare const ProcessRawTokenFeatureErrorTypes: ProcessRawTokenFeatureErrorType[];
+type ProcessRawTokenFeatureError = {
+    type: ProcessRawTokenFeatureErrorType;
+    extra?: string;
+};
+type GenerativeTokenMetadataVersion = "0.1" | "0.2" | "0.3" | "0.4" | "0.5";
+type BaseGenerativeTokenMetadata = {
+    name: string;
+    description: string;
+    childrenDescription: string;
+    mintingInstructions: string;
+    tags: string[];
+    artifactUri: string;
+    displayUri: string;
+    thumbnailUri: string;
+    generativeUri: string;
+    authenticityHash: string;
+    capture: CaptureSettings;
+    settings?: GenTokenSettings | null;
+    symbol: string;
+    version?: GenerativeTokenMetadataVersion;
+};
+type GenerativeTokenMetadataV1 = BaseGenerativeTokenMetadata;
+type GenerativeTokenMetadataV2 = GenerativeTokenMetadataV1 & {
+    previewHash?: string;
+    previewIteration?: string;
+    previewMinter?: string;
+    previewInputBytes?: string;
+    mintingInstructions: string;
+};
+type GenerativeTokenMetadataV3 = GenerativeTokenMetadataV2 & {
+    params: {
+        definition: any;
+        inputBytesSize: number;
+    };
+    snippetVersion: string;
+};
+type GenerativeTokenMetadataV4 = GenerativeTokenMetadataV3 & {
+    primarySplits: ISplit[];
+};
+type GenerativeTokenMetadataV5 = GenerativeTokenMetadataV4 & {
+    chain: string;
+};
+type GenerativeTokenMetadata = GenerativeTokenMetadataV1 | (GenerativeTokenMetadataV2 & {
+    version: "0.2";
+}) | (GenerativeTokenMetadataV3 & {
+    version: "0.3";
+}) | (GenerativeTokenMetadataV4 & {
+    version: "0.4";
+}) | (GenerativeTokenMetadataV5 & {
+    version: "0.5";
+});
+type ObjktMetadata = {
+    features?: TokenMetadataFeature[] | null;
+} & GenerativeTokenMetadata;
+interface Eth721ContractMetadata {
+    name: string;
+    description: string;
+    image: string;
+    external_link: string;
+    collaborators?: string[];
+    ipfsBackupUri?: string;
+}
+interface Eth721ContractMetadata {
+    name: string;
+    description: string;
+    image: string;
+    external_link: string;
+    collaborators?: string[];
+    ipfsBackupUri?: string;
+}
+interface Eth721TokenMetadata {
+    name: string;
+    description: string;
+    image: string;
+    external_url: string;
+    animation_url?: string;
+    collaborators?: string[];
+    ipfsBackupUri?: string;
+}
+interface Eth721TokenMetadata {
+    name: string;
+    description: string;
+    image: string;
+    external_url: string;
+    animation_url?: string;
+    collaborators?: string[];
+    ipfsBackupUri?: string;
+}
+interface ArticleMetadata {
+    decimals: number;
+    symbol: "ARTKL";
+    name: string;
+    description: string;
+    minter?: string;
+    creators?: string[];
+    contributors?: string[];
+    type: "article";
+    tags: string[];
+    language: string;
+    artifactUri: string;
+    displayUri: string;
+    thumbnailUri: string;
+    thumbnailCaption?: string;
+    platforms?: string[];
+}
+interface MarketplaceMetadataEvm {
+    external: boolean;
+    source?: string;
+    hasRoyalties: boolean;
+}
+
+declare enum TokenActionType {
+    NONE = "NONE",
+    UPDATE_STATE = "UPDATE_STATE",
+    UPDATE_PRICING = "UPDATE_PRICING",
+    BURN_SUPPLY = "BURN_SUPPLY",
+    CODEX_UPDATED = "CODEX_UPDATED",
+    MINTED = "MINTED",
+    MINTED_FROM = "MINTED_FROM",
+    TICKET_MINTED = "TICKET_MINTED",
+    TICKET_CLAIMED = "TICKET_CLAIMED",
+    TICKET_PRICE_UPDATED = "TICKET_PRICE_UPDATED",
+    GENTK_SIGNED = "GENTK_SIGNED",
+    GENTK_REVEALED = "GENTK_REVEALED",
+    GENTK_REDEEMED = "GENTK_REDEEMED",
+    COMPLETED = "COMPLETED",
+    TRANSFERED = "TRANSFERED",
+    LISTING_V1 = "LISTING_V1",
+    LISTING_V1_CANCELLED = "LISTING_V1_CANCELLED",
+    LISTING_V1_ACCEPTED = "LISTING_V1_ACCEPTED",
+    LISTING_ETH_V1 = "LISTING_ETH_V1",
+    LISTING_BASE_V1 = "LISTING_BASE_V1",
+    LISTING_ETH_V1_CANCELLED = "LISTING_ETH_V1_CANCELLED",
+    LISTING_BASE_V1_CANCELLED = "LISTING_BASE_V1_CANCELLED",
+    LISTING_ETH_V1_ACCEPTED = "LISTING_ETH_V1_ACCEPTED",
+    LISTING_BASE_V1_ACCEPTED = "LISTING_BASE_V1_ACCEPTED",
+    LISTING_V2 = "LISTING_V2",
+    LISTING_V2_CANCELLED = "LISTING_V2_CANCELLED",
+    LISTING_V2_ACCEPTED = "LISTING_V2_ACCEPTED",
+    LISTING_V3 = "LISTING_V3",
+    LISTING_V3_CANCELLED = "LISTING_V3_CANCELLED",
+    LISTING_V3_ACCEPTED = "LISTING_V3_ACCEPTED",
+    OFFER = "OFFER",
+    OFFER_CANCELLED = "OFFER_CANCELLED",
+    OFFER_ACCEPTED = "OFFER_ACCEPTED",
+    OFFER_ETH = "OFFER_ETH",
+    OFFER_BASE = "OFFER_BASE",
+    OFFER_CANCELLED_ETH = "OFFER_CANCELLED_ETH",
+    OFFER_CANCELLED_BASE = "OFFER_CANCELLED_BASE",
+    OFFER_ACCEPTED_ETH = "OFFER_ACCEPTED_ETH",
+    OFFER_ACCEPTED_BASE = "OFFER_ACCEPTED_BASE",
+    COLLECTION_OFFER_ETH = "COLLECTION_OFFER_ETH",
+    COLLECTION_OFFER_BASE = "COLLECTION_OFFER_BASE",
+    COLLECTION_OFFER_CANCELLED_ETH = "COLLECTION_OFFER_CANCELLED_ETH",
+    COLLECTION_OFFER_CANCELLED_BASE = "COLLECTION_OFFER_CANCELLED_BASE",
+    COLLECTION_OFFER_ACCEPTED_ETH = "COLLECTION_OFFER_ACCEPTED_ETH",
+    COLLECTION_OFFER_ACCEPTED_BASE = "COLLECTION_OFFER_ACCEPTED_BASE",
+    COLLECTION_OFFER = "COLLECTION_OFFER",
+    COLLECTION_OFFER_CANCELLED = "COLLECTION_OFFER_CANCELLED",
+    COLLECTION_OFFER_ACCEPTED = "COLLECTION_OFFER_ACCEPTED",
+    AUCTION = "AUCTION",
+    AUCTION_BID = "AUCTION_BID",
+    AUCTION_CANCELLED = "AUCTION_CANCELLED",
+    AUCTION_FULFILLED = "AUCTION_FULFILLED",
+    ARTICLE_MINTED = "ARTICLE_MINTED",
+    ARTICLE_METADATA_UPDATED = "ARTICLE_METADATA_UPDATED",
+    ARTICLE_METADATA_LOCKED = "ARTICLE_METADATA_LOCKED",
+    ARTICLE_EDITIONS_TRANSFERED = "ARTICLE_EDITIONS_TRANSFERED"
+}
+interface Action {
+    id: string;
+    opHash: string;
+    type: TokenActionType;
+    numericValue: number;
+    issuer?: User;
+    target?: User;
+    token?: GenerativeToken;
+    objkt?: Objkt;
+    redeemable?: Redeemable;
+    ticketId?: number;
+    article?: NFTArticleInfos;
+    metadata: HistoryMetadata;
+    createdAt: string;
+}
+
+interface UserItems {
+    generativeTokens?: GenerativeToken[];
+    objkts?: Objkt[];
+    listings?: Listing[];
+    actions?: Action[];
+}
+declare enum UserFlag {
+    NONE = "NONE",
+    REVIEW = "REVIEW",
+    SUSPICIOUS = "SUSPICIOUS",
+    MALICIOUS = "MALICIOUS",
+    VERIFIED = "VERIFIED"
+}
+declare enum UserAuthorization {
+    TOKEN_MODERATION = "TOKEN_MODERATION",
+    ARTICLE_MODERATION = "ARTICLE_MODERATION",
+    USER_MODERATION = "USER_MODERATION",
+    GOVERNANCE_MODERATION = "GOVERNANCE_MODERATION"
+}
+declare enum UserType {
+    REGULAR = "REGULAR",
+    COLLAB_CONTRACT_V1 = "COLLAB_CONTRACT_V1"
+}
+declare const UserFlagValues: Record<UserFlag, number>;
+interface User {
+    id: string;
+    name?: string;
+    type: UserType;
+    authorizations: UserAuthorization[];
+    flag: UserFlag;
+    metadata?: Record<string, any>;
+    metadataUri?: string;
+    description?: string;
+    avatarUri?: string;
+    avatarMedia?: MediaImage$1;
+    generativeTokens?: GenerativeToken[];
+    sales: Action[];
+    actionsAsIssuer: Action[];
+    actionsAsTarget: Action[];
+    listings: Listing[];
+    objkts: Objkt[];
+    offers: Listing[];
+    allOffersReceived: AnyOffer[];
+    allOffersSent: Offer[];
+    createdAt: Date;
+    updatedAt: Date;
+    actions?: Action[];
+    platformOwned?: boolean;
+    donationAddress?: boolean;
+    descriptionLight?: string;
+    preventLink?: boolean;
+    collaborationContracts: Collaboration[];
+    moderationReason?: string | null;
+    articles: NFTArticle[];
+    mintTickets: MintTicket[];
+}
+interface ConnectedUser extends Partial<User> {
+    id: string;
+    authorizations: UserAuthorization[];
+}
+interface Collaboration extends User {
+    collaborators: User[];
+}
+interface UserAlias {
+    id: string;
+    alias: Partial<User>;
+}
+interface IUserCollectionFilters {
+    issuer_in?: number[];
+    assigned_eq?: boolean;
+    offer_ne?: string;
+    createdAt_lt?: string;
+    createdAt_gt?: string;
+    assignedAt_gt?: string;
+    assignedAt_lt?: string;
+    mintProgress_eq?: "COMPLETED" | "ONGOING" | "ALMOST";
+    authorVerified_eq?: boolean;
+    author_in?: string[];
+    searchQuery_eq?: string;
+    activeListing_exist?: "LISTED" | "NOT LISTED";
+}
+interface UserFilters {
+    flag_in?: UserFlag[];
+    searchQuery_eq?: string;
+}
+
+declare class PendingSigningRequestError extends Error {
+    name: "PendingSigningRequestError";
+    message: string;
+}
+declare enum WalletConnectionErrorReason {
+    INCORRECT_CHAIN = "INCORRECT_CHAIN"
+}
+declare class WalletConnectionError extends Error {
+    readonly reason: WalletConnectionErrorReason;
+    name: "WalletConnectionError";
+    constructor(reason: WalletConnectionErrorReason);
+}
+declare class UserRejectedError extends Error {
+    name: "UserRejectedError";
+    message: string;
+}
+declare class InsufficientFundsError extends Error {
+    name: "InsufficientFundsError";
+    message: string;
+}
+declare class TransactionRevertedError extends Error {
+    readonly paramErrorName: string;
+    name: "TransactionRevertedError";
+    errorName: string;
+    constructor(paramErrorName: string);
+}
+declare class TransactionReceiptError extends Error {
+    name: "TransactionReceiptError";
+    constructor();
+}
+declare class TransactionUnknownError extends Error {
+    readonly paramErrorName?: string | undefined;
+    name: "TransactionUnknownError";
+    errorName?: string;
+    constructor(paramErrorName?: string | undefined);
+}
+declare class NetworkError extends Error {
+    name: "NetworkError";
+    message: string;
+}
+declare class BadRequestError extends Error {
+    name: "BadRequestError";
+    message: string;
+}
+type SignMessageOptions = {
+    /**
+     * An string-identifier to define the type of the operation. It is used to
+     * classify signatures in the cache.
+     */
+    type: string;
+    /**
+     * - wallet-only: the cache is bypassed and signature must come from wallet
+     * - cache-first: the cache is checked first, and if a valid signature is
+     *   found it's returned, otherwise the wallet is
+     */
+    policy: "wallet-only" | "cache-first";
+};
+type MessageSigned = {
+    signedAt: Date;
+    message: string;
+    signature: string;
+};
+declare abstract class WalletManager {
+    address: string;
+    private cache;
+    constructor(address: string);
+    /**
+     * Must be implemented by wallets for custom signing of messages.
+     * @param message The message to sign.
+     * @returns The signature of the message.
+     */
+    abstract signMessageWithWallet(message: string): PromiseResult<string, PendingSigningRequestError | UserRejectedError | WalletConnectionError>;
+    /**
+     * Sign a message using the wallet associated with the manager. Some sign
+     * options can be provided, mainly for implementing cache-fetching for
+     * avoiding redundant signatures from the wallet.
+     *
+     * Signatures are stored in cache so that users don't have to repeatedly
+     * sign messages for similar operations, as long as messages are considered to
+     * be valid for their usage. This function returns a message signed of a
+     * given type if it's still valid in cache. A signature is considered valid
+     * if it was made less than 4 minutes ago.
+     *
+     * @remark For now, the cache policy enforces a 5 min cache time for the
+     * signatures, after which they are considered invalid. There isn't any way to
+     * change this with the current implementation, although it could be added.
+     *
+     * @param options Sign options, which can be used to determine whether the
+     * signature should be fetched from cache or not.
+     */
+    signMessage(message: string, options?: SignMessageOptions): PromiseResult<MessageSigned, PendingSigningRequestError | UserRejectedError | WalletConnectionError>;
+    abstract sendTransaction<TParams>(operation: TContractOperation<this, TParams, any>, params: TParams, chain: BlockchainType): PromiseResult<unknown, WalletConnectionError | PendingSigningRequestError | UserRejectedError | InsufficientFundsError | TransactionRevertedError | TransactionUnknownError>;
+    abstract waitForTransaction(params: {
+        hash: string;
+    }): PromiseResult<unknown, UserRejectedError | TransactionRevertedError | TransactionReceiptError | TransactionUnknownError>;
+}
+type TWalletManager = new (address: string) => WalletManager;
+
+/**
+ * A Blockchain Environment is based on the classification of the "blockchain
+ * engine".
+ * TODO: should decide between BlockchainEnv & BlockchainNetwork and harmonize
+ */
+declare enum BlockchainEnv {
+    EVM = "EVM",
+    TEZOS = "TEZOS"
+}
+/**
+ * An array of all the `BlockchainEnv` enum values.
+ */
+declare const BlockchainEnvs: BlockchainEnv[];
+declare enum BlockchainNetwork {
+    TEZOS = "TEZOS",
+    ETHEREUM = "ETHEREUM"
+}
+declare const BlockchainNetworks: BlockchainNetwork[];
+declare enum TransactionType {
+    OFFCHAIN = "OFFCHAIN",
+    ONCHAIN = "ONCHAIN"
+}
+declare enum BlockchainType {
+    ETHEREUM = "ETHEREUM",
+    TEZOS = "TEZOS",
+    BASE = "BASE"
+}
+type Blockchain = keyof typeof BlockchainType;
+declare const BlockchainTypes: ("TEZOS" | "ETHEREUM" | "BASE")[];
+type ChainNetworkToChainTypemap = {
+    [T in BlockchainNetwork]: {
+        [BlockchainNetwork.ETHEREUM]: BlockchainType.ETHEREUM;
+        [BlockchainNetwork.TEZOS]: BlockchainType.TEZOS;
+    }[T];
+};
+/**
+ * Given a BlockchainNetwork, returns an associated BlockchainType of preference
+ */
+declare function networkToChain<N extends BlockchainNetwork>(network: N): ChainNetworkToChainTypemap[N];
+type ChainToChainEnvTypemap = {
+    [T in BlockchainType]: {
+        [BlockchainType.BASE]: BlockchainEnv.EVM;
+        [BlockchainType.ETHEREUM]: BlockchainEnv.EVM;
+        [BlockchainType.TEZOS]: BlockchainEnv.TEZOS;
+    }[T];
+};
+declare const chainToChainEnvMap: {
+    [K in BlockchainType]: ChainToChainEnvTypemap[K];
+};
+type ChainEnvToChainTypemap = {
+    [E in BlockchainEnv]: {
+        [BlockchainEnv.EVM]: BlockchainType.ETHEREUM;
+        [BlockchainEnv.TEZOS]: BlockchainType.TEZOS;
+    }[E];
+};
+declare const chainEnvToChainMap: {
+    [E in BlockchainEnv]: ChainEnvToChainTypemap[E];
+};
+/**
+ * A Contract Operation defines a set of operations to run at different
+ * moments of the lifecycle of an operation. When an operation needs to be sent,
+ * its corresponding class is instantiated with the operation parameters and
+ * the following steps are performed:
+ * - prepare: preparation steps before calling a contract
+ * - call: the actual contract call
+ * - success: a message is emitted
+ * In case of failure, the whole lifecycle restarts, if the RPC is at cause it
+ * is swapped with another one. This logic is handled by an external runner.
+ */
+declare abstract class ContractOperation<TWalletManager extends WalletManager, TParams, TData> {
+    manager: TWalletManager;
+    params: TParams;
+    chain: BlockchainType;
+    constructor(manager: TWalletManager, params: TParams, chain: BlockchainType);
+    /**
+     * Runs the required preparations (such as fetching the contracts to get
+     * the entrypoints signature), or any other sync/async operation considered
+     * not to be a part of the actual contract call.
+     * Can store required values in the members of the instance.
+     */
+    abstract prepare(): Promise<void>;
+    /**
+     * The actual calls to the contracts, which results in some Transaction
+     * Wallet Operation and can be observed to track the success/failure of
+     * the transaction emitted
+     */
+    abstract call(): Promise<TData>;
+    /**
+     * Each Contract Operation should implement a success message based on the
+     * operation parameters, and so to provide meaningful feedback to users on
+     * different parts of the front.
+     */
+    abstract success(): string;
+}
+type TContractOperation<TWalletManager extends WalletManager, TParams, TData> = new (manager: TWalletManager, params: TParams, chain: BlockchainType) => ContractOperation<TWalletManager, TParams, TData>;
+
+/**
+ * Model Wallet
+ *
+ */
+type Wallet = {
+    address: string;
+    network: BlockchainNetwork;
+    accountId: string;
+};
+/**
+ * Model Profile
+ *
+ */
+type Profile = {
+    accountId: string;
+    description: string | null;
+    website: string | null;
+    twitter: string | null;
+    instagram: string | null;
+    picture: string | null;
+};
+interface ConnectedAccount extends Partial<Account> {
+    id: string;
+    username: string;
+    activeWallet: string;
+    authorizations: UserAuthorization[];
+}
+interface Account {
+    id: string;
+    username: string;
+    authorizations: UserAuthorization[];
+    profile?: Profile;
+    wallets?: Wallet[];
+    flag: UserFlag;
+    metadata?: Record<string, any>;
+    metadataUri?: string;
+    description?: string;
+    avatarUri?: string;
+    avatarMedia?: MediaImage;
+    generativeTokens?: GenerativeToken[];
+    sales: Action[];
+    actionsAsIssuer: Action[];
+    actionsAsTarget: Action[];
+    listings: Listing[];
+    objkts: Objkt[];
+    offers: Listing[];
+    offersReceived: AnyOffer[];
+    offersSent: AnyOffer[];
+    createdAt: Date;
+    updatedAt: Date;
+    actions?: Action[];
+    platformOwned?: boolean;
+    donationAddress?: boolean;
+    descriptionLight?: string;
+    preventLink?: boolean;
+    moderationReason?: string | null;
+    articles: NFTArticle[];
+    mintTickets: MintTicket[];
+}
+declare const accountTypeGuard: (entity: any) => entity is Account;
+
+interface Ledger {
+    amount: number;
+    owner: User;
+}
+
+declare enum EventStatus {
+    PUBLISHED = "PUBLISHED",
+    DRAFT = "DRAFT",
+    HIDDEN = "HIDDEN"
+}
+declare enum EventAvailability {
+    ONLINE = "ONLINE",
+    IRL = "IRL"
+}
+interface LiveMintingEvent {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    startsAt: string;
+    endsAt: string;
+    projectIds: number[];
+    onboarding?: EventOnboarding;
+    location?: string;
+    imageUrl?: string;
+    availabilities: EventAvailability[];
+    status: EventStatus;
+    freeLiveMinting: boolean;
+}
+type LiveMintingEventWithArtists = LiveMintingEvent & {
+    artists: User[];
+};
+interface LiveMintingPassGroup {
+    address: string;
+    label: string;
+    maxMints: number;
+    maxMintsPerProject: number;
+    event: LiveMintingEvent;
+}
+interface LiveMintingPass {
+    token: string;
+    group: LiveMintingPassGroup;
+    expiresAt: string;
+}
+interface OnboardingComponent {
+    id: number;
+    description: string;
+    content: string;
+}
+interface EventOnboardingOnComponent {
+    component: OnboardingComponent;
+    index: number;
+}
+interface EventOnboarding {
+    id: number;
+    enabled: boolean;
+    description: string;
+    components: EventOnboardingOnComponent[];
+}
+
+declare enum EWalletOperatorState {
+    EMPTY = "EMPTY",
+    INITIALIZING = "INITIALIZING",
+    AVAILABLE = "AVAILABLE",
+    PREPARING = "PREPARING",
+    WAITING_CONFIRMATION = "WAITING_CONFIRMATION"
+}
+
+interface ModerationReason {
+    id: string;
+    reason: string;
+}
+
+interface JwtAccessTokenPayload extends JwtPayload {
+    id: string;
+}
+
+type UpdateIssuerForm<N = string> = Omit<Omit<Omit<GenTokDistributionForm<N>, "pricing">, "reserves">, "gracingPeriod">;
+
+type SandboxFiles = Record<string, {
+    blob?: Blob;
+    url: string;
+}>;
+declare enum SandboxFileError {
+    UNKNOWN = "UNKNOWN",
+    WRONG_FORMAT = "WRONG_FORMAT",
+    NO_INDEX_HTML = "NO_INDEX_HTML",
+    NO_SNIPPET = "NO_SNIPPET",
+    FAILED_UNZIP = "FAILED_UNZIP"
+}
+
+declare enum ProfileUploadError {
+    UNKNOWN = "UNKNOWN",
+    WRONG_FORMAT = "WRONG_FORMAT",
+    IPFS_UPLOAD_FAILED = "IPFS_UPLOAD_FAILED"
+}
+interface ProfileUploadResponse {
+    metadataUri: string;
+}
+declare enum AvatarUploadError {
+    UNKNOWN = "UNKNOWN",
+    NO_FILE = "NO_FILE",
+    WRONG_FORMAT = "WRONG_FORMAT",
+    IPFS_UPLOAD_FAILED = "IPFS_UPLOAD_FAILED"
+}
+interface AvatarUploadResponse {
+    avatarUri: string;
+}
+interface TempGenUploadProjectResponse {
+    zipKey: string;
+    projectCid: string;
+    authenticationHash: string;
+}
+interface MintGenUploadProjectResponse {
+    cidParams: string;
+    authenticationHash: string;
+}
+interface MintGenUploadProjectResponse {
+    zipKey: string;
+    projectCid: string;
+    authenticationHash: string;
+}
+declare enum StaticGenError {
+    UNKNOWN = "UNKNOWN",
+    MISSING_PARAMETERS = "MISSING_PARAMETERS",
+    AUTH_FAILED = "AUTH_FAILED",
+    INVALID_HASH = "INVALID_HASH",
+    IPFS_UPLOAD_FAILED = "IPFS_UPLOAD_FAILED",
+    NO_SNIPPET = "NO_SNIPPET"
+}
+interface StaticGenResponse {
+    cidStatic: string;
+    authenticationHash: string;
+}
+declare enum PreviewError {
+    UNKNOWN = "UNKNOWN",
+    MISSING_PARAMETERS = "MISSING_PARAMETERS",
+    AUTH_FAILED = "AUTH_FAILED",
+    INCORRECT_PARAMETERS = "INCORRECT_PARAMETERS",
+    PREVIEW_ERROR = "PREVIEW_ERROR",
+    IPFS_ERROR = "IPFS_ERROR"
+}
+interface PreviewErrorResponse {
+    error: PreviewError;
+}
+interface PreviewResponse {
+    cidPreview: string;
+    cidThumbnail: string;
+    authenticationHash: string;
+    mode: CaptureMode;
+    triggerMode: CaptureTriggerMode;
+    resX: number;
+    resY: number;
+    delay: number;
+    canvasSelector: string;
+    gpu: boolean;
+}
+declare enum TestPreviewError {
+    UNKNOWN = "UNKNOWN",
+    TIMEOUT = "TIMEOUT",
+    EXTRACT_SERVICE_UNREACHABLE = "EXTRACT_SERVICE_UNREACHABLE",
+    INVALID_INPUT_PARAMETERS = "INVALID_INPUT_PARAMETERS",
+    JOB_QUEUE_FAILED = "JOB_QUEUE_FAILED",
+    JOB_EXECUTION_FAILED = "JOB_EXECUTION_FAILED"
+}
+interface TestPreviewResponse {
+    capture: string;
+    features?: string;
+}
+interface TestPreviewErrorResponse {
+    error: TestPreviewError;
+}
+declare enum MetadataError {
+    UNKNOWN = "UNKNOWN",
+    IPFS_ERROR = "IPFS_ERROR",
+    UPLOAD_ERROR = "UPLOAD_ERROR",
+    METADATA_EXISTS = "METADATA_EXISTS"
+}
+interface MetadataResponse {
+    cid: string;
+}
+interface MetadataEthResponse {
+    key: string;
+}
+declare enum MintError {
+    UNKNOWN = "UNKNOWN",
+    BAD_REQUEST = "BAD_REQUEST",
+    TOKEN_NOT_EXISTS = "TOKEN_NOT_EXISTS",
+    TOKEN_UNAVAILABLE = "TOKEN_UNAVAILABLE",
+    FAIL_GET_METADATA = "FAIL_GET_METADATA",
+    WRONG_TOKEN_METADATA = "WRONG_TOKEN_METADATA",
+    FAIL_AUTHENTICATE = "FAIL_AUTHENTICATE",
+    FAIL_GET_TOKEN = "FAIL_GET_TOKEN",
+    INVALID_TOKEN = "INVALID_TOKEN",
+    FAIL_ADD_IPFS = "FAIL_ADD_IPFS",
+    FAIL_PREVIEW = "FAIL_PREVIEW"
+}
+declare const MintErrors: MintError[];
+declare enum MintProgressMessage {
+    GET_TOKEN_DATA = "GET_TOKEN_DATA",
+    GET_TOKEN_METADATA = "GET_TOKEN_METADATA",
+    GET_GENERATIVE_TOKEN_CONTENTS = "GET_GENERATIVE_TOKEN_CONTENTS",
+    ADD_CONTENT_IPFS = "ADD_CONTENT_IPFS",
+    GENERATE_PREVIEW = "GENERATE_PREVIEW",
+    AUTHENTICATE_TOKEN = "AUTHENTICATE_TOKEN"
+}
+interface MintResponse {
+    cidMetadata: string;
+    cidGenerative: string;
+    cidPreview: string;
+}
+declare enum SigningState {
+    NONE = "NONE",
+    NOT_FOUND = "NOT_FOUND",
+    QUEUED = "QUEUED",
+    GENERATING_METADATA = "GENERATING_METADATA",
+    METADATA_GENERATED = "METADATA_GENERATED",
+    CALLING_CONTRACT = "CALLING_CONTRACT",
+    SIGNED = "SIGNED"
+}
+interface SigningProgress {
+    state: SigningState;
+    extra?: any;
+}
+interface SigningData {
+    cidGenerative?: string;
+    cidPreview?: string;
+    features?: TokenFeature[];
+}
+
+interface IReserveConsumption {
+    method: EReserveMethod;
+    data: any;
+}
+
+interface InputProps<T = string> {
+    value: T;
+    onChange: (value: T) => void;
+}
+
+type IndexerStatusSeverity = "low" | "medium" | "high";
+interface IndexerStatus {
+    level: number;
+    id: number;
+    originatedAt: string;
+    lastIndexedAt: string;
+}
+interface NetworkStatus {
+    level: number;
+    lastSyncedAt: string;
+}
+
+interface FileSandboxResponse {
+    filename: string;
+    contents: string[];
+    url: string;
+}
+
+interface Cycle {
+    start: Date;
+    opening: number;
+    closing: number;
+}
+interface CyclesState {
+    opened: boolean;
+    nextOpening: Date;
+    nextClosing: Date;
+}
+
+type TColor = "success" | "warning" | "error";
+
+export { type Account, type Action, type AnyOffer, ArticleFlag, type ArticleGenerativeTokenMention, type ArticleMetadata, AvatarUploadError, type AvatarUploadResponse, BadRequestError, type Blockchain, BlockchainEnv, BlockchainEnvs, BlockchainNetwork, BlockchainNetworks, BlockchainType, BlockchainTypes, CaptureMode, CaptureModeList, type CaptureSettings, CaptureTriggerMode, CaptureTriggerModeList, type ChainEnvToChainTypemap, type ChainNetworkToChainTypemap, type ChainToChainEnvTypemap, type Collaboration, type CollectionOffer, type ConnectedAccount, type ConnectedUser, type ConstraintVariant, ContractOperation, type Cycle, type CyclesState, EObjktFeatureType, EReserveMethod, EWalletOperatorState, type Eth721ContractMetadata, type Eth721TokenMetadata, EventAvailability, type EventMedia, type EventOnboarding, type EventOnboardingOnComponent, EventStatus, type ExplorationSettings, type FileSandboxResponse, type FrameMintingFormValues, type GenTokConstrains, type GenTokDistributionForm, GenTokEditions, type GenTokEditionsForm, type GenTokFixedEditionsForm, GenTokFlag, GenTokLabel, type GenTokLabelDefinition, GenTokLabelGroup, GenTokLabel_Params, GenTokLabel_Redeemable, type GenTokOpenEditionsForm, GenTokPricing, type GenTokPricingForm, type GenTokenInformationsForm, type GenTokenSettings, type GenerativeToken, type GenerativeTokenFeature, type GenerativeTokenFeatureValue, type GenerativeTokenFilters, type GenerativeTokenInformations, type GenerativeTokenMarketStats, type GenerativeTokenMarketStatsHistory, type GenerativeTokenMetadata, type GenerativeTokenMetadataV1, type GenerativeTokenMetadataV2, type GenerativeTokenMetadataV3, type GenerativeTokenMetadataV4, type GenerativeTokenMetadataV5, GenerativeTokenVersion, type GenerativeTokenWithCollection, type HistoryMetadata, type IAddress, type IObjktFeatureFilter, type IPricingDutchAuction, type IPricingFixed, type IReserve, type IReserveConsumption, type IReserveMintInput, type ISplit, type IUserCollectionFilters, type IWhitelistData, type IndexerStatus, type IndexerStatusSeverity, type InputProps, InsufficientFundsError, type JwtAccessTokenPayload, type Ledger, type Listing, type ListingFilters, type LiveMintingEvent, type LiveMintingEventWithArtists, type LiveMintingPass, type LiveMintingPassGroup, type MarketplaceMetadataEvm, type MediaImage$1 as MediaImage, type MessageSigned, MetadataError, type MetadataEthResponse, type MetadataResponse, MintError, MintErrors, type MintGenUploadProjectResponse, type MintGenerativeData, type MintGenerativeParams, MintProgressMessage, type MintResponse, type MintTicket, type MintTicketMetadata, type MintTicketSettings, type ModerationReason, type NFTArticle, type NFTArticleFilters, type NFTArticleGenerativeToken, type NFTArticleInfos, type NFTArticleRevision, type NTFArticleLedger, NetworkError, type NetworkStatus, type Objkt, type ObjktFilters, type ObjktMetadata, type Offer, type OnboardingComponent, PendingSigningRequestError, PreviewError, type PreviewErrorResponse, type PreviewResponse, type ProcessRawTokenFeatureError, ProcessRawTokenFeatureErrorType, ProcessRawTokenFeatureErrorTypes, ProfileUploadError, type ProfileUploadResponse, type RawTokenFeatures, type Redeemable, type RedeemableDetails, type RedeemableOption, type RedeemableOptionValue, type RedeemablePublicDefinition, type RedeemableUserAction, type RedeemableUserActionInputType, type RedeemableUserActionOptions, RedeemableUserActionType, type Redemption, type Report, type ReserveMintPass, type ReserveWhiteList, SandboxFileError, type SandboxFiles, type SignMessageOptions, type SigningData, type SigningProgress, SigningState, type Split, StaticGenError, type StaticGenResponse, type TColor, type TContractOperation, type TWalletManager, type TempGenUploadProjectResponse, TestPreviewError, type TestPreviewErrorResponse, type TestPreviewResponse, TokenActionType, type TokenFeature, type TokenFeatureValueType, type TokenFormat, type TokenMetadata, type TokenMetadataFeature, TransactionReceiptError, TransactionRevertedError, TransactionType, TransactionUnknownError, type UpdateIssuerForm, type User, type UserAlias, UserAuthorization, type UserFilters, UserFlag, UserFlagValues, type UserItems, UserRejectedError, UserType, type Vec2, WalletConnectionError, WalletConnectionErrorReason, WalletManager, accountTypeGuard, chainEnvToChainMap, chainToChainEnvMap, isReserveMintPass, isReserveWhiteList, networkToChain, objktFeatureType, offerTypeGuard };