/// <reference types="node" />
import { ActiveDefinitions } from "@activeledger/activedefinitions";
import { ActiveCrypto as DefaultActiveCrypto } from "@activeledger/activecrypto";
import { EventEmitter } from "events";
export declare class Stream {
    protected cDate: Date;
    protected remoteAddr: string;
    protected umid: string;
    protected transactions: ActiveDefinitions.LedgerTransaction;
    private inputs;
    private outputs;
    private reads;
    private contractData;
    private sigs;
    private key;
    private eventEmitter;
    private selfHost;
    private activities;
    private inINC;
    private outINC;
    updatedContractData: boolean;
    throwTo: string[];
    private nextTimeout;
    private safeMode;
    private clearINC;
    private remoteReturn;
    ActiveLogger: typeof ActiveLogger;
    ActiveCrypto: typeof ActiveCrypto;
    constructor(cDate: Date, remoteAddr: string, umid: string, transactions: ActiveDefinitions.LedgerTransaction, inputs: ActiveDefinitions.LedgerStream[], outputs: ActiveDefinitions.LedgerStream[], reads: ActiveDefinitions.LedgerIORputs, contractData: ActiveDefinitions.IContractData, sigs: ActiveDefinitions.LedgerSignatures, key: number, eventEmitter: EventEmitter, selfHost: string);
    private filterPrefix;
    attemptDecrypt(data: DefaultActiveCrypto.ISecuredData | {}, safeMode?: boolean): Promise<{}>;
    newActivityStream(name: string, deterministic?: string): Activity;
    getActivityStreams(): {
        [reference: string]: Activity;
    };
    getActivityStreams(stream: any): Activity;
    getMofSignatures(m: number): boolean;
    hasAuthorityStake(minimum: number, activity: Activity): boolean;
    getContractData<T>(): T;
    setContractData<T>(contractData: T): void;
    exportContractData(): ActiveDefinitions.IContractData;
    getReadOnlyStream(name: string): any;
    getAnyStreamReadOnly(streamId: string): Promise<ActiveDefinitions.IStream>;
    setInterNodeComms(secret: number, data: ActiveDefinitions.ICommunications): void;
    protected getInterNodeComms(): ActiveDefinitions.ICommunications;
    protected setThisInterNodeComms(data: object): void;
    getThisInterNodeComms(): object;
    protected clearAllInterNodeComms(): void;
    getClearInterNodeComms(): boolean;
    protected returnToRemote(data: unknown): void;
    getReturnToRemote(): unknown;
    protected getRemoteAddr(): string;
    findRemoteAddr(matches: string | string[]): boolean;
    throw(location: string): void;
    isExecutingOn(host: string): boolean;
    protected setTimeout(ms: number): void;
    getTimeout(): Date;
}
export declare class Activity {
    private umid;
    private name;
    private signature;
    private eventEmitter;
    private meta;
    private state;
    updated: boolean;
    volatileUpdated: boolean;
    private key;
    private safeMode;
    private volatile;
    constructor(umid: string, name: string | null, signature: boolean, eventEmitter: EventEmitter, meta?: ActiveDefinitions.IMeta, state?: ActiveDefinitions.IState);
    setSafeMode(): void;
    export2Ledger(secret: number): ActiveDefinitions.LedgerStream;
    setKey(secret: number): void;
    setACL(name: string, stream: string): void;
    hasACL(name: string): boolean;
    hasSignature(): boolean;
    setAuthority(pubKey: string, type?: string): void;
    setAuthorities(authority: ActiveDefinitions.ILedgerAuthority | ActiveDefinitions.ILedgerAuthority[]): void;
    deleteAuthorities(pubKey: string | string[]): void;
    getAuthority(type?: boolean): string | undefined;
    getAuthorities(): ActiveDefinitions.ILedgerAuthority[];
    setContractLock(script: string | Array<string>): boolean;
    setNamespaceLock(namespace: string | Array<string>): boolean;
    getId(): string;
    getName(): string;
    getState(): ActiveDefinitions.IState;
    setState(state: ActiveDefinitions.IState): void;
    getVolatile(): Promise<ActiveDefinitions.IVolatile>;
    private makeVolatileSafe;
    setVolatile(volatile: ActiveDefinitions.IVolatile): void;
    getCng(buffer?: string): number;
}
export declare class ActiveCrypto {
    private static reference;
    static Hash: DefaultActiveCrypto.Hash;
    static KeyPair: DefaultActiveCrypto.KeyPair;
    static Secured: DefaultActiveCrypto.Secured;
}
export declare class ActiveLogger {
    private static reference;
    static trace(msg: string): void;
    static trace(obj: object, msg?: string): void;
    static debug(msg: string): void;
    static debug(obj: object, msg?: string): void;
    static info(msg: string): void;
    static info(obj: object, msg?: string): void;
    static warn(msg: string): void;
    static warn(obj: object, msg?: string): void;
    static error(msg: string): void;
    static error(obj: object, msg?: string): void;
    static fatal(msg: string): void;
    static fatal(obj: object, msg?: string): void;
}
//# sourceMappingURL=stream.d.ts.map