/// <reference types="node" />
import { AppConfig } from './appConfig';
import { SessionOptions } from './sessionData';
import { SessionDataStore } from './sessionStore';
import * as authApp from './authApp';
import * as storage from '../storage';
import { GaiaHubConfig } from '../storage/hub';
/**
 * Represents an instance of a signed in user for a particular app.
 *
 * A signed in user has access to two major pieces of information
 * about the user, the user's private key for that app and the location
 * of the user's gaia storage bucket for the app.
 *
 * A user can be signed in either directly through the interactive
 * sign in process or by directly providing the app private key.
 */
export declare class UserSession {
    appConfig: AppConfig;
    store: SessionDataStore;
    constructor(options?: {
        appConfig?: AppConfig;
        sessionStore?: SessionDataStore;
        sessionOptions?: SessionOptions;
    });
    /**
     * Generates an authentication request and redirects the user to the Blockstack
     * browser to approve the sign in request.
     *
     * Please note that this requires that the web browser properly handles the
     * `blockstack:` URL protocol handler.
     *
     * Most applications should use this
     * method for sign in unless they require more fine grained control over how the
     * authentication request is generated. If your app falls into this category,
     * use `generateAndStoreTransitKey`, `makeAuthRequest`,
     * and `redirectToSignInWithAuthRequest` to build your own sign in process.
     *
     * @return {void}
     */
    redirectToSignIn(redirectURI?: string, manifestURI?: string, scopes?: string[]): void;
    /**
     * Redirects the user to the Blockstack browser to approve the sign in request
     * given.
     *
     * The user is redirected to the authenticator URL specified in the `AppConfig`
     * if the `blockstack:` protocol handler is not detected.
     * Please note that the protocol handler detection
     * does not work on all browsers.
     * @param  {String} authRequest - the authentication request generated by `makeAuthRequest`
     * @return {void}
     */
    redirectToSignInWithAuthRequest(authRequest?: string, blockstackIDHost?: string): void;
    /**
     * Generates an authentication request that can be sent to the Blockstack
     * browser for the user to approve sign in. This authentication request can
     * then be used for sign in by passing it to the `redirectToSignInWithAuthRequest`
     * method.
     *
     * *Note: This method should only be used if you want to roll your own authentication
     * flow. Typically you'd use `redirectToSignIn` which takes care of this
     * under the hood.*
     * @param {string} transitKey - hex-encoded transit key
     * @param {Number} expiresAt - the time at which this request is no longer valid
     * @param {Object} extraParams - Any extra parameters you'd like to pass to the authenticator.
     * Use this to pass options that aren't part of the Blockstack auth spec, but might be supported
     * by special authenticators.
     * @return {String} the authentication request
     */
    makeAuthRequest(transitKey?: string, redirectURI?: string, manifestURI?: string, scopes?: string[], appDomain?: string, expiresAt?: number, extraParams?: any): string;
    /**
     * Generates a ECDSA keypair to
     * use as the ephemeral app transit private key
     * and store in the session
     * @return {String} the hex encoded private key
     *
     */
    generateAndStoreTransitKey(): string;
    /**
     * Retrieve the authentication token from the URL query
     * @return {String} the authentication token if it exists otherwise `null`
     */
    getAuthResponseToken(): string;
    /**
     * Check if there is a authentication request that hasn't been handled.
     * @return {Boolean} `true` if there is a pending sign in, otherwise `false`
     */
    isSignInPending(): boolean;
    /**
     * Check if a user is currently signed in.
     * @return {Boolean} `true` if the user is signed in, `false` if not.
     */
    isUserSignedIn(): boolean;
    /**
     * Try to process any pending sign in request by returning a `Promise` that resolves
     * to the user data object if the sign in succeeds.
     *
     * @param {String} authResponseToken - the signed authentication response token
     * @return {Promise} that resolves to the user data object if successful and rejects
     * if handling the sign in request fails or there was no pending sign in request.
     */
    handlePendingSignIn(authResponseToken?: string): Promise<authApp.UserData>;
    /**
     * Retrieves the user data object. The user's profile is stored in the key `profile`.
     * @return {Object} User data object.
     */
    loadUserData(): authApp.UserData;
    /**
     * Sign the user out and optionally redirect to given location.
     * @param  redirectURL
     * Location to redirect user to after sign out.
     * Only used in environments with `window` available
     */
    signUserOut(redirectURL?: string): void;
    /**
     * Encrypts the data provided with the app public key.
     * @param {String|Buffer} content - data to encrypt
     * @param {Object} [options=null] - options object
     * @param {String} options.publicKey - the hex string of the ECDSA public
     * key to use for encryption. If not provided, will use user's appPrivateKey.
     * @return {String} Stringified ciphertext object
     */
    encryptContent(content: string | Buffer, options?: {
        publicKey?: string;
    }): string;
    /**
     * Decrypts data encrypted with `encryptContent` with the
     * transit private key.
     * @param {String|Buffer} content - encrypted content.
     * @param {Object} [options=null] - options object
     * @param {String} options.privateKey - the hex string of the ECDSA private
     * key to use for decryption. If not provided, will use user's appPrivateKey.
     * @return {String|Buffer} decrypted content.
     */
    decryptContent(content: string, options?: {
        privateKey?: string;
    }): string | Buffer;
    /**
     * Stores the data provided in the app's data store to to the file specified.
     * @param {String} path - the path to store the data in
     * @param {String|Buffer} content - the data to store in the file
     * @param {Object} [options=null] - options object
     * @param {Boolean|String} [options.encrypt=true] - encrypt the data with the app private key
     *                                                  or the provided public key
     * @param {Boolean} [options.sign=false] - sign the data using ECDSA on SHA256 hashes with
     *                                         the app private key
     * @return {Promise} that resolves if the operation succeed and rejects
     * if it failed
     */
    putFile(path: string, content: string | Buffer, options?: storage.PutFileOptions): Promise<string>;
    /**
     * Retrieves the specified file from the app's data store.
     * @param {String} path - the path to the file to read
     * @param {Object} [options=null] - options object
     * @param {Boolean} [options.decrypt=true] - try to decrypt the data with the app private key
     * @param {String} options.username - the Blockstack ID to lookup for multi-player storage
     * @param {Boolean} options.verify - Whether the content should be verified, only to be used
     * when `putFile` was set to `sign = true`
     * @param {String} options.app - the app to lookup for multi-player storage -
     * defaults to current origin
     * @param {String} [options.zoneFileLookupURL=null] - The URL
     * to use for zonefile lookup. If falsey, this will use the
     * blockstack.js's getNameInfo function instead.
     * @returns {Promise} that resolves to the raw data in the file
     * or rejects with an error
     */
    getFile(path: string, options?: storage.GetFileOptions): Promise<string | ArrayBuffer>;
    /**
     * Get the URL for reading a file from an app's data store.
     * @param {String} path - the path to the file to read
     * @param {Object} [options=null] - options object
     * @param {String} options.username - the Blockstack ID to lookup for multi-player storage
     * @param {String} options.app - the app to lookup for multi-player storage -
     * defaults to current origin
     * @param {String} [options.zoneFileLookupURL=null] - The URL
     * to use for zonefile lookup. If falsey, this will use the
     * blockstack.js's getNameInfo function instead.
     * @returns {Promise<string>} that resolves to the URL or rejects with an error
     */
    getFileUrl(path: string, options?: {
        username?: string;
        app?: string;
        zoneFileLookupURL?: string;
    }): Promise<string>;
    /**
     * List the set of files in this application's Gaia storage bucket.
     * @param {function} callback - a callback to invoke on each named file that
     * returns `true` to continue the listing operation or `false` to end it
     * @return {Promise} that resolves to the number of files listed
     */
    listFiles(callback: (name: string) => boolean): Promise<number>;
    /**
     * Deletes the specified file from the app's data store. Currently not implemented.
     * @param {String} path - the path to the file to delete
     * @returns {Promise} that resolves when the file has been removed
     * or rejects with an error
     */
    deleteFile(path: string): void;
    getOrSetLocalGaiaHubConnection(): Promise<GaiaHubConfig>;
    /**
     * These two functions are app-specific connections to gaia hub,
     *   they read the user data object for information on setting up
     *   a hub connection, and store the hub config to localstorage
     * @private
     * @returns {Promise} that resolves to the new gaia hub connection
     */
    setLocalGaiaHubConnection(): Promise<GaiaHubConfig>;
}