import { EthApi } from "@joincivil/ethapi";
import { NewsroomRoles } from "@joincivil/utils";
import { Observable } from "rxjs";
import { TransactionReceipt, TransactionConfig, Transaction } from "web3-core";
import { ContentProvider } from "../content/contentprovider";
import { BigNumber, ApprovedRevision, CharterContent, ContentId, EthAddress, EthContentHeader, Hex, NewsroomContent, NewsroomData, NewsroomWrapper, RevisionId, TxHash, Uri } from "@joincivil/typescript-types";
import { CivilTransactionReceipt, TwoStepEthTransaction } from "../types";
import { BaseWrapper } from "./basewrapper";
import { NewsroomContract } from "./generated/wrappers/newsroom";
import { MultisigProxyTransaction } from "./multisig/basemultisigproxy";
import { MultisigTransaction } from "./multisig/multisigtransaction";
/**
 * A Newsroom can be thought of an organizational unit with a sole goal of providing content
 * in an organized way.
 *
 * Newsroom is controlled by access-control pattern, with multiple roles (see [[NewsroomRoles]]) that allow governing
 * what get's published and what isn't.
 *
 * All of the logic exists on the Ethereum network, with the data of articles living outside.
 * The smart-contracts doesn't limit _where_ the articles lives, as it accepts an URI with a schema.
 * And so articles can live in IPFS, Filecoin, Whisper, or just a simple HTTP server.
 * Right now the only supported systems are HTTP and [[InMemoryProvider]] for debugging purpouses
 */
export declare class Newsroom extends BaseWrapper<NewsroomContract> {
    static deployTrusted(ethApi: EthApi, contentProvider: ContentProvider, newsroomName: string, charterUri?: Uri, charterHash?: Hex): Promise<TwoStepEthTransaction<Newsroom>>;
    static fromFactoryReceipt(factoryReceipt: TransactionReceipt, ethApi: EthApi, contentProvider: ContentProvider): Promise<Newsroom>;
    static estimateDeployTrusted(ethApi: EthApi, newsroomName: string, charterUri?: string, charterHash?: string): Promise<number>;
    static deployNonMultisigTrusted(ethApi: EthApi, contentProvider: ContentProvider, newsroomName: string, charterUri?: Uri, charterHash?: Hex): Promise<TwoStepEthTransaction<Newsroom>>;
    static atUntrusted(ethApi: EthApi, contentProvider: ContentProvider, address: EthAddress): Promise<Newsroom>;
    static recoverArchiveTx(tx: Transaction): Promise<string>;
    private multisigProxy;
    private contentProvider;
    private constructor();
    editors(): Observable<EthAddress>;
    /**
     * An unending stream of all the content, both signed as well as unsigned.
     * @param fromBlock Starting block in history for events concerning content being proposed.
     *                  Set to "latest" for only new events
     * @returns Metadata about the content from Ethereum. Use [[resolveContent]] to get actual contents
     */
    content(fromBlock?: number): Observable<EthContentHeader>;
    /**
     * An unending stream of all revsions
     * @param contentId Optional parameter to get revisions of only specific content
     * @param fromBlock Starting block in history for events concerning content being proposed.
     *                  Set to "latest" for only new events
     * @returns Metadata about the content from Ethereum. Use [[resolveContent]] to get actual contents
     */
    revisions(contentId?: number | BigNumber | undefined, fromBlock?: number): Observable<EthContentHeader>;
    /**
     * An unending stream of all names this Newsroom had ever had.
     * @param fromBlock Starting block in history for events.
     *                  Set to "latest" to only listen for new events
     * @returns Name history of this Newsroom
     */
    nameChanges(fromBlock?: number): Observable<string>;
    /**
     * Returns NewsroomWrapper (address + data) for this newsroom
     */
    getNewsroomWrapper(): Promise<NewsroomWrapper>;
    /**
     * Returns NewsroomData for this newsroom
     */
    getNewsroomData(): Promise<NewsroomData>;
    /**
     * Returns a list of Board of Directors with superuser powers over this
     * newsroom.
     */
    owners(): Promise<EthAddress[]>;
    addOwner(owner: EthAddress): Promise<TwoStepEthTransaction<MultisigTransaction>>;
    estimateAddOwner(owner: EthAddress): Promise<number>;
    /**
     * Returns the address of the multisig that controls this newsroom if one is defined
     */
    getMultisigAddress(): Promise<EthAddress | undefined>;
    /**
     * Transfers ETH from multisig to a given address
     * @param eth Amount to transfer, in ether
     * @param to Address to transfer to
     */
    transferEthFromMultisig(eth: string, to: EthAddress): Promise<TwoStepEthTransaction<MultisigTransaction>>;
    /**
     * Checks if the user is the owner of the newsroom
     * @param address Address for the ownership check, leave empty for current user
     * @throws {CivilErrors.NoUnlockedAccount} Requires the node to have at least one account if no address provided
     */
    isOwner(address?: EthAddress): Promise<boolean>;
    /**
     * Checks if the user can assign roles and approve/deny content
     * @param address Address for the role check, leave empty for current user
     * @throws {CivilErrors.NoUnlockedAccount} Requires the node to have at least one account if no address provided
     */
    isEditor(address?: EthAddress): Promise<boolean>;
    /**
     * Checks if the user can assign roles and approve/deny content
     * Also returns true if user has director super powers
     * @param address Address for the role check, leave empty for current user
     * @throws {CivilErrors.NoUnlockedAccount} Requires the node to have at least one account if no address provided
     */
    hasEditorCapabilities(address?: EthAddress): Promise<boolean>;
    getArticleHeader(articleId: BigNumber): Promise<EthContentHeader>;
    getCharterHeader(): Promise<EthContentHeader>;
    /**
     * Gets newsroom charter data.
     * @throws {CivilErrors.MalformedCharter} Charter data is malformed.
     */
    getCharter(): Promise<CharterContent | undefined>;
    /**
     * Loads everything concerning one article needed to read it fully.
     * Accesess both Ethereum network as well as the active ContentProvider
     * @param articleId Id of the article that you want to read
     */
    loadArticle(articleId: BigNumber): Promise<NewsroomContent | undefined>;
    /**
     * Converts metadata gathered from Ethereum network into a fully fledged Article all the
     * text needed for display
     * @param header Metadata you get from Ethereum
     */
    resolveContent(header: EthContentHeader): Promise<NewsroomContent | undefined>;
    /**
     * Accesses the Ethereum network and loads basic metatadata about the content
     * @param articleId Id of the article whose metadata you need
     */
    loadContentHeader(contentId: BigNumber, revisionId?: number | BigNumber): Promise<EthContentHeader>;
    getName(): Promise<string>;
    /**
     * Sets an Access-Control-List role to a specified address
     * @param actor The address that shall be granted a role
     * @param role What privilige the address should be given
     * @throws {Civil.NoPrivileges} Requires editor privilege
     * @throws {CivilErrors.NoUnlockedAccount} Needs at least one account for editor role check
     */
    addRole(actor: EthAddress, role: NewsroomRoles): Promise<MultisigProxyTransaction>;
    /**
     * Removes an Access-Control-List role to a specified address
     * Silently succeeds if the role isn't set
     * @param actor The address that shall have the role removed
     * @param role What privilege will be removed
     * @throws {Civil.NoPrivileges} Requires editor privilege
     * @throws {CivilErrors.NoUnlockedAccount} Needs at least one account for editor role check
     */
    removeRole(actor: EthAddress, role: NewsroomRoles): Promise<MultisigProxyTransaction>;
    removeOwner(actor: EthAddress): Promise<TwoStepEthTransaction<MultisigTransaction>>;
    /**
     * Changes the name of the Newsroom.
     * The name can be any string, but when applying to a TCR, it must be unique in that TCR
     * @param newName The new name of this Newsroom
     * @throws {CivilErrors.NoPrivileges} Requires owner permission
     * @throws {CivilErrors.NoUnlockedAccount} Needs the unlocked to check privileges
     */
    setName(newName: string): Promise<MultisigProxyTransaction>;
    txArchiveForContentId(contentId: number, revisionId: number): Observable<any>;
    estimatePublishURIAndHash(uriOrContent: any, hash: string, author?: string, signature?: string, archive?: boolean): Promise<number>;
    estimateUpdateURIAndHash(contentId: number, uriOrContent: any, hash: string, signature?: string, archive?: boolean): Promise<number>;
    estimateFromDataMultiSig(data: TransactionConfig, content?: any): Promise<number>;
    estimateFromContent(content: any, dataLength: number): Promise<number>;
    publishURIAndHash(uri: string, hash: string, author?: string, signature?: string): Promise<TwoStepEthTransaction<ContentId | MultisigTransaction>>;
    updateRevisionURIAndHash(contentId: ContentId, uri: string, hash: string, signature?: string): Promise<TwoStepEthTransaction<RevisionId | MultisigTransaction>>;
    addArchiveToMultisig(data: TransactionConfig, hex: string, gas: number): Promise<TransactionConfig>;
    publishWithArchive(content: any, hash: string, author?: string, signature?: string): Promise<TwoStepEthTransaction<MultisigTransaction | ContentId>>;
    updateRevisionURIAndHashWithArchive(contentId: ContentId, content: any, hash: string, signature?: string): Promise<TwoStepEthTransaction<RevisionId | MultisigTransaction>>;
    contentIdFromTxHash(txHash: TxHash): Promise<number>;
    /**
     * Allows editor to publish content on the ethereum storage and record it in the
     * Blockchain Newsroom.
     * The content can also be pre-approved by the author through their signature using their private key
     * @param content The content that should be put in the content provider
     * @param signedData An object representing author's approval concerning this content
     * @returns An id assigned on Ethereum to the uri, or a multig transaction if it requires more confirmations
     */
    publishContent(content: string, signedData?: ApprovedRevision): Promise<TwoStepEthTransaction<ContentId | MultisigTransaction>>;
    revisionFromTxHash(txHash: TxHash): Promise<RevisionId>;
    /**
     * Allows editor to create a new revision to already existing content.
     * The revision can be unsigned. If the revision is signed,
     * the author has to match the author defined when publishing in the first place.
     * If there was no author during publishing [[signRevision]] can update them.
     * @param contentId The id of the already published content
     * @param content The data that should be stored in content storage
     * @param signedData Optional pre-approval from the author concerning this article
     */
    updateRevision(contentId: ContentId, content: string, signedData?: ApprovedRevision): Promise<TwoStepEthTransaction<RevisionId | MultisigTransaction>>;
    /**
     * Allows editor to back-sign a revision which was previously unsigned.
     * Additionally if the content was published without the author, this function will allow to set the author.
     * If the author was set previously, the signature also needs to be from the same author.
     * @param contentId The id of already published content
     * @param revisionId The id of already published revision for that content
     * @param signedData Data needed to back-sign the revision
     */
    signRevision(contentId: ContentId, revisionId: RevisionId, signedData: ApprovedRevision): Promise<TwoStepEthTransaction<CivilTransactionReceipt | MultisigTransaction>>;
    /**
     * Signs that specific content with the current private key of the user of this library with their approval
     * @param content Data to sign
     * @returns An object containing all information to represent what has the author approved
     */
    approveByAuthor(content: string): Promise<ApprovedRevision>;
    approveByAuthorPersonalSign(contentHash: Hex): Promise<ApprovedRevision>;
    private requireEditor;
    private requireRole;
    private requireOwner;
    private verifyApprovedRevision;
    private uploadToStorage;
    /**
     * Used when the transaction might go through a multisig wallet
     * In that case, more confirmations might be needed from other owners
     */
    private twoStepOrMulti;
}