import { DecodedLogEntryEvent, DecodedLogEntry, DecodedTransactionReceipt } from "@joincivil/typescript-types";
import "rxjs/add/operator/distinctUntilChanged";
import { TransactionConfig } from "web3-core";
import { EthAddress } from "@joincivil/typescript-types";
import { EthApi } from "@joincivil/ethapi";
import { BaseContract } from "../../basecontract";
declare type BigNumber = string;
export declare class NewsroomContract extends BaseContract {
    static singletonTrusted(ethApi: EthApi): Promise<NewsroomContract | undefined>;
    static atUntrusted(ethApi: EthApi, address: EthAddress): NewsroomContract;
    static deployTrusted: {
        sendTransactionAsync(ethApi: EthApi, newsroomName: string, charterUri: string, charterHash: string, options: TransactionConfig): Promise<string>;
        estimateGasAsync(ethApi: EthApi, newsroomName: string, charterUri: string, charterHash: string): Promise<number>;
    };
    name: {
        callAsync(): Promise<string>;
    };
    hasRole: {
        callAsync(user: string, role: string): Promise<boolean>;
    };
    isOwner: {
        callAsync(user: string): Promise<boolean>;
    };
    renounceOwnership: {
        sendTransactionAsync(txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    owner: {
        callAsync(): Promise<string>;
    };
    contentCount: {
        callAsync(): Promise<string>;
    };
    transferOwnership: {
        sendTransactionAsync(_newOwner: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_newOwner: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_newOwner: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    getContent: {
        callAsync(contentId: string): Promise<[string, string, string, string, string]>;
    };
    getRevision: {
        callAsync(contentId: string, revisionId: string): Promise<[string, string, string, string, string]>;
    };
    revisionCount: {
        callAsync(contentId: string): Promise<string>;
    };
    isContentSigned: {
        callAsync(contentId: string): Promise<boolean>;
    };
    isRevisionSigned: {
        callAsync(contentId: string, revisionId: string): Promise<boolean>;
    };
    setName: {
        sendTransactionAsync(newName: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(newName: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(newName: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    addRole: {
        sendTransactionAsync(who: string, role: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(who: string, role: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(who: string, role: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    addEditor: {
        sendTransactionAsync(who: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(who: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(who: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    removeRole: {
        sendTransactionAsync(who: string, role: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(who: string, role: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(who: string, role: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    publishContent: {
        sendTransactionAsync(contentUri: string, contentHash: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(contentUri: string, contentHash: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(contentUri: string, contentHash: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    updateRevision: {
        sendTransactionAsync(contentId: string, contentUri: string, contentHash: string, signature: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(contentId: string, contentUri: string, contentHash: string, signature: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(contentId: string, contentUri: string, contentHash: string, signature: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    signRevision: {
        sendTransactionAsync(contentId: string, revisionId: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(contentId: string, revisionId: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(contentId: string, revisionId: string, author: string, signature: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    ContentPublishedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.ContentPublished, Newsroom.Events.ContentPublished>>;
    RevisionSignedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.RevisionSigned, Newsroom.Events.RevisionSigned>>;
    RevisionUpdatedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.RevisionUpdated, Newsroom.Events.RevisionUpdated>>;
    NameChangedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.NameChanged, Newsroom.Events.NameChanged>>;
    RoleAddedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.RoleAdded, Newsroom.Events.RoleAdded>>;
    RoleRemovedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.RoleRemoved, Newsroom.Events.RoleRemoved>>;
    OwnershipRenouncedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.OwnershipRenounced, Newsroom.Events.OwnershipRenounced>>;
    OwnershipTransferredStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<Newsroom.Args.OwnershipTransferred, Newsroom.Events.OwnershipTransferred>>;
    private constructor();
}
export declare namespace Newsroom {
    enum Events {
        ContentPublished = "ContentPublished",
        RevisionSigned = "RevisionSigned",
        RevisionUpdated = "RevisionUpdated",
        NameChanged = "NameChanged",
        RoleAdded = "RoleAdded",
        RoleRemoved = "RoleRemoved",
        OwnershipRenounced = "OwnershipRenounced",
        OwnershipTransferred = "OwnershipTransferred"
    }
    namespace Args {
        interface ContentPublished {
            editor: string;
            contentId: BigNumber;
            uri: string;
        }
        interface RevisionSigned {
            contentId: BigNumber;
            revisionId: BigNumber;
            author: string;
        }
        interface RevisionUpdated {
            editor: string;
            contentId: BigNumber;
            revisionId: BigNumber;
            uri: string;
        }
        interface NameChanged {
            newName: string;
        }
        interface RoleAdded {
            granter: string;
            grantee: string;
            role: string;
        }
        interface RoleRemoved {
            granter: string;
            grantee: string;
            role: string;
        }
        interface OwnershipRenounced {
            previousOwner: string;
        }
        interface OwnershipTransferred {
            previousOwner: string;
            newOwner: string;
        }
    }
    namespace Logs {
        type ContentPublished = DecodedLogEntry<Args.ContentPublished, Events.ContentPublished>;
        type RevisionSigned = DecodedLogEntry<Args.RevisionSigned, Events.RevisionSigned>;
        type RevisionUpdated = DecodedLogEntry<Args.RevisionUpdated, Events.RevisionUpdated>;
        type NameChanged = DecodedLogEntry<Args.NameChanged, Events.NameChanged>;
        type RoleAdded = DecodedLogEntry<Args.RoleAdded, Events.RoleAdded>;
        type RoleRemoved = DecodedLogEntry<Args.RoleRemoved, Events.RoleRemoved>;
        type OwnershipRenounced = DecodedLogEntry<Args.OwnershipRenounced, Events.OwnershipRenounced>;
        type OwnershipTransferred = DecodedLogEntry<Args.OwnershipTransferred, Events.OwnershipTransferred>;
        type All = Logs.ContentPublished | Logs.RevisionSigned | Logs.RevisionUpdated | Logs.NameChanged | Logs.RoleAdded | Logs.RoleRemoved | Logs.OwnershipRenounced | Logs.OwnershipTransferred;
    }
    namespace LogEvents {
        type ContentPublished = DecodedLogEntryEvent<Args.ContentPublished, Events.ContentPublished>;
        type RevisionSigned = DecodedLogEntryEvent<Args.RevisionSigned, Events.RevisionSigned>;
        type RevisionUpdated = DecodedLogEntryEvent<Args.RevisionUpdated, Events.RevisionUpdated>;
        type NameChanged = DecodedLogEntryEvent<Args.NameChanged, Events.NameChanged>;
        type RoleAdded = DecodedLogEntryEvent<Args.RoleAdded, Events.RoleAdded>;
        type RoleRemoved = DecodedLogEntryEvent<Args.RoleRemoved, Events.RoleRemoved>;
        type OwnershipRenounced = DecodedLogEntryEvent<Args.OwnershipRenounced, Events.OwnershipRenounced>;
        type OwnershipTransferred = DecodedLogEntryEvent<Args.OwnershipTransferred, Events.OwnershipTransferred>;
        type All = LogEvents.ContentPublished | LogEvents.RevisionSigned | LogEvents.RevisionUpdated | LogEvents.NameChanged | LogEvents.RoleAdded | LogEvents.RoleRemoved | LogEvents.OwnershipRenounced | LogEvents.OwnershipTransferred;
    }
    type Receipt = DecodedTransactionReceipt<Logs.All>;
    type EventReceipt = DecodedTransactionReceipt<LogEvents.All>;
}
export {};