import { BearerTokenHttpClientProvider } from '@trimble-oss/trimble-id';
import { AuthState, TIDUser, TokenResponse } from './interfaces';
interface TIDClientConfig {
    /**
     * The URL for the Trimble Identity OpenID well known configuration endpoint
     * Staging: https://stage.id.trimblecloud.com/.well-known/openid-configuration
     * Production: https://id.trimble.com/.well-known/openid-configuration
     * @type {string}
     */
    configurationEndpoint: string;
    /**
     * Client id of the application created in trimble developer console
     * @type {string}
     */
    clientId: string;
    /**
     * The URL to which Trimble Identity should redirect after successfully authenticating a user
     * @type {string}
     */
    redirectUrl: string;
    /**
     * The URL to which Trimble Identity should redirect after successfully logout a user
     * @type {string}
     */
    logoutRedirectUrl: string;
    /**
     * The type of credentials you want (openID, or application_name)
     * @type {string[]}
     */
    scopes: string[];
}
interface LoginWithRedirectOptions {
    /**
     * Function called when the user redirection is occurring
     * If you send this function you will need to handle the redirection
     * @param {string} url - Redirect url to TID with the necessary information to log in the user
     */
    onRedirect?: (url: string) => void;
}
interface LogoutOptions {
    /**
     * Function called when the user redirection is occurring
     * If you send this function you will need to handle the redirection
     * @param {string} url - Redirect url to TID with the necessary information to log out the user
     */
    onRedirect?: (url: string) => void;
    /**
     * If you want to disable the auto redirect to TID after the logout is successful you can set this to true
     * If you set this to true you will need to handle the redirection and the provider will clear the user information from the context
     *
     * **IMPORTANT**: If you set this to true the user information will be cleared from the context and isAuthenticated will be false
     * if you are using the AuthenticationGuard component it will redirect the user to the login page automatically
     * @default false
     * @type {boolean}
     * @example
     * logout({disabledAutoRedirect: true})
     */
    disabledAutoRedirect?: boolean;
}
export interface TIDClientOptions {
    /**
     * TID client configuration
     * @type {TIDClientConfig}
     */
    config: TIDClientConfig;
}
export declare class TIDClient {
    /**
     * Token provider SDK. This object handles all necessary communication with TID
     * @type {AuthorizationCodeGrantTokenProvider}
     */
    private tokenProvider;
    /**
     * This object manage all caching, and all configurations necessary
     * @type {CacheManager}
     */
    private readonly cacheManager;
    /**
     * This object manage all cookies administration, and all configurations necessary
     * @type {CookiesManager}
     */
    private readonly cookiesManager;
    /**
     * Client id of the application created in trimble developer console
     * @type {string}
     */
    private readonly clientId;
    /**
     * Callback url to redirect the user after the authentication is successful
     * @type {string}
     */
    private readonly redirectUrl;
    /**
      * AnalyticsHttpClient for sending events
      * @type {AnalyticsHttpClient}
      */
    private readonly analyticshttpclient;
    /**
     * Create a TID client to handle manage all user authentication functions and information
     * @param {CacheManagerOptions} props - TID client configuration
     */
    constructor(props: TIDClientOptions);
    /**
     * Redirect the user to TID using the browser
     * @param {LoginWithRedirectOptions} options - Custom configuration for the redirection
     * @return {Promise<void>} Empty promise
     * @example No configuration
     * loginWithRedirect()
     * // Automatically redirects the user to TID with all necessary parameters
     * @example Custom redirect
     * loginWithRedirect({onRedirect: (url) => router.navigate(url)})
     * // Redirect calls onRedirect with the log-out url for TID
     * // So it can be handled by the developer
     */
    loginWithRedirect(options?: LoginWithRedirectOptions): Promise<void>;
    /**
     * Authenticated the user using the url callback params
     * @param {string} url - Custom configuration for the redirection
     * @return {Promise<AuthState>} Object contain the state returned from TID
     * @throws {CodeVerifierNotFoundException} Will throw an exception if the session doesn't contain the code verifier
     * @example No configuration
     * handleCallback()
     * // Will automatically take the url from the browser and try to log in the user
     * @example Custom url
     * handleCallback('https://example.com?code=code....')
     * // Will try to log in the user with the url assign by the developer
     */
    handleCallback(url?: string): Promise<AuthState>;
    /**
     * Function to generate and store the access token
     * @param {string} identityProvider - Type of identity provider used
     * @return {Promise<void>} Empty promise
     */
    private generateToken;
    private reloadCodeVerifier;
    /**
     * Return the user stored in cache
     * @return {Promise<TIDUser | undefined>} User in cache
     */
    getUser(): Promise<TIDUser | undefined>;
    /**
     * Gets the access token from cache. If the token already expired,
     * will try to refresh it using the refresh token
     * @return {Promise<string>} Access token
     * @throws {TokenNotFoundException} Will throw an exception if the access token is not in cache
     * @throws {TokenExpiredException} Will throw an exception if the user token expired
     */
    getAccessTokenSilently(): Promise<string>;
    /**
     * Retrieves token details from the cache, including the access token, ID token, and expiration time.
     * If the token already expired, will try to refresh it using the refresh token.
     * @return {Promise<TokenResponse>} Token response
     * @throws {TokenNotFoundException} Will throw an exception if there are no tokens in cache
     * @throws {TokenExpiredException} Will throw an exception if the user token expired
     */
    getTokens(): Promise<TokenResponse>;
    /**
     * Redirect the user to TID using the browser
     * @param {LogoutOptions} options - Custom configuration for teh redirection
     * @return {Promise<void>} Empty promise
     * @example No configuration
     * logout()
     * // Automatically redirects the user to TID to log out
     * @example Custom redirect
     * logout({onRedirect: (url) => router.navigate(url)})
     * // Redirect calls onRedirect with the log-out url for TID
     * // So it can be handled by the developer
     */
    logout(options?: LogoutOptions): Promise<void>;
    /**
     * Check if the user still has a valid session
     * @return {Promise<boolean>} True or false depending on if the user is session is valid or not
     */
    checkSession(): Promise<boolean>;
    /**
     * Check if the user has a session valid after a refresh
     * @return {Promise<void>} Empty promise
     */
    loadUserSession(): Promise<void>;
    /**
     * Load the user session from cache into the SDK
     * @return {Promise<void>} Empty promise
     */
    private loadCacheSessionIntoSDK;
    /**
     * Get a http bearer token client to use it for another SDK (Ex: Processing framework)
     * @return {any} - BearerTokenHttpClientProvider
     */
    getBearerTokenHttpClient(apiURL: string): typeof BearerTokenHttpClientProvider;
    /**
     * Get the redirect url to TID
     * @return {string} - Callback redirect url
     */
    getRedirectUrl(): string;
}
export {};