/* tslint:disable */
/* eslint-disable */
export function ed25519_generateKeyPair(): Ed25519KeyPair;
export function decodeTransaction(transaction: Transaction, contract_abi: string, method: MethodName): DecodedTransaction | undefined;
export function getCodeSalt(code: string): string | undefined;
export function decodeEvent(message_body: string, contract_abi: string, event: MethodName): DecodedEvent | undefined;
export function mergeTvc(code: string, data: string): { hash: string, boc: string, };
export function extendSignature(signature: string): ExtendedSignature;
export function setCodeSalt(code: string, salt: string): { hash: string, boc: string, };
export function createExternalMessageWithoutSignature(clock: ClockWithOffset, dst: string, contract_abi: string, method: string, state_init: string | null | undefined, input: TokensObject, timeout: number): SignedMessage;
export function splitTvc(tvc: string): StateInit;
export function encodeInternalInput(contract_abi: string, method: string, input: TokensObject): string;
export function makeFullAccountBoc(account_stuff_boc?: string | null): string;
export function unpackFromCell(params: Array<AbiParam>, boc: string, allow_partial: boolean, abi_version?: string | null): TokensObject;
export function packIntoCell(params: Array<AbiParam>, tokens: TokensObject, abi_version?: string | null): { hash: string, boc: string, };
export function validateCell(data: string): boolean;
export function extractPublicKey(boc: string): string;
export function verifySignature(public_key: string, data: string, signature: string, signature_ctx: SignatureContext): boolean;
export function decodeTransactionEvents(transaction: Transaction, contract_abi: string): DecodedTransactionEvents;
export function executeLocal(config: string, account: string, message: string, utime: number, disable_signature_check: boolean, overwrite_balance?: string | null, global_id?: number | null): TransactionExecutorOutput;
export function unpackInitData(contract_abi: string, data: string): { publicKey?: string, data: TokensObject };
export function parseFullAccountBoc(account: string): FullContractState | undefined;
export function unpackContractFields(contract_abi: string, boc: string, allow_partial: boolean): TokensObject | undefined;
export function encodeInternalMessage(src: string | null | undefined, dst: string, bounce: boolean, state_init: string | null | undefined, body: string | null | undefined, amount: string, bounced?: boolean | null): string;
export function parseFullAccountStateInit(account: string): string | undefined;
export function createExternalMessage(clock: ClockWithOffset, dst: string, contract_abi: string, method: string, state_init: string | null | undefined, input: TokensObject, public_key: string, timeout: number): UnsignedMessage;
export function ed25519_sign(secret_key: string, data: string, signature_ctx: SignatureContext): string;
export function getDataHash(data: string): string;
export function codeToTvc(code: string): { hash: string, boc: string, };
export function checkAddress(address: string): boolean;
export function getExpectedAddress(tvc: string, contract_abi: string, workchain_id: number, public_key: string | null | undefined, init_data: TokensObject): ExpectedAddress;
export function extractContractData(boc: string): string | undefined;
export function repackAddress(address: string): string;
export function decodeOutput(message_body: string, contract_abi: string, method: MethodName): DecodedOutput | undefined;
export function runLocal(clock: ClockWithOffset, account_stuff_boc: string, contract_abi: string, method: string, input: TokensObject, libraries: LibrariesObject, responsible: boolean, signature_ctx: SignatureContext): ExecutionOutput;
export function computeStorageFee(config: string, account: string, utime: number, is_masterchain: boolean): StorageFeeInfo;
export function runLocalWithLibs(transport: Transport, account_stuff_boc: string, contract_abi: string, method: string, input: TokensObject, libraries: LibrariesObject, retry_count: number, responsible: boolean, signature_ctx: SignatureContext): Promise<Promise<ExecutionOutput>>;
export function runGetter(clock: ClockWithOffset, account_stuff_boc: string, contract_abi: string, method: string, input: TokensObject, libraries: LibrariesObject, signature_ctx: SignatureContext): ExecutionOutput;
export function createRawExternalMessage(dst: string, state_init: string | null | undefined, body: string | null | undefined, expire_at: number): SignedMessage;
export function unpackTransactionTree(boc: string): TransactionTree;
export function getBocHash(boc: string): string;
export function decodeInput(message_body: string, contract_abi: string, method: MethodName, internal: boolean): DecodedInput | undefined;

export type ExecutorParams = {
    disableSignatureCheck?: boolean,
    overrideBalance?: string | number,
};



export type LibrariesObject = { [K: string]: string };



export type EnumItem<T extends string, D> = { type: T, data: D };



export type NetworkCapabilities = {
    globalId: number,
    capabilities: string,
};

export type NetworkDescription = NetworkCapabilities & {
    signatureContext: SignatureContext,
};

export type BlockchainConfig = {
    globalId: number,
    boc: string,
}

export type TransactionId = {
    lt: string,
    hash: string,
};

export type GenTimings = {
    genLt: string,
    genUtime: number,
};

export type LastTransactionId = {
    isExact: boolean,
    lt: string,
    hash?: string,
};

export type ContractState = {
    balance: string,
    genTimings: GenTimings,
    lastTransactionId?: LastTransactionId,
    isDeployed: boolean,
    codeHash?: string,
};

export type AccountStatus = 'uninit' | 'frozen' | 'active' | 'nonexist';

export type Message = {
    hash: string,
    src?: string,
    dst?: string,
    value: string,
    bounce: boolean,
    bounced: boolean,
    body?: string,
    bodyHash?: string,
    boc: string,
};

export type PendingTransaction = {
    messageHash: string,
    src?: string,
    expireAt: number,
};

export type AccountsList = {
  accounts: string[];
  continuation: string | undefined;
};

export type TransactionsList = {
    transactions: Transaction[];
    continuation: TransactionId | undefined;
};

export type Transaction = {
    id: TransactionId,
    prevTransactionId?: TransactionId,
    createdAt: number,
    aborted: boolean,
    exitCode?: number,
    resultCode?: number,
    origStatus: AccountStatus,
    endStatus: AccountStatus,
    totalFees: string,
    inMessage: Message,
    outMessages: Message[],
    boc: string
};

export type TransactionsBatchType = 'old' | 'new';

export type TransactionsBatchInfo = {
    minLt: string,
    maxLt: string,
    batchType: TransactionsBatchType,
};

export type StateInit = {
    data: string | undefined;
    code: string | undefined;
};

export type ExpectedAddress = {
    stateInit: string;
    address: string;
    hash: string;
};

export type DecodedInput = {
    method: string,
    input: TokensObject,
};

export type DecodedEvent = {
    event: string,
    data: TokensObject,
};

export type DecodedOutput = {
    method: string,
    output: TokensObject,
};

export type DecodedTransaction = {
    method: string,
    input: TokensObject,
    output: TokensObject,
};

export type DecodedTransactionEvents = Array<DecodedEvent>;

export type TransactionExecutorOutput =
    | { exitCode: number }
    | { account: string, transaction: Transaction };

export type ExecutionOutput = {
    output?: TokensObject,
    code: number,
};

export type ReliableBehaviorType = 'BlockWalking' | 'IntensivePolling';

export type TransportInfo = {
    maxTransactionsPerFetch: number;
    reliableBehavior: ReliableBehaviorType;
    hasKeyBlocks: boolean;
};

export type MethodName = undefined | string | string[];

export type AbiToken =
    | null
    | boolean
    | string
    | number
    | { [K in string]: AbiToken }
    | AbiToken[]
    | (readonly [AbiToken, AbiToken])[];

type TokensObject = { [K in string]: AbiToken };

export type AbiParam = {
  name: string;
  type: string;
  components?: AbiParam[];
};

export type LatestBlock = {
    id: string,
    endLt: string,
    genUtime: number,
};

export type SignedMessage = {
    hash: string,
    expireAt: number,
    boc: string,
};

export type PollingMethod = 'manual' | 'reliable';

export type Ed25519KeyPair = {
    publicKey: string,
    secretKey: string,
};

export type ExtendedSignature = {
    signature: string,
    signatureHex: string,
    signatureParts: {
        high: string,
        low: string,
    }
};

export type FullContractState = {
    balance: string;
    genTimings: GenTimings;
    lastTransactionId: LastTransactionId;
    isDeployed: boolean;
    codeHash?: string;
    boc: string;
};

export type RawContractState = {
    account: string;
    lastTransactionId: LastTransactionId;
    timings: GenTimings;
    type: string;
};

export type TransactionTree = {
    root: Transaction,
    children: TransactionTree[]
};

export type StorageFeeInfo = {
    storageFee: string;
    storageFeeDebt?: string;
    accountStatus: AccountStatus;
    freezeDueLimit: string;
    deleteDueLimit: string;
};

export type SignatureContext =
  | { type: "empty" }
  | { type: "signatureId", globalId: number }
  | { type: "signatureDomainL2", globalId: number };



export interface IGqlSender {
  isLocal(): boolean;
  send(data: string, handler: StringQuery, long_query: boolean): void;
}

export interface IJrpcSender {
  send(data: string, handler: StringQuery, requires_db: boolean): void;
}

export interface IProtoSender {
  send(data: Uint8Array, handler: BytesQuery, requires_db: boolean): void;
}



export interface IProxyConnector {
  info(): TransportInfo;
  sendMessage(message: string): Promise<void>;
  getContractState(address: string): Promise<string>;
  getAccountsByCodeHash(codeHash: string, limit: number, continuation?: string): Promise<string[]>;
  getTransactions(address: string, fromLt: string, count: number): Promise<string[]>;
  getTransaction(id: string): Promise<string | undefined>;
  getDstTransaction(msg_hash: string): Promise<string | undefined>;
  getLatestKeyBlock(): Promise<string>;
  getCapabilities(now_ms: string): Promise<NetworkCapabilities>;
  getBlockchainConfig(now_ms: string): Promise<BlockchainConfig>;
}


export class BytesQuery {
  private constructor();
  free(): void;
  onReceive(data: Uint8Array): void;
  onTimeout(): void;
  onError(arg0: any): void;
}
export class ClockWithOffset {
  free(): void;
  updateOffset(offset_ms: number): void;
  constructor();
  offsetMs(): number;
  readonly nowMs: number;
}
export class GenericContract {
  private constructor();
  free(): void;
  handleBlock(block_id: string): Promise<PollingMethod>;
  sendMessage(message: SignedMessage): Promise<PendingTransaction>;
  preloadTransactions(lt: string): Promise<void>;
  sendMessageLocally(message: SignedMessage, params: ExecutorParams | undefined): Promise<Transaction>;
  refresh(): Promise<PollingMethod>;
  readonly pollingMethod: PollingMethod;
  readonly address: string;
}
export class GqlConnection {
  free(): void;
  getLatestBlock(address: string): Promise<LatestBlock>;
  waitForNextBlock(current_block_id: string, address: string, timeout: number): Promise<string>;
  constructor(sender: IGqlSender);
}
export class JrpcConnection {
  free(): void;
  constructor(sender: IJrpcSender);
}
export class ProtoConnection {
  free(): void;
  constructor(sender: IProtoSender);
}
export class ProxyConnection {
  free(): void;
  constructor(proxy_connector: IProxyConnector);
}
export class StringQuery {
  private constructor();
  free(): void;
  onReceive(data: string): void;
  onTimeout(): void;
  onError(arg0: any): void;
}
export class Transport {
  private constructor();
  free(): void;
  getTransaction(hash: string): Promise<Transaction | undefined>;
  getSignatureId(): Promise<number | undefined>;
  getTransactions(address: string, continuation: string | null | undefined, limit: number): Promise<TransactionsList>;
  static fromGqlConnection(gql: GqlConnection, clock: ClockWithOffset): Transport;
  getDstTransaction(message_hash: string): Promise<Transaction | undefined>;
  static fromJrpcConnection(jrpc: JrpcConnection, clock: ClockWithOffset): Transport;
  static fromProtoConnection(proto: ProtoConnection, clock: ClockWithOffset): Transport;
  static fromProxyConnection(proxy: ProxyConnection, clock: ClockWithOffset): Transport;
  getBlockchainConfig(force?: boolean | null): Promise<string>;
  getSignatureContext(): Promise<SignatureContext>;
  getFullContractState(address: string): Promise<FullContractState | undefined>;
  getNetworkDescription(): Promise<NetworkDescription>;
  getAccountsByCodeHash(code_hash: string, limit: number, continuation?: string | null): Promise<AccountsList>;
  subscribeToGenericContract(address: string, handler: any): Promise<GenericContract>;
}
export class UnsignedMessage {
  private constructor();
  free(): void;
  refreshTimeout(clock: ClockWithOffset): void;
  sign(signature: string): SignedMessage;
  expireAt(): number;
  signFake(): SignedMessage;
  readonly hash: string;
}