@azure/msal-angular 4.0.13 → 4.0.14

package/docs/msal-guard.md

@@ -1,208 +0,0 @@
-# MSAL Guard
-
-MSAL Angular provides `MsalGuard`, a class you can use to protect routes and require authentication before accessing the protected route. This doc provides more information about configuring and considerations when using the `MsalGuard`.
-
-`MsalGuard` is a convenience class you can use improve the user experience, but it should not be relied upon for security. Attackers can potentially get around client-side guards, and you should ensure that the server does not return any data the user should not access.
-
-You may also need a route guard that addresses specific needs. We encourage you to write your own guard if `MsalGuard` does not meet all those needs.
-
-## Configurations
-
-### Configuring the `MsalGuard` in the *app.module.ts* and *app-routing.module.ts*
-
-The `MsalGuard` can be added to your application as a provider in the *app.module.ts*, with its configuration. The imports takes in an instance of MSAL, as well as two Angular-specific configuration objects. The second argument is a [`MsalGuardConfiguration`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.guard.config.ts) object, which contain the values for `interactionType`, an optional `authRequest`, and an optional `loginFailedRoute`.
-
-The `MsalGuard` is then used to protect routes in the *app-routing.module.ts*. The code sample below demonstrates adding the `MsalGuard` to the `Profile` route. Protecting the `Profile` route means that even if a user does not sign in using the `Login` button, if they try to access the `Profile` route or click the `Profile` button, the `MsalGuard` will prompt the user to authenticate via popup or redirect before showing the `Profile` page.
-
-Your configuration may look like the below. See our [configuration doc](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/configuration.md) on other ways to configure MSAL Angular for your app, and the sections below for more details on the `MsalConfiguration` object and interfaces for routing.
-
-```javascript
-// app.module.ts
-import { NgModule } from '@angular/core';
-import { HTTP_INTERCEPTORS, HttpClientModule } from "@angular/common/http";
-import { MsalModule, MsalRedirectComponent, MsalGuard } from '@azure/msal-angular'; // Import MsalInterceptor
-import { InteractionType, PublicClientApplication } from '@azure/msal-browser';
-import { AppComponent } from './app.component';
-import { AppRoutingModule } from './app-routing.module';
-
-@NgModule({
-    declarations: [
-        AppComponent,
-    ],
-    imports: [
-        MsalModule.forRoot( new PublicClientApplication({
-            // MSAL Configuration
-        }), {
-            // MSAL Guard Configuration
-            interactionType: InteractionType.Redirect,
-            authRequest: {
-                scopes: ['user.read']
-            },
-            loginFailedRoute: '/login-failed'
-        }, {
-            // MSAL Interceptor Configurations
-        }),
-        AppRoutingModule
-    ],
-    providers: [
-        // ...
-        MsalGuard
-    ],
-    bootstrap: [AppComponent, MsalRedirectComponent]
-})
-export class AppModule { }
-```
-
-```javascript
-// app-routing.module.ts
-import { NgModule } from '@angular/core';
-import { Routes, RouterModule } from '@angular/router';
-import { HomeComponent } from './home/home.component';
-import { ProfileComponent } from './profile/profile.component';
-import { MsalGuard } from '@azure/msal-angular';
-
-const routes: Routes = [
-    {
-        path: 'profile',
-        component: ProfileComponent,
-        canActivate: [MsalGuard]
-    },
-    {
-        path: '',
-        component: HomeComponent
-    },
-];
-
-@NgModule({
-    imports: [RouterModule.forRoot(routes)],
-    exports: [RouterModule]
-})
-export class AppRoutingModule { }
-```
-
-### Interaction Type
-
-Setting the interaction type determines how the `MsalGuard` will interactively prompt for login. The `InteractionType` can be imported from `@azure/msal-browser` and set to `Popup` or `Redirect`.
-
-### Optional authRequest
-
-The optional `authRequest` is an advanced featured that is not required. However, we recommend setting `authRequest` on the `MsalGuardConfiguration` with `scopes` so that consent may be obtained for the scopes upfront. If consent for `scopes` are not consented to upfront, scopes can be obtained incrementally. This may result in a consent dialogue being presented to your app user multiple times.
-
-Consenting to scopes upfront is demonstrated in the code samples above, and in our [samples](https://github.com/AzureAD/microsoft-authentication-library-for-js/tree/dev/samples/msal-angular-samples).
-
-All possible parameters for the request object can be found here: [`PopupRequest`](https://azuread.github.io/microsoft-authentication-library-for-js/ref/msal-browser/modules/_src_request_popuprequest_.html) and [`RedirectRequest`](https://azuread.github.io/microsoft-authentication-library-for-js/ref/msal-browser/modules/_src_request_redirectrequest_.html).
-
-### Login Failed Route
-
-The `loginFailedRoute` string can be set on `MsalGuardConfiguration`. The `MsalGuard` will redirect to this route if login is required and fails.
-
-See the Angular sample for examples of implementing it in the [configuration](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/samples/msal-angular-samples/angular-modules-sample/src/app/app.module.ts#L66) and [app routing module](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/samples/msal-angular-samples/angular-modules-sample/src/app/app-routing.module.ts#L20). 
-
-Note that redirecting on failure is not available for Angular 9 applications that use the `CanLoad` interface due to base type differences.
-
-### Interfaces
-
-In addition to `canActivate`, `MsalGuard` also implements `canActivateChild` and `canLoad`, and these can be added to your route definitions in *app-routing.module.ts*. You can see these used in our [older MSAL Angular v2 Angular 11 sample application](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/msal-lts/samples/msal-angular-v2-samples/angular11-sample-app/src/app/app-routing.module.ts), as well as below. For more information on interfaces, see the [Angular docs](https://angular.io/api/router).
-
-```js
-const routes: Routes = [
-    {
-        path: 'profile',
-        canActivateChild: [MsalGuard],
-        children: [
-        {
-            path: '',
-            component: ProfileComponent
-        },
-        {
-            path: 'detail',
-            component: DetailComponent
-        }
-        ]
-    },
-    { 
-        path: 'lazyLoad', 
-        loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule),
-        canLoad: [MsalGuard]
-    },
-];
-```
-
-## Considerations when using the MSAL Guard
-
-### Using the MSAL Guard on the home page
-
-Setting the `MsalGuard` on the initial page is our recommendation if you want users to be prompted to log in when they reach your application. We do not recommend calling `login` in the `ngOnInit` in `app.component.ts`, as this can cause looping with redirects.
-
-Our additional recommendations depend on your routing strategy, and can be found in the sections below.
-
-### Using the MSAL Guard with path routing
-
-When using the `PathLocationStrategy` and redirects with your Angular app, we recommend using a dedicated route for redirects, which will help prevent looping. This route should also be your `redirectUri`, and should not be protected by the `MsalGuard`. 
-
-```javascript
-const routes: Routes = [
-    {
-        path: 'profile',
-        component: ProfileComponent,
-        canActivate: [MsalGuard]
-    },
-    {
-        // Dedicated route for redirects
-        path: 'auth', 
-        component: MsalRedirectComponent
-    },
-    {
-        path: '',
-        component: HomeComponent
-    }
-];
-```
-
-To log users in upon reaching your app, when using the `PathLocationStrategy`, we recommend:
-- Setting the `MsalGuard` on your initial page
-- Set your `redirectUri` to `'http://localhost:4200/auth'`
-- Adding an `'auth'` path to your routes, setting the `MsalRedirectComponent` as the component (this route should not be protected by the `MsalGuard`)
-- Making sure the `MsalRedirectComponent` is bootstrapped
-- Optionally: adding `MsalGuard` to all your routes if you want all your routes protected
-
-Our [Angular 15 sample](https://github.com/AzureAD/microsoft-authentication-library-for-js/tree/dev/samples/msal-angular-samples/angular-modules-sample) uses the `PathLocationStrategy` and demonstrates how to protect routes with the `MsalGuard`.
-
-### Using the MSAL Guard with hash routing
-
-When using the `HashLocationStrategy` with your Angular app, we strongly recommend setting placeholder routes (such as `/code`) in your *app-routing.module.ts* to prevent triggering the Angular router when AAD returns the auth code response in the hash, as you may experience issues completing authentication without doing so. These placeholder routes should not be protected by the `MsalGuard`, and should not point to a component that triggers interaction or makes protected API calls on page load.
-
-```javascript
-const routes: Routes = [
-  {
-    path: 'profile',
-    component: ProfileComponent,
-    canActivate: [MsalGuard]
-  },
-  {
-    // Needed for hash routing
-    path: 'code',
-    component: HomeComponent
-  },
-  {
-    path: '',
-    component: HomeComponent
-  }
-];
-```
-
-The `redirectUri` in the MSAL Configuration should also be set to the home page.
-
-To log users in upon reaching your app, when using the `HashLocationStrategy`, we recommend:
-- Setting the `MsalGuard` on your initial page
-- Not setting the `MsalGuard` on placeholder routes (e.g. `/code`, `/error`)
-- Making sure the `MsalRedirectComponent` is bootstrapped
-- Optionally: adding `MsalGuard` to all the rest of your routes if you want all your routes protected
-
-See our [older MSAL Angular v2 Angular 11 sample](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/msal-lts/samples/msal-angular-v2-samples/angular11-sample-app/src/app/app-routing.module.ts), which uses the `HashLocationStrategy` and demonstrates how to protect routes with `MsalGuard`.
-
-## Changes from msal-angular v1 to v2
-
-* **Configuration**: `MsalAngularConfiguration` has been deprecated and no longer works. Configuring the `MsalGuard` is now done through the `MsalGuardConfiguration`.
-* **Interfaces**: `MsalGuard` now implements `CanActivateChild` and `CanLoad` in addition to `CanActivate`. See the section above on `Interfaces` for more details.
-* **Redirect on failure**: `MsalGuard` configuration now has a `loginFailedRoute` that can be configured. See the section above on the `loginFailedRoute` for details.

package/docs/msal-interceptor.md

@@ -1,160 +0,0 @@
-# MSAL Interceptor
-
-MSAL Angular provides an `Interceptor` class that automatically acquires tokens for outgoing requests that use the Angular `http` client to known protected resources. This doc provides more information about the configuring and using the `MsalInterceptor`.
-
-While we recommend using the `MsalInterceptor` instead of the `acquireTokenSilent` API directly, please note that using the `MsalInterceptor` is optional. You may wish to explicitly acquire tokens using the acquireToken APIs instead.
-
-Please note that the `MsalInterceptor` is provided for your convenience and may not fit all use cases. We encourage you to write your own interceptor if you have specific needs that are not addressed by the `MsalInterceptor`. 
-
-## Configuration
-
-### Configuring the `MsalInterceptor` in the *app.module.ts*
-
-The `MsalInterceptor` can be added to your application as a provider in the *app.module.ts*, with its configuration. The imports takes in an instance of MSAL, as well as two Angular-specific configuration objects. The third argument is a [`MsalInterceptorConfiguration`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.interceptor.config.ts) object, which contain the values for `interactionType`, a `protectedResourceMap`, and an optional `authRequest`.
-
-Your configuration may look like the below. See our [configuration doc](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/configuration.md) on other ways to configure MSAL Angular for your app. 
-
-```javascript
-import { NgModule } from '@angular/core';
-import { HTTP_INTERCEPTORS, HttpClientModule } from "@angular/common/http";
-import { AppComponent } from './app.component';
-import { MsalModule, MsalRedirectComponent, MsalGuard, MsalInterceptor } from '@azure/msal-angular'; // Import MsalInterceptor
-import { InteractionType, PublicClientApplication } from '@azure/msal-browser';
-
-@NgModule({
-    declarations: [
-        AppComponent,
-    ],
-    imports: [
-        MsalModule.forRoot( new PublicClientApplication({
-            // MSAL Configuration
-        }), {
-            // MSAL Guard Configuration
-        }, {
-            // MSAL Interceptor Configurations
-            interactionType: InteractionType.Redirect,
-            protectedResourceMap: new Map([ 
-                ['Enter_the_Graph_Endpoint_Here/v1.0/me', ['user.read']]
-            ])
-        })
-    ],
-    providers: [
-        {
-            provide: HTTP_INTERCEPTORS, // Provides as HTTP Interceptor
-            useClass: MsalInterceptor,
-            multi: true
-        },
-        MsalGuard
-    ],
-    bootstrap: [AppComponent, MsalRedirectComponent]
-})
-export class AppModule { }
-```
-
-### Interaction Type
-
-While the `MsalInterceptor` is designed to acquire tokens silently, in the event that a silent request fails, it will fall back to acquiring tokens interactively. The `InteractionType` can be imported from `@azure/msal-browser` and set to `Popup` or `Redirect`.
-
-```javascript
-{
-    interactionType: InteractionType.Redirect,
-    protectedResourceMap: new Map([ 
-        ['Enter_the_Graph_Endpoint_Here/v1.0/me', ['user.read']]
-    ])
-}
-```
-
-### Protected Resource Map
-
-The protected resources and corresponding scopes are provided as a `protectedResourceMap` in the `MsalInterceptor` configuration. 
-
-The URLs you provide in the `protectedResourceMap` collection are case-sensitive. For each resource, add scopes being requested to be returned in the access token.
-
-For example:
-
-* `["user.read"]` for Microsoft Graph
-* `["<Application ID URL>/scope"]` for custom web APIs (that is, `api://<Application ID>/access_as_user`)
-
-
-Scopes can be specified for a resource in the following ways:
-
-1. An array of scopes, which will be added to every HTTP request to that resource, regardless of HTTP method.
-
-    ```javascript
-    {
-        interactionType: InteractionType.Redirect,
-        protectedResourceMap: new Map<string, Array<string> | null>([
-            ["https://graph.microsoft.com/v1.0/me", ["user.read", "profile"]],
-            ["https://myapplication.com/user/*", ["customscope.read"]]
-        ]),
-    }
-    ```
-
-1. An array of `ProtectedResourceScopes`, which will attach scopes only for specific HTTP methods. 
-
-    ```javascript
-    {
-        interactionType: InteractionType.Redirect,
-        protectedResourceMap: new Map<string, Array<string|ProtectedResourceScopes> | null>([
-            ["https://graph.microsoft.com/v1.0/me", ["user.read"]],
-            ["http://myapplication.com", [
-                {
-                    httpMethod: "POST",
-                    scopes: ["write.scope"]
-                }
-            ]]
-        ])
-    }
-    ```
-
-    Note that scopes for a resource can contain a combination of strings and `ProtectedResourceScopes`. In the below example, a `GET` request will have the scopes `"all.scope"` and `"read.scope"`, whereas as `PUT` request would just have `"all.scope"`.
-
-    ```javascript
-    {
-        interactionType: InteractionType.Redirect,
-        protectedResourceMap: new Map<string, Array<string|ProtectedResourceScopes> | null>([
-            ["http://myapplication.com", [
-                "all.scope",
-                {
-                    httpMethod: "GET",
-                    scopes: ["read.scope"]
-                },
-                {
-                    httpMethod: "POST",
-                    scopes: ["info.scope"]
-                }
-            ]]
-        ])
-    }
-    ```
-
-1. A scope value of `null`, indicating that a resource is to be unprotected and will not get tokens. Resources not included in the `protectedResourceMap` are not protected by default. Specifying a particular resource to be unprotected can be useful when some routes on a resource are to be protected, and some are not. Note that the order in `protectedResourceMap` matters, so null resource should be put before any similar base urls or wildcards.
-
-    ```javascript
-    {
-        interactionType: InteractionType.Redirect,
-        protectedResourceMap: new Map<string, Array<string> | null>([
-            ["https://graph.microsoft.com/v1.0/me", ["user.read", "profile"]],
-            ["https://myapplication.com/unprotected", null],
-            ["https://myapplication.com/unprotected/post", [{ httpMethod: 'POST', scopes: null }]],
-            ["https://myapplication.com", ["custom.scope"]]
-        ]),
-    }
-    ```
-
-Other things to note regarding the `protectedResourceMap`:
-
-* **Wildcards**: `protectedResourceMap` supports using `*` for wildcards. When using wildcards, if multiple matching entries are found in the `protectedResourceMap`, the first match found will be used (based on the order of the `protectedResourceMap`). 
-* **Relative paths**: If there are relative resource paths in your application, you may need to provide the relative path in the `protectedResourceMap`. This also applies to issues that may arise with ngx-translate. Be aware that the relative path in your `protectedResourceMap` may or may not need a leading slash depending on your app, and may need to try both.
-
-### Optional authRequest
-
-For more information on the optional `authRequest` that can be set in the `MsalInterceptorConfiguration`, please see our [multi-tenant doc here](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/multi-tenant.md#dynamic-auth-request).
-
-## Changes from msal-angular v1 to v2
-
-* Note that the `unprotectedResourceMap` in MSAL Angular v1's `MsalAngularConfiguration` has been deprecated and no longer works.
-* `protectedResourceMap` has been moved to the `MsalInterceptorConfiguration` object, and can be passed as `Map<string, Array<string|ProtectedResourceScopes>>`. `MsalAngularConfiguration` has been deprecated and no longer works.
-* Putting the root domain in the `protectedResourceMap` to protect all routes is no longer supported. Please use wildcard matching instead.
-
-For more information on how to configure scopes, please see our [FAQs](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/FAQ.md). 

package/docs/multi-tenant.md

@@ -1,90 +0,0 @@
-# Multi-Tenant
-
-By default, there is multi-tenant support for your application since MSAL sets the tenant in the authority to 'common' if it is not specified in the config. This allows any Microsoft account to authenticate to your application. If you are not interested in multi-tenant behavior, you will need to set the `authority` config property when instantiating MSAL in the `app.module.ts` as shown below.
-
-```js
-@NgModule({
-  imports: [
-    MsalModule.forRoot({ // MSAL Configuration
-      auth: {
-        clientId: 'CLIENT_ID_HERE',
-        authority: 'https://login.microsoftonline.com/TENANT_ID_HERE',
-        redirectUri: 'http://localhost:4200',
-        postLogoutRedirectUri: 'http://localhost:4200'
-      },
-      // Additional configuration here
-    });
-  ]
-})
-export class AppModule {}
-```
-
-If you allow multi-tenant authentication, and you do not wish to allow all Microsoft account users to use your application, you must provide your own method of filtering the token issuers to only those tenants who are allowed to login.
-
-## Changing the tenant
-The tenant can also be set dynamically by instantiating a new instance of MSAL in the relevant component, as shown below.
-
-```js
-import { PublicClientApplication } from '@azure/msal-browser';
-import { MsalService } from '@azure/msal-angular';
-
-@Component({})
-export class AppComponent implements OnInit {
-  constructor(
-    private authService: MsalService
-  ) {}
-
-  ngOnInit(): void {
-    this.authService.instance = new PublicClientApplication({
-      auth: {
-        clientId: 'CLIENT_ID_HERE',
-        authority: 'https://login.microsoftonline.com/TENANT_ID_HERE',
-        redirectUri: 'http://localhost:4200',
-        postLogoutRedirectUri: 'http://localhost:4200'
-      }
-    });
-  }
-```
-
-## Dynamic auth request
-
-By default the MsalGuard and the MsalInterceptor use the static properties set in the config. Both can also be configured with a method for the `authRequest`, allowing the parameters used for authentication to be changed dynamically.
-
-### MsalInterceptor - dynamic auth request (multi tenant tokens)
-
-If `organizations` or `common` is used as the tenant, all tokens will be requested for the users' home tenant. However, this may not be the desired outcome. If a user is invited as a guest, the tokens may be from the wrong authority.
-
-Setting the `authRequest` in the **MsalInterceptorConfig** to a method allows you to dynamically change the auth request. For instance, you may set the authority based on the home tenant of the account when using guest users.
-Properties on `authRequest` may be changed, but should always extend the `originalAuthRequest` like below:
-
-```js
-export function MSALInterceptorConfigFactory(): MsalInterceptorConfiguration {
-  const protectedResourceMap = new Map<string, Array<string>>();
-  protectedResourceMap.set("https://graph.microsoft.com/v1.0/me", ["user.read"]);
-  
-  return {
-    interactionType: InteractionType.Popup,
-    protectedResourceMap,
-    authRequest: (msalService, httpReq, originalAuthRequest) => {
-      return {
-        ...originalAuthRequest,
-        authority: `https://login.microsoftonline.com/${originalAuthRequest.account?.tenantId ?? 'organizations'}`
-      };
-    }
-  };
-}
-...
-
-@NgModule({
-  declarations: [...],
-  imports: [...],
-  providers: [
-    ...
-    {
-      provide: MSAL_INTERCEPTOR_CONFIG,
-      useFactory: MSALInterceptorConfigFactory
-    }
-  ]
-});
-
-```

package/docs/performance.md

@@ -1,50 +0,0 @@
-# Performance
-
-## How to configure `@azure/msal-angular` to use your router's navigate function for client-side navigation
-
-By default, when MSAL.js needs to navigate from one page in your application to another it will reassign `window.location`, causing a full frame redirect to the other page and causing your application to re-render. If you're using the Angular Router this may be undesireable since the Router enables "client-side" navigation and shows or hides only the parts of the page as necessary.
-
-Currently there is one scenario where MSAL.js will navigate from one page in your application to another. If your application is doing **all** of the following things, continue reading:
-
-- Your application is using the redirect flow, instead of the popup flow, to login
-- `PublicClientApplication` is configured with `auth.navigateToLoginRequestUrl: true` (default)
-- Your application has pages that may call `loginRedirect`/`acquireTokenRedirect` with a shared `redirectUri` i.e. You call `loginRedirect` from `http://localhost/protected` with a redirectUri of `http://localhost`
-
-If your application is doing all of the things above you can override the method MSAL uses to navigate by importing the `MsalCustomNavigationClient` and calling `setNavigationClient`.
-
-**NOTE**: Due to a security fix, the `MsalCustomNavigationClient` will not be using the Angular `Router` to navigate client-side when `navigateToLoginRequestUrl` is set to true and handling redirects. This is a known issue that will be addressed in a future release.
-
-### Example Implementation
-
-The example below will show how to implement this when using the Angular `Router`. More information on the Angular Router can be found [here](https://angular.io/guide/router), and you can find a full sample app that implements this for [Angular here](https://github.com/AzureAD/microsoft-authentication-library-for-js/tree/msal-lts/samples/msal-angular-v2-samples/angular10-sample-app).
-
-```javascript
-import { Component, OnInit, Inject } from '@angular/core';
-import { Router } from '@angular/router';
-import { Location } from '@angular/common';
-import { MsalService, MsalBroadcastService, MSAL_GUARD_CONFIG, MsalGuardConfiguration, MsalCustomNavigationClient } from '@azure/msal-angular';
-
-@Component({
-  selector: 'app-root',
-  templateUrl: './app.component.html',
-  styleUrls: ['./app.component.css']
-})
-export class AppComponent implements OnInit, OnDestroy {
-
-  constructor(
-    @Inject(MSAL_GUARD_CONFIG) private msalGuardConfig: MsalGuardConfiguration,
-    private authService: MsalService,
-    private msalBroadcastService: MsalBroadcastService,
-    private router: Router,
-    private location: Location
-  ) {
-    const customNavigationClient = new MsalCustomNavigationClient(this.authService, this.router, this.location);
-    this.authService.instance.setNavigationClient(customNavigationClient);
-  }
-
-  ngOnInit(): void {
-    // Additional code
-  }
-}
-
-```

package/docs/public-apis.md

@@ -1,29 +0,0 @@
-# Public APIs for MSAL Angular
-
-Before you start here, make sure you understand how to [initialize the application object](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/initialization.md).
-
-The login APIs in MSAL retrieve an `authorization code` which can be exchanged for an [ID token](https://docs.microsoft.com/azure/active-directory/develop/id-tokens) for a signed in user, while consenting scopes for an additional resource, and an [access token](https://docs.microsoft.com/azure/active-directory/develop/access-tokens) containing the user consented scopes to allow your app to securely call the API.
-
-You can read more about ID tokens on our [Azure Docs pages](https://docs.microsoft.com/azure/active-directory/develop/id-tokens).
-
-## Public APIs
-
-`@azure/msal-angular` exposes the following, along with their configurations. See the [library references](https://azuread.github.io/microsoft-authentication-library-for-js/ref/modules/_azure_msal_angular.html) for properties and methods.  
-
-1. [`MsalService`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.service.ts/)
-1. [`MsalGuard`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.guard.ts/)
-    * [`MsalGuardConfiguration`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.guard.config.ts/)
-1. [`MsalInterceptor`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.interceptor.ts/)
-    * [`MsalInterceptorConfiguration`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.interceptor.config.ts/)
-1. [`MsalBroadcastService`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.broadcast.service.ts/)
-1. [`MsalModule`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.module.ts/)
-
-
-The login and acquire token functions using Angular observables are found on the [IMsalService](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/IMsalService.ts/).
-
-`@azure/msal-angular` also exposes the following:
-
-1. [`MsalRedirectComponent`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.redirect.component.ts): Used for handling redirects. See the [redirect doc](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/redirects.md) for more details.
-1. [`MsalCustomNavigationClient`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/src/msal.navigation.client.ts): Used for client-side navigation. See the [performance doc](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-angular/docs/performance.md) for more details.
-
-Additional functions from `@azure/msal-browser` are found on [`IPublicClientApplication`](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/src/app/IPublicClientApplication.ts), with corresponding documentation [here](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/login-user.md).