/// <reference types="node" />
/// <reference types="pouchdb-core" />
import { BinaryWriter, ECPoint, RegisterTransactionJSON, TransactionBaseModel, UInt160, UInt160Hex } from '@neo-one/client-common';
import { Constructor } from '@neo-one/utils';
import BN from 'bn.js';
import { AssetType } from '../AssetType';
import { DeserializeWireBaseOptions, SerializeJSONContext } from '../Serializable';
import { VerifyScriptResult } from '../vm';
import { Witness } from '../Witness';
import { Attribute } from './attribute';
import { Input } from './Input';
import { Output } from './Output';
import { FeeContext, TransactionBaseAdd, TransactionGetScriptHashesForVerifyingOptions, TransactionVerifyOptions } from './TransactionBase';
import { TransactionType } from './TransactionType';
interface Asset {
    readonly type: AssetType;
    readonly name: string;
    readonly amount: BN;
    readonly precision: number;
    readonly owner: ECPoint;
    readonly admin: UInt160;
}
export interface RegisterTransactionAdd extends TransactionBaseAdd {
    readonly asset: Asset;
}
declare const RegisterTransaction_base: {
    new (...args: any[]): {
        readonly equals: import("..").Equals;
        readonly toKeyString: () => string;
        readonly getSortedScriptHashesForVerifying: (input: TransactionGetScriptHashesForVerifyingOptions) => Promise<string[]>;
        readonly sizeInternal: () => number;
        readonly networkFee: (input: FeeContext) => Promise<BN>;
        readonly getReferencesInternal: (input: import("./TransactionBase").GetReferencesOptions) => Promise<Output[]>;
        readonly getTransactionResultsInternal: (input: import("./TransactionBase").GetTransactionResultsOptions) => Promise<{
            readonly [x: string]: BN | undefined;
        }>;
        readonly baseGetScriptHashesForVerifyingInternal: (input: TransactionGetScriptHashesForVerifyingOptions) => Promise<Set<string>>;
        readonly size: number;
        serializeTransactionBaseJSON(context: SerializeJSONContext): Promise<import("@neo-one/client-common").TransactionBaseJSON>;
        serializeJSON(_context: SerializeJSONContext): Promise<RegisterTransactionJSON>;
        getNetworkFee(context: FeeContext): Promise<BN>;
        getSystemFee({ fees }: FeeContext): BN;
        getReferences(options: import("./TransactionBase").GetReferencesOptions): Promise<readonly Output[]>;
        getTransactionResults(options: import("./TransactionBase").GetTransactionResultsOptions): Promise<{
            readonly [key: string]: BN;
        }>;
        getScriptHashesForVerifying(options: TransactionGetScriptHashesForVerifyingOptions): Promise<Set<string>>;
        verify(options: TransactionVerifyOptions): Promise<readonly VerifyScriptResult[]>;
        readonly sizeExclusive: () => number;
        verifyDoubleSpend({ isSpent }: TransactionVerifyOptions): Promise<void>;
        verifyOutputs({ getAsset, currentHeight }: TransactionVerifyOptions): Promise<void>;
        verifyTransactionResults({ getOutput, utilityToken, governingToken, fees, registerValidatorFee, }: TransactionVerifyOptions): Promise<void>;
        verifyScripts({ getAsset, getOutput, verifyScript, }: TransactionVerifyOptions): Promise<readonly VerifyScriptResult[]>;
        readonly type: TransactionType.Register;
        readonly version: number;
        readonly attributes: readonly Attribute[];
        readonly inputs: readonly Input[];
        readonly outputs: readonly Output[];
        readonly scripts: readonly Witness[];
        readonly serializeWire: import("../Serializable").SerializeWire;
        readonly serializeUnsigned: import("../Serializable").SerializeWire;
        readonly hashInternal: () => import("@neo-one/client-common").UInt256;
        readonly hashHexInternal: () => string;
        readonly messageInternal: () => Buffer;
        clone(options: {
            readonly scripts?: readonly Witness[] | undefined;
            readonly attributes?: readonly Attribute[] | undefined;
            readonly inputs?: readonly Input[] | undefined;
            readonly outputs?: readonly Output[] | undefined;
        }): any;
        readonly hash: import("@neo-one/client-common").UInt256;
        readonly hashHex: string;
        readonly message: Buffer;
        sign(key: import("@neo-one/client-common").PrivateKey): any;
        signWithSignature(signature: Buffer, publicKey: ECPoint): any;
        serializeExclusiveBase(_writer: BinaryWriter): void;
        serializeUnsignedBase(writer: BinaryWriter): void;
        serializeWireBase(writer: BinaryWriter): void;
    };
    deserializeTransactionBaseStartWireBase({ reader, }: DeserializeWireBaseOptions): {
        readonly type: TransactionType;
        readonly version: number;
    };
    deserializeTransactionBaseEndWireBase(options: DeserializeWireBaseOptions): {
        readonly attributes: readonly Attribute[];
        readonly inputs: readonly Input[];
        readonly outputs: readonly Output[];
        readonly scripts: readonly Witness[];
    };
    deserializeWireBase(_options: DeserializeWireBaseOptions): any;
    deserializeWire(options: import("../Serializable").DeserializeWireOptions): any;
    readonly WitnessConstructor: Constructor<Witness>;
} & Constructor<TransactionBaseModel<TransactionType.Register, Attribute, Input, Output, Witness>>;
export declare class RegisterTransaction extends RegisterTransaction_base {
    static deserializeWireBase(options: DeserializeWireBaseOptions): RegisterTransaction;
    readonly asset: Asset;
    protected readonly sizeExclusive: () => number;
    private readonly registerGetScriptHashesForVerifyingInternal;
    constructor({ version, attributes, inputs, outputs, scripts, hash, asset }: RegisterTransactionAdd);
    clone({ scripts, attributes, inputs, outputs, }: {
        readonly scripts?: readonly Witness[];
        readonly attributes?: readonly Attribute[];
        readonly inputs?: readonly Input[];
        readonly outputs?: readonly Output[];
    }): this;
    serializeExclusiveBase(writer: BinaryWriter): void;
    serializeJSON(context: SerializeJSONContext): Promise<RegisterTransactionJSON>;
    getSystemFee(context: FeeContext): BN;
    getScriptHashesForVerifying(options: TransactionGetScriptHashesForVerifyingOptions): Promise<Set<UInt160Hex>>;
    verify(_options: TransactionVerifyOptions): Promise<readonly VerifyScriptResult[]>;
}
export {};