// Code generated by the multiversx-sc proxy generator. DO NOT EDIT.

////////////////////////////////////////////////////
////////////////// AUTO-GENERATED //////////////////
////////////////////////////////////////////////////

#![allow(dead_code)]
#![allow(clippy::all)]

use multiversx_sc::proxy_imports::*;

pub struct NftMinterProxy;

impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for NftMinterProxy
where
    Env: TxEnv,
    From: TxFrom<Env>,
    To: TxTo<Env>,
    Gas: TxGas<Env>,
{
    type TxProxyMethods = NftMinterProxyMethods<Env, From, To, Gas>;

    fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
        NftMinterProxyMethods { wrapped_tx: tx }
    }
}

pub struct NftMinterProxyMethods<Env, From, To, Gas>
where
    Env: TxEnv,
    From: TxFrom<Env>,
    To: TxTo<Env>,
    Gas: TxGas<Env>,
{
    wrapped_tx: Tx<Env, From, To, (), Gas, (), ()>,
}

#[rustfmt::skip]
impl<Env, From, Gas> NftMinterProxyMethods<Env, From, (), Gas>
where
    Env: TxEnv,
    Env::Api: VMApi,
    From: TxFrom<Env>,
    Gas: TxGas<Env>,
{
    pub fn init<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
        Arg1: ProxyArg<ManagedAddress<Env::Api>>,
        Arg2: ProxyArg<usize>,
        Arg3: ProxyArg<OptionalValue<ManagedAddress<Env::Api>>>,
    >(
        self,
        royalties_claim_address: Arg0,
        mint_payments_claim_address: Arg1,
        max_nfts_per_transaction: Arg2,
        opt_admin: Arg3,
    ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_deploy()
            .argument(&royalties_claim_address)
            .argument(&mint_payments_claim_address)
            .argument(&max_nfts_per_transaction)
            .argument(&opt_admin)
            .original_result()
    }
}

#[rustfmt::skip]
impl<Env, From, To, Gas> NftMinterProxyMethods<Env, From, To, Gas>
where
    Env: TxEnv,
    Env::Api: VMApi,
    From: TxFrom<Env>,
    To: TxTo<Env>,
    Gas: TxGas<Env>,
{
    pub fn upgrade<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
        Arg1: ProxyArg<ManagedAddress<Env::Api>>,
        Arg2: ProxyArg<usize>,
        Arg3: ProxyArg<OptionalValue<ManagedAddress<Env::Api>>>,
    >(
        self,
        royalties_claim_address: Arg0,
        mint_payments_claim_address: Arg1,
        max_nfts_per_transaction: Arg2,
        opt_admin: Arg3,
    ) -> TxTypedUpgrade<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_upgrade()
            .argument(&royalties_claim_address)
            .argument(&mint_payments_claim_address)
            .argument(&max_nfts_per_transaction)
            .argument(&opt_admin)
            .original_result()
    }
}

#[rustfmt::skip]
impl<Env, From, To, Gas> NftMinterProxyMethods<Env, From, To, Gas>
where
    Env: TxEnv,
    Env::Api: VMApi,
    From: TxFrom<Env>,
    To: TxTo<Env>,
    Gas: TxGas<Env>,
{
    pub fn set_max_nfts_per_transaction<
        Arg0: ProxyArg<usize>,
    >(
        self,
        max: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("setMaxNftsPerTransaction")
            .argument(&max)
            .original_result()
    }

    pub fn max_nfts_per_transaction(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, usize> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getMaxNftsPerTransaction")
            .original_result()
    }

    pub fn registered_collection_hashes(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, ManagedByteArray<Env::Api, 46usize>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getRegisterdCollectionHashes")
            .original_result()
    }

    pub fn registered_brands(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getRegisteredBrands")
            .original_result()
    }

    pub fn nft_token<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, TokenIdentifier<Env::Api>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getNftTokenIdForBrand")
            .argument(&brand_id)
            .original_result()
    }

    pub fn price_for_tier<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
        tier: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MintPrice<Env::Api>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getPriceForTier")
            .argument(&brand_id)
            .argument(&tier)
            .original_result()
    }

    pub fn tags_for_brand<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedVec<Env::Api, ManagedBuffer<Env::Api>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getTagsForBrand")
            .argument(&brand_id)
            .original_result()
    }

    pub fn mint_whitelist<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, ManagedAddress<Env::Api>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getMintWhitelist")
            .argument(&brand_id)
            .original_result()
    }

    pub fn add_user_to_admin_list<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
    >(
        self,
        address: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("addUserToAdminList")
            .argument(&address)
            .original_result()
    }

    pub fn remove_user_from_admin_list<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
    >(
        self,
        address: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("removeUserFromAdminList")
            .argument(&address)
            .original_result()
    }

    pub fn issue_token_for_brand<
        Arg0: ProxyArg<ManagedByteArray<Env::Api, 46usize>>,
        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg2: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg3: ProxyArg<BigUint<Env::Api>>,
        Arg4: ProxyArg<u64>,
        Arg5: ProxyArg<u64>,
        Arg6: ProxyArg<EgldOrEsdtTokenIdentifier<Env::Api>>,
        Arg7: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg8: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg9: ProxyArg<u64>,
        Arg10: ProxyArg<ManagedVec<Env::Api, ManagedBuffer<Env::Api>>>,
        Arg11: ProxyArg<MultiValueEncoded<Env::Api, MultiValue3<ManagedBuffer<Env::Api>, usize, BigUint<Env::Api>>>>,
    >(
        self,
        collection_hash: Arg0,
        brand_id: Arg1,
        media_type: Arg2,
        royalties: Arg3,
        mint_start_timestamp: Arg4,
        mint_end_timestamp: Arg5,
        mint_price_token_id: Arg6,
        token_display_name: Arg7,
        token_ticker: Arg8,
        whitelist_expire_timestamp: Arg9,
        tags: Arg10,
        tier_name_nr_nfts_pairs: Arg11,
    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
        self.wrapped_tx
            .raw_call("issueTokenForBrand")
            .argument(&collection_hash)
            .argument(&brand_id)
            .argument(&media_type)
            .argument(&royalties)
            .argument(&mint_start_timestamp)
            .argument(&mint_end_timestamp)
            .argument(&mint_price_token_id)
            .argument(&token_display_name)
            .argument(&token_ticker)
            .argument(&whitelist_expire_timestamp)
            .argument(&tags)
            .argument(&tier_name_nr_nfts_pairs)
            .original_result()
    }

    pub fn add_to_whitelist<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<MultiValueEncoded<Env::Api, ManagedAddress<Env::Api>>>,
    >(
        self,
        brand_id: Arg0,
        users: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("addToWhitelist")
            .argument(&brand_id)
            .argument(&users)
            .original_result()
    }

    pub fn remove_from_whitelist<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<MultiValueEncoded<Env::Api, ManagedAddress<Env::Api>>>,
    >(
        self,
        brand_id: Arg0,
        users: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("removeFromWhitelist")
            .argument(&brand_id)
            .argument(&users)
            .original_result()
    }

    pub fn set_mint_whitelist_expire_timestamp<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<u64>,
    >(
        self,
        brand_id: Arg0,
        timestamp: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("setMintWhitelistExpireTimestamp")
            .argument(&brand_id)
            .argument(&timestamp)
            .original_result()
    }

    pub fn buy_random_nft<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg2: ProxyArg<OptionalValue<usize>>,
    >(
        self,
        brand_id: Arg0,
        tier: Arg1,
        opt_nfts_to_buy: Arg2,
    ) -> TxTypedCall<Env, From, To, (), Gas, ManagedVec<Env::Api, EsdtTokenPayment<Env::Api>>> {
        self.wrapped_tx
            .raw_call("buyRandomNft")
            .argument(&brand_id)
            .argument(&tier)
            .argument(&opt_nfts_to_buy)
            .original_result()
    }

    pub fn giveaway_nfts<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg2: ProxyArg<MultiValueEncoded<Env::Api, MultiValue2<ManagedAddress<Env::Api>, usize>>>,
    >(
        self,
        brand_id: Arg0,
        tier: Arg1,
        dest_amount_pairs: Arg2,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("giveawayNfts")
            .argument(&brand_id)
            .argument(&tier)
            .argument(&dest_amount_pairs)
            .original_result()
    }

    pub fn nft_tiers_for_brand<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getNftTiersForBrand")
            .argument(&brand_id)
            .original_result()
    }

    pub fn nft_id_offset_for_tier<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
        tier: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, usize> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("nftIdOffsetForTier")
            .argument(&brand_id)
            .argument(&tier)
            .original_result()
    }

    pub fn set_royalties_claim_address<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
    >(
        self,
        new_address: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("setRoyaltiesClaimAddress")
            .argument(&new_address)
            .original_result()
    }

    pub fn change_royalties_for_brand<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
        Arg1: ProxyArg<BigUint<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
        new_royalties: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("changeRoyaltiesForBrand")
            .argument(&brand_id)
            .argument(&new_royalties)
            .original_result()
    }

    pub fn set_mint_payments_claim_address<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
    >(
        self,
        new_address: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("setMintPaymentsClaimAddress")
            .argument(&new_address)
            .original_result()
    }

    pub fn claim_royalties(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue2<BigUint<Env::Api>, ManagedVec<Env::Api, EsdtTokenPayment<Env::Api>>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("claimRoyalties")
            .original_result()
    }

    pub fn claim_mint_payments(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue2<BigUint<Env::Api>, ManagedVec<Env::Api, EsdtTokenPayment<Env::Api>>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("claimMintPayments")
            .original_result()
    }

    pub fn royalties_claim_address(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getRoyaltiesClaimAddress")
            .original_result()
    }

    pub fn mint_payments_claim_address(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getMintPaymentsClaimAddress")
            .original_result()
    }

    pub fn accumulated_royalties(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, MultiValue2<EgldOrEsdtTokenIdentifier<Env::Api>, BigUint<Env::Api>>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getAccumulatedRoyalties")
            .original_result()
    }

    pub fn accumulated_mint_payments(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, MultiValue2<EgldOrEsdtTokenIdentifier<Env::Api>, BigUint<Env::Api>>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getAccumulatedMintPayments")
            .original_result()
    }

    pub fn claim_royalties_from_marketplace<
        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
        Arg1: ProxyArg<MultiValueEncoded<Env::Api, EgldOrEsdtTokenIdentifier<Env::Api>>>,
    >(
        self,
        marketplace_address: Arg0,
        tokens: Arg1,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("claimRoyaltiesFromMarketplace")
            .argument(&marketplace_address)
            .argument(&tokens)
            .original_result()
    }

    pub fn get_brand_info_view<
        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
    >(
        self,
        brand_id: Arg0,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, BrandInfoViewResultType<Env::Api>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getBrandInfo")
            .argument(&brand_id)
            .original_result()
    }

    pub fn get_all_brands_info(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, BrandInfoViewResultType<Env::Api>>> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("getAllBrandsInfo")
            .original_result()
    }

    pub fn pause_endpoint(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("pause")
            .original_result()
    }

    pub fn unpause_endpoint(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("unpause")
            .original_result()
    }

    pub fn paused_status(
        self,
    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, bool> {
        self.wrapped_tx
            .payment(NotPayable)
            .raw_call("isPaused")
            .original_result()
    }
}

#[type_abi]
#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, PartialEq, Debug)]
pub struct MintPrice<Api>
where
    Api: ManagedTypeApi,
{
    pub token_id: EgldOrEsdtTokenIdentifier<Api>,
    pub amount: BigUint<Api>,
}

#[type_abi]
#[derive(TopEncode, TopDecode)]
pub struct BrandInfoViewResultType<Api>
where
    Api: ManagedTypeApi,
{
    pub brand_id: ManagedBuffer<Api>,
    pub nft_token_id: TokenIdentifier<Api>,
    pub brand_info: BrandInfo<Api>,
    pub tier_info_entries: ArrayVec<TierInfoEntry<Api>, 5usize>,
}

#[type_abi]
#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, PartialEq, Debug)]
pub struct BrandInfo<Api>
where
    Api: ManagedTypeApi,
{
    pub collection_hash: ManagedByteArray<Api, 46usize>,
    pub token_display_name: ManagedBuffer<Api>,
    pub media_type: ManagedBuffer<Api>,
    pub royalties: BigUint<Api>,
    pub mint_period: TimePeriod,
    pub whitelist_expire_timestamp: u64,
}

#[type_abi]
#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, PartialEq, Debug)]
pub struct TimePeriod {
    pub start: u64,
    pub end: u64,
}

#[type_abi]
#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, Debug, PartialEq)]
pub struct TierInfoEntry<Api>
where
    Api: ManagedTypeApi,
{
    pub tier: ManagedBuffer<Api>,
    pub total_nfts: usize,
    pub available_nfts: usize,
    pub mint_price: MintPrice<Api>,
}
