/**
 * Logs that a page or other item was viewed. 
 * @param IPageViewTelemetry The string you used as the name in startTrackPage. Defaults to the  document title.
 * @param customProperties Additional data used to filter events and metrics. Defaults to empty.
 */
applicationInsights.trackPageView(pageView: IPageViewTelemetry, customProperties?: { [key: string]: any })

interface IPageViewTelemetry {
    /*
     * name String - The string you used as the name in startTrackPage.
     * Defaults to the document title.
     */
    name?: string;

    /*
     * uri  String - a relative or absolute URL that identifies the page or other item.
     * Defaults to the window location.
     */
    uri?: string;

    /*
     * refUri  String - the URL of the source page where current page is loaded from
     */
    refUri?: string;

    /*
     * pageType  String - page type
     */
    pageType?: string;

    /*
     * isLoggedIn - boolean is user logged in
     */
    isLoggedIn?: boolean;

    /*
     * property bag to contain an extension to domain properties - extension to Part B
     */
    pageTags?: { [key: string]: any };
}

startTrackPage(name?: string)

stopTrackPage(name?: string, url?: string, customProperties?: { [name: string]: any; });

trackMetric(metric: IMetricTelemetry, customProperties?: {[name: string]: any})

trackException(exception: IExceptionTelemtry, customProperties?: {[key: string]: any})

})({
    instrumentationKey: "your instrumentation key",

    extensionConfig: {
        ApplicationInsightsAnalytics: {
            disableExceptionTracking: true
        }
    }
});

trackTrace(trace: ITraceTelemetry, customProperties?: {[key: string]: any})

core.track(envelope: ITelemetryItem);

interface ITelemetryItem {
    /**
     * Unique name of the telemetry item
     */ 
    name: string;

    /**
     * Timestamp when item was sent
     */ 
    timestamp?: Date;

    /**
     * Identifier of the resource that uniquely identifies which resource data is sent to
     */ 
    instrumentationKey?: string;

    /**
     * System properties with well defined extensions, documentation coming soon 
     */ 
    ctx?: {[key: string]: any};

    /**
     * Part A custom extensions
     */
    tags?: Tags[];

    /**
     * Telemetry type used for part B
     */
    baseType?: string;

    /**
     * Based on schema for part B
     */ 
    baseData?: { [key: string]: any };
    
    /**
     * Telemetry data used for Part C
     */
    data?: {
        [key: string]: any;
    },
}

trackDependencyData(dependency: IDependencyTelemetry, customProperties?: {[key: string]: any}, systemProperties?: {[key: string]: any})

flush()

setAuthenticatedUserContext(authenticatedUserId: string, accountId?: string, storeInCookie = false)

clearAuthenticatedUserContext ()

config: IConfig

interface IConfiguration {

    /**
    * Instrumentation key of resource
    */
    instrumentationKey: string; // todo: update later for multi-tenant?

    /**
     * Polling interval (in ms) for internal logging queue
     */
    diagnosticLoggingInterval?: number;

    /**
     * Maximum number of iKey transmitted logging telemetry per page view
     */
    maxMessageLimit?: number;

    /**
     * Console logging level. All logs with a severity level higher
     * than the configured level will be printed to console. Otherwise 
     * they are suppressed. ie Level 2 will print both CRITICAL and
     * WARNING logs to console, level 1 prints only CRITICAL.
     * 
     * Note: Logs sent as telemetry to instrumentation key will also 
     * be logged to console if their severity meets the configured loggingConsoleLevel
     * 
     * 0: ALL console logging off
     * 1: logs to console: severity >= CRITICAL
     * 2: logs to console: severity >= WARNING
     */
    loggingLevelConsole?: number;

    /**
     * Telemtry logging level to instrumentation key. All logs with a severity
     * level higher than the configured level will sent as telemetry data to
     * the configured instrumentation key.
     * 
     * 0: ALL iKey logging off
     * 1: logs to iKey: severity >= CRITICAL
     * 2: logs to iKey: severity >= WARNING
     */
    loggingLevelTelemetry?: number

    /**
     * If enabled, uncaught exceptions will be thrown to help with debugging
     */
    enableDebugExceptions?: boolean;
    
    /**
    * Endpoint where telemetry data is sent
    */
    endpointUrl?: string;

    /**
    * Extension configs loaded in SDK
    */
    extensionConfig?: { [key: string]: any }; // extension configs;

    /**
     * Additional extensions that should be loaded by core at runtime
     */
    extensions?: ITelemetryPlugin[];

    /**
     * Custom channel queues for use with sending data to multiple channels in parallel
     */
    channels?: Array<IChannelControls[]>;
}

config: IConfig

interface IConfiguration {

    /**
    * Instrumentation key of resource
    */
    instrumentationKey: string; // todo: update later for multi-tenant?

    /**
     * Polling interval (in ms) for internal logging queue
     */
    diagnosticLoggingInterval?: number;

    /**
     * Maximum number of iKey transmitted logging telemetry per page view
     */
    maxMessageLimit?: number;

    /**
     * Console logging level. All logs with a severity level higher
     * than the configured level will be printed to console. Otherwise 
     * they are suppressed. ie Level 2 will print both CRITICAL and
     * WARNING logs to console, level 1 prints only CRITICAL.
     * 
     * Note: Logs sent as telemetry to instrumentation key will also 
     * be logged to console if their severity meets the configured loggingConsoleLevel
     * 
     * 0: ALL console logging off
     * 1: logs to console: severity >= CRITICAL
     * 2: logs to console: severity >= WARNING
     */
    loggingLevelConsole?: number;

    /**
     * Telemtry logging level to instrumentation key. All logs with a severity
     * level higher than the configured level will sent as telemetry data to
     * the configured instrumentation key.
     * 
     * 0: ALL iKey logging off
     * 1: logs to iKey: severity >= CRITICAL
     * 2: logs to iKey: severity >= WARNING
     */
    loggingLevelTelemetry?: number

    /**
     * If enabled, uncaught exceptions will be thrown to help with debugging
     */
    enableDebugExceptions?: boolean;
    
    /**
    * Endpoint where telemetry data is sent
    */
    endpointUrl?: string;

    /**
    * Extension configs loaded in SDK
    */
    extensionConfig?: { [key: string]: any }; // extension configs;

    /**
     * Additional extensions that should be loaded by core at runtime
     */
    extensions?: ITelemetryPlugin[];

    /**
     * Custom channel queues for use with sending data to multiple channels in parallel
     */
    channels?: Array<IChannelControls[]>;
}

})({
    instrumentationKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
});

appInsights.config.instrumentationKey = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx';

var init = new Initialization({
    config: {
        instrumentationKey: 'YOUR INSTRUMENTATION KEY',
        extensionConfig: {
            'AppInsightsChannelPlugin': {
                maxBatchInterval: 5000
            }
        }
    }
});
this._ai = init.loadAppInsights();

interface IConfig {
    accountId: string;

    // A session is logged if the user is inactive for this time in milliseconds. Default 30 mins.
    sessionRenewalMs: number; 

    // A session is logged if it has continued for this time in milliseconds. Default 24h.
    sessionExpirationMs: number;

    // Default 100k
    maxBatchSizeInBytes: number;

    // Default 15s
    maxBatchInterval: number;

    // If true, debugging data is thrown as an exception by the logger. Default false.
    enableDebug: boolean;

    // If true, telemetry data is not collected or sent. Default false.
    disableTelemetry: boolean; 

    // If true, the SDK will log all internal errors (any severity) to the console. Default false
    verboseLogging: boolean;

    // Controls what percentage of events will be sent
    // Default 100. 
    samplingPercentage: number;

    // Default 10s
    diagnosticLogInterval: number;

    // If true, exceptions are not monitored. 
    disableExceptionTracking: boolean;

    // If true, ajax calls are not monitored.
    disableAjaxTracking: boolean;

    // If true, default behavior of trackPageView is changed to record end of page view duration interval when 
    // trackPageView is called. If false and no custom duration is provided to trackPageView, the page view
    // performance is calculated using the navigation timing API.
    overridePageViewDuration: boolean;

    // Default 500 - controls how many ajax calls will be monitored per page view.
    // Set to -1 to monitor all ajax calls on the page.
    maxAjaxCallsPerView: number;

    // If true, the SDK will not store or read any data from cookies.
    // Default: false
    isCookieUseDisabled: boolean;

    // Custom cookie domain. This is helpful if you want to share Application Insights cookies across subdomains.
    cookieDomain: string;

    // Default false. If true, flush method will not be called when onBeforeUnload event triggers.
    disableFlushOnBeforeUnload: boolean;

    // If true, the buffer with all unsent telemetry is stored in a session storage. The buffer is restored on page load.
    // The feature is enable by default starting with v0.23.0. 
    enableSessionStorageBuffer: boolean;

    // Is retry handler disabled. Default false.
    // If enabled, retry on 206 (partial success), 408 (timeout), 429 (too many requests), 500 (internal server error) and 503 (service unavailable).
    isRetryDisabled: boolean;

    // The url from where the JS SDK will be downloaded. 
    // Default 'https://az416426.vo.msecnd.net/scripts/a/ai.0.js'
    url: string;

    // If true, the SDK will not store or read any data from local and session storage.
    // Default: false
    isStorageUseDisabled: boolean;

    // If false, the SDK will add two headers ('Request-Id' and 'Request-Context') to all 
    // dependency requests to correlate them with corresponding requests on the server side.
    // Default false. 
    disableCorrelationHeaders: boolean;

    // If true, the SDK will send all telemetry using [Beacon API](https://www.w3.org/TR/beacon/)
    // When Beacon API is enabled, then SessionStorageBuffer cannot be used and maxBatchSizeInBytes is limit too 64kb
    // Default: true
    isBeaconApiDisabled: boolean;

    // Sets the sdk extension name. Only alphabetic characters are allowed. 
    // The extension name is added as a prefix to 'ai.internal.sdkVersion' tag (for instance 'ext_javascript:1.0.5')
    // Default: null
    sdkExtension: string;

    // If true, the SDK will track all [Browser Link](https://docs.microsoft.com/en-us/aspnet/core/client-side/using-browserlink) requests. 
    // Default: false
    isBrowserLinkTrackingEnabled: boolean;

    // If true, the SDK will add two headers ('Request-Id' and 'Request-Context') to all 
    // CORS requests to correlate outgoing AJAX dependencies with corresponding requests on the server side.
    // Default false. 
    enableCorsCorrelation: boolean;
}

application: Context.Application

 context.application.ver: string
 context.application.build : string

device : Context.Device

user: Context.User

session: Context.Session

location: Context.Location

operation: Context.Operation;

public addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void)

interface ITelemetryPlugin {
    /**
    * Call back for telemetry processing before it is sent to next plugin for processing (needs to be invoked by caller)
    */
    processTelemetry: (env: ITelemetryItem) => void;

    /**
    * Extension name
    */
    identifier: string;

    /**
    * Set next extension for telemetry processing
    */
    setNextPlugin: (next: ITelemetryPlugin) => void;

    /**
    * Priority of the extension
    *
    * 1 - 100: customer plugins
    * 100 � 199: reserved for internal plugins.
    * > 200: channel plugins (that implement IChannelControls to send data to an endpoint)
    */
    priority: number;
}