import * as c from '@ton/core';
import { ContractProvider, Sender, SendMode } from '@ton/core';
type RemainingBitsAndRefs = c.Slice;
export type any_address = c.Address | c.ExternalAddress | 'none';
export type CellRef<T> = {
    ref: T;
};
type coins = bigint;
type int32 = bigint;
type uint16 = bigint;
type uint64 = bigint;
type uint128 = bigint;
type uint256 = bigint;
/**
 > struct MemeMetadata {
 >     uri: string
 > }
 */
export interface MemeMetadata {
    readonly $: 'MemeMetadata';
    uri: string;
}
export declare const MemeMetadata: {
    create(args: {
        uri: string;
    }): MemeMetadata;
    fromSlice(s: c.Slice): MemeMetadata;
    store(self: MemeMetadata, b: c.Builder): void;
    toCell(self: MemeMetadata): c.Cell;
};
/**
 > struct PartnerConfig {
 >     partnerId: uint256
 >     partnerFeeBps: uint16
 > }
 */
export interface PartnerConfig {
    readonly $: 'PartnerConfig';
    partnerId: uint256;
    partnerFeeBps: uint16;
}
export declare const PartnerConfig: {
    create(args: {
        partnerId: uint256;
        partnerFeeBps: uint16;
    }): PartnerConfig;
    fromSlice(s: c.Slice): PartnerConfig;
    store(self: PartnerConfig, b: c.Builder): void;
    toCell(self: PartnerConfig): c.Cell;
};
/**
 > struct ReferrerConfig {
 >     referrerId: uint256
 >     referrerFeeBps: uint16
 > }
 */
export interface ReferrerConfig {
    readonly $: 'ReferrerConfig';
    referrerId: uint256;
    referrerFeeBps: uint16;
}
export declare const ReferrerConfig: {
    create(args: {
        referrerId: uint256;
        referrerFeeBps: uint16;
    }): ReferrerConfig;
    fromSlice(s: c.Slice): ReferrerConfig;
    store(self: ReferrerConfig, b: c.Builder): void;
    toCell(self: ReferrerConfig): c.Cell;
};
/**
 > struct MemeConfig {
 >     creatorAddress: address
 >     controllerAddress: address
 >     metadata: MemeMetadata
 >     raisingFunds: coins
 >     liquidityTokens: coins
 >     seed: uint128
 > }
 */
export interface MemeConfig {
    readonly $: 'MemeConfig';
    creatorAddress: c.Address;
    controllerAddress: c.Address;
    metadata: MemeMetadata;
    raisingFunds: coins;
    liquidityTokens: coins;
    seed: uint128;
}
export declare const MemeConfig: {
    create(args: {
        creatorAddress: c.Address;
        controllerAddress: c.Address;
        metadata: MemeMetadata;
        raisingFunds: coins;
        liquidityTokens: coins;
        seed?: uint128;
    }): MemeConfig;
    fromSlice(s: c.Slice): MemeConfig;
    store(self: MemeConfig, b: c.Builder): void;
    toCell(self: MemeConfig): c.Cell;
};
/**
 > struct BondingCurve {
 >     graduated: bool
 >     alpha: coins
 >     beta: coins
 >     onSellSupply: coins
 >     raisedFunds: coins
 >     currentSupply: coins
 > }
 */
export interface BondingCurve {
    readonly $: 'BondingCurve';
    graduated: boolean;
    alpha: coins;
    beta: coins;
    onSellSupply: coins;
    raisedFunds: coins;
    currentSupply: coins;
}
export declare const BondingCurve: {
    create(args: {
        graduated?: boolean;
        alpha: coins;
        beta: coins;
        onSellSupply: coins;
        raisedFunds?: coins;
        currentSupply?: coins;
    }): BondingCurve;
    fromSlice(s: c.Slice): BondingCurve;
    store(self: BondingCurve, b: c.Builder): void;
    toCell(self: BondingCurve): c.Cell;
};
/**
 > struct MemeStorage {
 >     initialized: bool
 >     migrated: bool
 >     config: Cell<MemeConfig>
 >     baseFeeBps: uint16
 >     curve: BondingCurve
 >     totalSupply: coins
 >     creatorFee: coins
 >     protocolFee: coins
 > }
 */
export interface MemeStorage {
    readonly $: 'MemeStorage';
    initialized: boolean;
    migrated: boolean;
    config: CellRef<MemeConfig>;
    baseFeeBps: uint16;
    curve: BondingCurve;
    totalSupply: coins;
    creatorFee: coins;
    protocolFee: coins;
}
export declare const MemeStorage: {
    create(args: {
        initialized?: boolean;
        migrated?: boolean;
        config: CellRef<MemeConfig>;
        baseFeeBps: uint16;
        curve: BondingCurve;
        totalSupply?: coins;
        creatorFee?: coins;
        protocolFee?: coins;
    }): MemeStorage;
    fromSlice(s: c.Slice): MemeStorage;
    store(self: MemeStorage, b: c.Builder): void;
    toCell(self: MemeStorage): c.Cell;
};
/**
 > struct (0x796f5a0c) InitMemeMessage {
 >     queryId: uint64
 >     initialBuy: coins
 >     partnerConfig: PartnerConfig?
 >     referrerConfig: ReferrerConfig?
 > }
 */
export interface InitMemeMessage {
    readonly $: 'InitMemeMessage';
    queryId: uint64;
    initialBuy: coins;
    partnerConfig: PartnerConfig | null;
    referrerConfig: ReferrerConfig | null;
}
export declare const InitMemeMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        initialBuy: coins;
        partnerConfig: PartnerConfig | null;
        referrerConfig: ReferrerConfig | null;
    }): InitMemeMessage;
    fromSlice(s: c.Slice): InitMemeMessage;
    store(self: InitMemeMessage, b: c.Builder): void;
    toCell(self: InitMemeMessage): c.Cell;
};
/**
 > struct (0x94826557) BuyMessage {
 >     queryId: uint64
 >     amount: coins
 >     minimalAmountOut: coins
 >     excessesTo: address
 >     partnerConfig: Cell<PartnerConfig>?
 >     referrerConfig: Cell<ReferrerConfig>?
 > }
 */
export interface BuyMessage {
    readonly $: 'BuyMessage';
    queryId: uint64;
    amount: coins;
    minimalAmountOut: coins;
    excessesTo: c.Address;
    partnerConfig: CellRef<PartnerConfig> | null;
    referrerConfig: CellRef<ReferrerConfig> | null;
}
export declare const BuyMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        excessesTo: c.Address;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }): BuyMessage;
    fromSlice(s: c.Slice): BuyMessage;
    store(self: BuyMessage, b: c.Builder): void;
    toCell(self: BuyMessage): c.Cell;
};
/**
 > struct (0x646ad424) SellMessage {
 >     queryId: uint64
 >     amount: coins
 >     minimalAmountOut: coins
 >     from: address
 >     excessesTo: address?
 >     partnerConfig: Cell<PartnerConfig>?
 >     referrerConfig: Cell<ReferrerConfig>?
 > }
 */
export interface SellMessage {
    readonly $: 'SellMessage';
    queryId: uint64;
    amount: coins;
    minimalAmountOut: coins;
    from: c.Address;
    excessesTo: c.Address | null;
    partnerConfig: CellRef<PartnerConfig> | null;
    referrerConfig: CellRef<ReferrerConfig> | null;
}
export declare const SellMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        from: c.Address;
        excessesTo: c.Address | null;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }): SellMessage;
    fromSlice(s: c.Slice): SellMessage;
    store(self: SellMessage, b: c.Builder): void;
    toCell(self: SellMessage): c.Cell;
};
/**
 > struct (0x2c76b973) RequestWalletAddressMessage {
 >     queryId: uint64
 >     ownerAddress: any_address
 >     includeOwnerAddress: bool
 > }
 */
export interface RequestWalletAddressMessage {
    readonly $: 'RequestWalletAddressMessage';
    queryId: uint64;
    ownerAddress: any_address;
    includeOwnerAddress: boolean;
}
export declare const RequestWalletAddressMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        ownerAddress: any_address;
        includeOwnerAddress?: boolean;
    }): RequestWalletAddressMessage;
    fromSlice(s: c.Slice): RequestWalletAddressMessage;
    store(self: RequestWalletAddressMessage, b: c.Builder): void;
    toCell(self: RequestWalletAddressMessage): c.Cell;
};
/**
 > struct (0xd1735400) ReplyWalletAddressMessage {
 >     queryId: uint64
 >     walletAddress: address?
 >     ownerAddress: Cell<any_address>?
 > }
 */
export interface ReplyWalletAddressMessage {
    readonly $: 'ReplyWalletAddressMessage';
    queryId: uint64;
    walletAddress: c.Address | null;
    ownerAddress: CellRef<any_address> | null;
}
export declare const ReplyWalletAddressMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        walletAddress: c.Address | null;
        ownerAddress: CellRef<any_address> | null;
    }): ReplyWalletAddressMessage;
    fromSlice(s: c.Slice): ReplyWalletAddressMessage;
    store(self: ReplyWalletAddressMessage, b: c.Builder): void;
    toCell(self: ReplyWalletAddressMessage): c.Cell;
};
/**
 > struct (0xad7269a8) ClaimCreatorFeeMessage {
 >     queryId: uint64
 >     to: address?
 >     excessesTo: address?
 > }
 */
export interface ClaimCreatorFeeMessage {
    readonly $: 'ClaimCreatorFeeMessage';
    queryId: uint64;
    to: c.Address | null;
    excessesTo: c.Address | null;
}
export declare const ClaimCreatorFeeMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        to: c.Address | null;
        excessesTo: c.Address | null;
    }): ClaimCreatorFeeMessage;
    fromSlice(s: c.Slice): ClaimCreatorFeeMessage;
    store(self: ClaimCreatorFeeMessage, b: c.Builder): void;
    toCell(self: ClaimCreatorFeeMessage): c.Cell;
};
/**
 > struct (0xf14b54f3) ResetGasMessage {
 >     queryId: uint64
 >     excessesTo: address?
 > }
 */
export interface ResetGasMessage {
    readonly $: 'ResetGasMessage';
    queryId: uint64;
    excessesTo: c.Address | null;
}
export declare const ResetGasMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        excessesTo: c.Address | null;
    }): ResetGasMessage;
    fromSlice(s: c.Slice): ResetGasMessage;
    store(self: ResetGasMessage, b: c.Builder): void;
    toCell(self: ResetGasMessage): c.Cell;
};
/**
 > struct (0x66c8ad72) PayoutMessage {
 >     queryId: uint64
 > }
 */
export interface PayoutMessage {
    readonly $: 'PayoutMessage';
    queryId: uint64;
}
export declare const PayoutMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
    }): PayoutMessage;
    fromSlice(s: c.Slice): PayoutMessage;
    store(self: PayoutMessage, b: c.Builder): void;
    toCell(self: PayoutMessage): c.Cell;
};
/**
 > struct TradeFees {
 >     creatorFee: coins
 >     protocolFee: coins
 >     partnerFee: coins
 >     referrerFee: coins
 > }
 */
export interface TradeFees {
    readonly $: 'TradeFees';
    creatorFee: coins;
    protocolFee: coins;
    partnerFee: coins;
    referrerFee: coins;
}
export declare const TradeFees: {
    create(args: {
        creatorFee: coins;
        protocolFee: coins;
        partnerFee: coins;
        referrerFee: coins;
    }): TradeFees;
    fromSlice(s: c.Slice): TradeFees;
    store(self: TradeFees, b: c.Builder): void;
    toCell(self: TradeFees): c.Cell;
};
/**
 > struct (0xa0aa6bc2) BuyEvent {
 >     traderAddress: address
 >     amountIn: coins
 >     amountOut: coins
 >     fees: TradeFees
 >     currentSupply: coins
 >     raisedFunds: coins
 >     isGraduated: bool
 > }
 */
export interface BuyEvent {
    readonly $: 'BuyEvent';
    traderAddress: c.Address;
    amountIn: coins;
    amountOut: coins;
    fees: TradeFees;
    currentSupply: coins;
    raisedFunds: coins;
    isGraduated: boolean;
}
export declare const BuyEvent: {
    PREFIX: number;
    create(args: {
        traderAddress: c.Address;
        amountIn: coins;
        amountOut: coins;
        fees: TradeFees;
        currentSupply: coins;
        raisedFunds: coins;
        isGraduated: boolean;
    }): BuyEvent;
    fromSlice(s: c.Slice): BuyEvent;
    store(self: BuyEvent, b: c.Builder): void;
    toCell(self: BuyEvent): c.Cell;
};
/**
 > struct (0x3ab0fccc) SellEvent {
 >     traderAddress: address
 >     amountIn: coins
 >     amountOut: coins
 >     fees: TradeFees
 >     currentSupply: coins
 >     raisedFunds: coins
 > }
 */
export interface SellEvent {
    readonly $: 'SellEvent';
    traderAddress: c.Address;
    amountIn: coins;
    amountOut: coins;
    fees: TradeFees;
    currentSupply: coins;
    raisedFunds: coins;
}
export declare const SellEvent: {
    PREFIX: number;
    create(args: {
        traderAddress: c.Address;
        amountIn: coins;
        amountOut: coins;
        fees: TradeFees;
        currentSupply: coins;
        raisedFunds: coins;
    }): SellEvent;
    fromSlice(s: c.Slice): SellEvent;
    store(self: SellEvent, b: c.Builder): void;
    toCell(self: SellEvent): c.Cell;
};
/**
 > struct GetJettonDataReply {
 >     totalSupply: coins
 >     isMintable: bool
 >     adminAddress: any_address
 >     metadata: cell
 >     memeWalletCode: cell
 > }
 */
export interface GetJettonDataReply {
    readonly $: 'GetJettonDataReply';
    totalSupply: coins;
    isMintable: boolean;
    adminAddress: any_address;
    metadata: c.Cell;
    memeWalletCode: c.Cell;
}
export declare const GetJettonDataReply: {
    create(args: {
        totalSupply: coins;
        isMintable?: boolean;
        adminAddress: any_address;
        metadata: c.Cell;
        memeWalletCode: c.Cell;
    }): GetJettonDataReply;
    fromSlice(s: c.Slice): GetJettonDataReply;
    store(self: GetJettonDataReply, b: c.Builder): void;
    toCell(self: GetJettonDataReply): c.Cell;
};
/**
 > struct GetMemeDataReply {
 >     initialized: bool
 >     migrated: bool
 >     controllerAddress: address
 >     creatorAddress: address
 >     creatorFee: coins
 >     seed: uint128
 >     isGraduated: bool
 >     alpha: coins
 >     beta: coins
 >     onSellSupply: coins
 >     tradeFeeBps: uint16
 >     raisedFunds: coins
 >     currentSupply: coins
 > }
 */
export interface GetMemeDataReply {
    readonly $: 'GetMemeDataReply';
    initialized: boolean;
    migrated: boolean;
    controllerAddress: c.Address;
    creatorAddress: c.Address;
    creatorFee: coins;
    seed: uint128;
    isGraduated: boolean;
    alpha: coins;
    beta: coins;
    onSellSupply: coins;
    tradeFeeBps: uint16;
    raisedFunds: coins;
    currentSupply: coins;
}
export declare const GetMemeDataReply: {
    create(args: {
        initialized: boolean;
        migrated: boolean;
        controllerAddress: c.Address;
        creatorAddress: c.Address;
        creatorFee: coins;
        seed: uint128;
        isGraduated: boolean;
        alpha: coins;
        beta: coins;
        onSellSupply: coins;
        tradeFeeBps: uint16;
        raisedFunds: coins;
        currentSupply: coins;
    }): GetMemeDataReply;
    fromSlice(s: c.Slice): GetMemeDataReply;
    store(self: GetMemeDataReply, b: c.Builder): void;
    toCell(self: GetMemeDataReply): c.Cell;
};
/**
 > struct (0x178d4519) ReceiveTokensMessage {
 >     queryId: uint64
 >     amount: coins
 >     from: address?
 >     excessesTo: address?
 >     forwardAmount: coins
 >     forwardPayload: RemainingBitsAndRefs | cell
 > }
 */
export interface ReceiveTokensMessage {
    readonly $: 'ReceiveTokensMessage';
    queryId: uint64;
    amount: coins;
    from: c.Address | null;
    excessesTo: c.Address | null;
    forwardAmount: coins;
    forwardPayload: {
        $: 'RemainingBitsAndRefs';
        value: RemainingBitsAndRefs;
    } | {
        $: 'cell';
        value: c.Cell;
    };
}
export declare const ReceiveTokensMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        amount: coins;
        from: c.Address | null;
        excessesTo: c.Address | null;
        forwardAmount?: coins;
        forwardPayload: {
            $: "RemainingBitsAndRefs";
            value: RemainingBitsAndRefs;
        } | {
            $: "cell";
            value: c.Cell;
        };
    }): ReceiveTokensMessage;
    fromSlice(s: c.Slice): ReceiveTokensMessage;
    store(self: ReceiveTokensMessage, b: c.Builder): void;
    toCell(self: ReceiveTokensMessage): c.Cell;
};
/**
 > struct (0xd53276db) ExcessesMessage {
 >     queryId: uint64
 > }
 */
export interface ExcessesMessage {
    readonly $: 'ExcessesMessage';
    queryId: uint64;
}
export declare const ExcessesMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
    }): ExcessesMessage;
    fromSlice(s: c.Slice): ExcessesMessage;
    store(self: ExcessesMessage, b: c.Builder): void;
    toCell(self: ExcessesMessage): c.Cell;
};
/**
 > struct (0x7bdd97de) BurnNotificationMessage {
 >     queryId: uint64
 >     amount: coins
 >     from: address
 >     excessesTo: address?
 > }
 */
export interface BurnNotificationMessage {
    readonly $: 'BurnNotificationMessage';
    queryId: uint64;
    amount: coins;
    from: c.Address;
    excessesTo: c.Address | null;
}
export declare const BurnNotificationMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        amount: coins;
        from: c.Address;
        excessesTo: c.Address | null;
    }): BurnNotificationMessage;
    fromSlice(s: c.Slice): BurnNotificationMessage;
    store(self: BurnNotificationMessage, b: c.Builder): void;
    toCell(self: BurnNotificationMessage): c.Cell;
};
/**
 > struct (0x773faf30) AffiliateFeeMessage {
 >     queryId: uint64
 > }
 */
export interface AffiliateFeeMessage {
    readonly $: 'AffiliateFeeMessage';
    queryId: uint64;
}
export declare const AffiliateFeeMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
    }): AffiliateFeeMessage;
    fromSlice(s: c.Slice): AffiliateFeeMessage;
    store(self: AffiliateFeeMessage, b: c.Builder): void;
    toCell(self: AffiliateFeeMessage): c.Cell;
};
/**
 > struct PayoutOptions {
 >     destination: address?
 >     extraGas: coins
 >     payload: cell?
 >     wrapPayload: bool
 > }
 */
export interface PayoutOptions {
    readonly $: 'PayoutOptions';
    destination: c.Address | null;
    extraGas: coins;
    payload: c.Cell | null;
    wrapPayload: boolean;
}
export declare const PayoutOptions: {
    create(args: {
        destination?: c.Address | null;
        extraGas?: coins;
        payload?: c.Cell | null;
        wrapPayload?: boolean;
    }): PayoutOptions;
    fromSlice(s: c.Slice): PayoutOptions;
    store(self: PayoutOptions, b: c.Builder): void;
    toCell(self: PayoutOptions): c.Cell;
};
/**
 > struct ExtendedPayoutConfig {
 >     fulfill: PayoutOptions
 >     reject: PayoutOptions
 >     excessesTo: address?
 > }
 */
export interface ExtendedPayoutConfig {
    readonly $: 'ExtendedPayoutConfig';
    fulfill: PayoutOptions;
    reject: PayoutOptions;
    excessesTo: c.Address | null;
}
export declare const ExtendedPayoutConfig: {
    create(args: {
        fulfill?: PayoutOptions;
        reject?: PayoutOptions;
        excessesTo: c.Address | null;
    }): ExtendedPayoutConfig;
    fromSlice(s: c.Slice): ExtendedPayoutConfig;
    store(self: ExtendedPayoutConfig, b: c.Builder): void;
    toCell(self: ExtendedPayoutConfig): c.Cell;
};
/**
 > struct (0xde8402ce) InitPoolMessage {
 >     queryId: uint64
 >     customPayload: cell?
 > }
 */
export interface InitPoolMessage {
    readonly $: 'InitPoolMessage';
    queryId: uint64;
    customPayload: c.Cell | null;
}
export declare const InitPoolMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        customPayload?: c.Cell | null;
    }): InitPoolMessage;
    fromSlice(s: c.Slice): InitPoolMessage;
    store(self: InitPoolMessage, b: c.Builder): void;
    toCell(self: InitPoolMessage): c.Cell;
};
/**
 > struct (0xce185bd7) InitPoolResultMessage {
 >     queryId: uint64
 >     exitCode: int32
 >     customPayload: cell?
 > }
 */
export interface InitPoolResultMessage {
    readonly $: 'InitPoolResultMessage';
    queryId: uint64;
    exitCode: int32;
    customPayload: c.Cell | null;
}
export declare const InitPoolResultMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        exitCode?: int32;
        customPayload?: c.Cell | null;
    }): InitPoolResultMessage;
    fromSlice(s: c.Slice): InitPoolResultMessage;
    store(self: InitPoolResultMessage, b: c.Builder): void;
    toCell(self: InitPoolResultMessage): c.Cell;
};
/**
 > struct (0xa5a7cbf8) PayNativeMessage {
 >     queryId: uint64
 >     amount: coins
 >     paymentPayload: cell
 >     payoutConfig: Cell<ExtendedPayoutConfig>
 > }
 */
export interface PayNativeMessage {
    readonly $: 'PayNativeMessage';
    queryId: uint64;
    amount: coins;
    paymentPayload: c.Cell;
    payoutConfig: CellRef<ExtendedPayoutConfig>;
}
export declare const PayNativeMessage: {
    PREFIX: number;
    create(args: {
        queryId: uint64;
        amount: coins;
        paymentPayload: c.Cell;
        payoutConfig: CellRef<ExtendedPayoutConfig>;
    }): PayNativeMessage;
    fromSlice(s: c.Slice): PayNativeMessage;
    store(self: PayNativeMessage, b: c.Builder): void;
    toCell(self: PayNativeMessage): c.Cell;
};
interface ExtraSendOptions {
    bounce?: boolean;
    sendMode?: SendMode;
    extraCurrencies?: c.ExtraCurrency;
}
interface DeployedAddrOptions {
    workchain?: number;
    toShard?: {
        fixedPrefixLength: number;
        closeTo: c.Address;
    };
    overrideContractCode?: c.Cell;
}
export declare class Meme implements c.Contract {
    static CodeCell: c.Cell;
    static Errors: {
        'ErrorCode.BondingCurveParametersMalformed': number;
        'ErrorCode.SlippageExceeded': number;
        'ErrorCode.MessageValueTooLow': number;
        'ErrorCode.AlreadyInitialized': number;
        'ErrorCode.SenderUnauthorized': number;
        'ErrorCode.NotInitialized': number;
        'ErrorCode.AlreadyGraduated': number;
        'ErrorCode.NotMigrated': number;
        'ErrorCode.UnknownOperation': number;
    };
    readonly address: c.Address;
    readonly init?: {
        code: c.Cell;
        data: c.Cell;
    };
    protected constructor(address: c.Address, init?: {
        code: c.Cell;
        data: c.Cell;
    });
    static fromAddress(address: c.Address): Meme;
    static fromStorage(emptyStorage: {
        initialized?: boolean;
        migrated?: boolean;
        config: CellRef<MemeConfig>;
        baseFeeBps: uint16;
        curve: BondingCurve;
        totalSupply?: coins;
        creatorFee?: coins;
        protocolFee?: coins;
    }, deployedOptions?: DeployedAddrOptions): Meme;
    static createCellOfInitMemeMessage(body: {
        queryId: uint64;
        initialBuy: coins;
        partnerConfig: PartnerConfig | null;
        referrerConfig: ReferrerConfig | null;
    }): c.Cell;
    static createCellOfBuyMessage(body: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        excessesTo: c.Address;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }): c.Cell;
    static createCellOfSellMessage(body: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        from: c.Address;
        excessesTo: c.Address | null;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }): c.Cell;
    static createCellOfBurnNotificationMessage(body: {
        queryId: uint64;
        amount: coins;
        from: c.Address;
        excessesTo: c.Address | null;
    }): c.Cell;
    static createCellOfRequestWalletAddressMessage(body: {
        queryId: uint64;
        ownerAddress: any_address;
        includeOwnerAddress?: boolean;
    }): c.Cell;
    static createCellOfClaimCreatorFeeMessage(body: {
        queryId: uint64;
        to: c.Address | null;
        excessesTo: c.Address | null;
    }): c.Cell;
    static createCellOfResetGasMessage(body: {
        queryId: uint64;
        excessesTo: c.Address | null;
    }): c.Cell;
    static createCellOfExcessesMessage(body: {
        queryId: uint64;
    }): c.Cell;
    static createCellOfInitPoolResultMessage(body: {
        queryId: uint64;
        exitCode?: int32;
        customPayload?: c.Cell | null;
    }): c.Cell;
    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
    sendInitMemeMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        initialBuy: coins;
        partnerConfig: PartnerConfig | null;
        referrerConfig: ReferrerConfig | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendBuyMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        excessesTo: c.Address;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendSellMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        amount: coins;
        minimalAmountOut: coins;
        from: c.Address;
        excessesTo: c.Address | null;
        partnerConfig: CellRef<PartnerConfig> | null;
        referrerConfig: CellRef<ReferrerConfig> | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendBurnNotificationMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        amount: coins;
        from: c.Address;
        excessesTo: c.Address | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendRequestWalletAddressMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        ownerAddress: any_address;
        includeOwnerAddress?: boolean;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendClaimCreatorFeeMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        to: c.Address | null;
        excessesTo: c.Address | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendResetGasMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        excessesTo: c.Address | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendExcessesMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    sendInitPoolResultMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
        queryId: uint64;
        exitCode?: int32;
        customPayload?: c.Cell | null;
    }, extraOptions?: ExtraSendOptions): Promise<void>;
    getWalletAddress(provider: ContractProvider, ownerAddress: c.Address): Promise<c.Address>;
    getJettonData(provider: ContractProvider): Promise<GetJettonDataReply>;
    getMemeData(provider: ContractProvider): Promise<GetMemeDataReply>;
}
export {};