Angular Documentation

Main Page

Blocks

@defer
@for
@if
@switch

Classs

Constants

Decorators

Attribute
Component
ContentChild
ContentChildren
Directive
Host
HostBinding
HostListener
Injectable
Input
NgModule
Optional
Output
Pipe
Self
SkipSelf
ViewChild
ViewChildren

Directives

Elements

<ng-container>
<ng-content>
<ng-template>

Enums

AfterRenderPhase
AnimationMetadataType
ChangeDetectionStrategy
DeferBlockBehavior
DeferBlockState
EventType
FormStyle
FormatWidth
HttpEventType
HttpFeatureKind
HttpStatusCode
HydrationFeatureKind
InjectFlags
MissingTranslationStrategy
NavigationCancellationCode
NavigationSkippedCode
NumberFormatStyle
NumberSymbol
Plural
RendererStyleFlags2
SecurityContext
TranslationWidth
ViewEncapsulation
WeekDay

Functions

Globals

$localize
ng.applyChanges
ng.getComponent
ng.getContext
ng.getDirectiveMetadata
ng.getDirectives
ng.getHostElement
ng.getInjector
ng.getListeners
ng.getOwningComponent
ng.getRootComponents

Guides

AOT metadata errors
Accessibility in Angular
Add the localize package
Ahead-of-time (AOT) compilation
Angular CLI builders
Angular Internationalization
Angular Language Service
Angular Roadmap
Angular Routing
Angular Signals
Angular change detection and runtime optimization
Angular coding style guide
Angular compiler options
Angular components overview
Angular developer guides
Angular documentation localization guidelines
Angular documentation style guide
Angular elements overview
Angular package format
Angular service worker introduction
Angular versioning and releases
Angular workspace configuration
AngularJS to Angular concepts: Quick reference
Animation transitions and triggers
App shell
Attribute binding
Attribute directives
Authoring schematics
Background processing using web workers
Basics of testing components
Binding syntax
Browser support
Build and test a documentation update
Building a template-driven form
Building and serving Angular apps
Building dynamic forms
Built-in control flow
Built-in directives
Cheat Sheet
Class and style binding
Common Internationalization tasks
Common Routing Tasks
Complex animation sequences
Component Lifecycle
Component interaction
Component styles
Component testing scenarios
Configuring dependency providers
Content projection
Creating an injectable service
Creating libraries
Debugging tests
Deferrable Views
Dependency injection in Angular
Dependency injection in action
Deploy multiple locales
Deployment
Deprecated APIs and features
DevTools Overview
Directive composition API
Displaying values with interpolation
Documentation contributors guide
Dynamic component loader
Event binding
Example Angular Internationalization application
Example applications
Feature modules
Find out how much code you're testing
Finish up a documentation pull request
Format data based on locale
Frequently-used modules
Generating code using schematics
Getting started with NgOptimizedImage
Getting started with service workers
Getting started with standalone components
Getting started with the Angular CLI's new build system
Glossary
Guidelines for creating NgModules
HTTP - Configure URL parameters
HTTP - Intercept requests and responses
HTTP - Optimize server interaction with debouncing
HTTP - Pass metadata to interceptors
HTTP - Track and show request progress
HTTP - interceptor use-cases
HTTP client - Handle request errors
HTTP client - Security: Cross-Site Request Forgery (XSRF) protection
HTTP client - Test requests
HTTP: Make a JSONP request
HTTP: Request data from a server
HTTP: Send data to a server
HTTP: Setup for server communication
Hierarchical injectors
How event binding works
Hydration
Import global variants of the locale data
Injection context
Introduction to Angular animations
Introduction to Angular concepts
Introduction to components and templates
Introduction to forms in Angular
Introduction to services and dependency injection
JavaScript modules vs. NgModules
Keeping your Angular projects up-to-date
Launching your app with a root module
Lazy-loading feature modules
Localized documentation
Make and save changes to a documentation topic
Manage marked text with custom IDs
Merge translations into the application
Migrate an existing Angular project to standalone
ModuleWithProviders Migration
Navigate the component tree with DI
Next steps: tools and techniques
NgModule API
NgModule FAQ
NgModules
NgZone
Observables compared to other techniques
Observables in Angular
Open a documentation pull request
Optimizing client application size with lightweight injection tokens
Optional Internationalization practices
Overview of Angular documentation editorial workflow
Overview of Angular libraries
Overview of documentation maintenance tasks
Pipe precedence in template expressions
Practical observable usage
Prepare a documentation update for a pull request
Prepare component for translation
Prepare to edit Angular documentation
Prerendering (SSG)
Property binding
Property binding best practices
Providing dependencies in modules
Reactive forms
Refer to locales by ID
Resolve documentation linter messages
Resolving zone pollution
Reusable animations
Review documentation
Route transition animations
Router reference
Router tutorial: tour of heroes
RxJS Interop
SVG as templates
Schematics for libraries
Security
Select a documentation issue
Server-side rendering
Service worker communication
Service worker configuration
Service worker in production
Service worker notifications
Setting up the local environment and workspace
Setup for upgrading from AngularJS
Sharing data between child and parent directives and components
Sharing modules
Singleton services
Skipping component subtrees
Slow computations
Start to edit a documentation topic
Static query migration guide
Strict mode
Structural directives
Style Precedence
Template expression operators
Template statements
Template syntax
Template type checking
Testing
Testing Attribute Directives
Testing Pipes
Testing Utility APIs
Testing services
The RxJS library
Transforming Data Using Pipes
Transforming data with parameters and chained pipes
Tutorial: Creating custom route matches
Two-way binding
TypeScript configuration
Typed Forms
Understanding Angular
Understanding Pipes
Understanding binding
Understanding communicating with backend services using HTTP
Understanding dependency injection
Understanding template expressions
Understanding template variables
Understanding templates
Update Angular to v14
Update Angular to v15
Update Angular to v16
Update a documentation pull request
Update search keywords
Upgrading for performance
Upgrading from AngularJS to Angular
Usage of Angular libraries published to npm
User input
Using Angular routes in a single-page application
Using a pipe in a template
Using observables for streams of values
Validating form input
Version compatibility
View encapsulation
What is Angular?
Work with translation files
Workspace and project file structure
Workspace npm dependencies

Interfaces

Methods

$locationShim.$$parse
$locationShim.$$parseLinkUrl
$locationShim.absUrl
$locationShim.constructor
$locationShim.hash
$locationShim.host
$locationShim.onChange
$locationShim.path
$locationShim.port
$locationShim.protocol
$locationShim.replace
$locationShim.search
$locationShim.state
$locationShim.url
$locationShimProvider.$get
$locationShimProvider.constructor
$locationShimProvider.hashPrefix
$locationShimProvider.html5Mode
ActivatedRoute.toString
ActivatedRouteSnapshot.toString
ActivationEnd.constructor
ActivationEnd.toString
ActivationStart.constructor
ActivationStart.toString
AfterContentChecked.ngAfterContentChecked
AfterContentInit.ngAfterContentInit
AfterRenderRef.destroy
AfterViewChecked.ngAfterViewChecked
AfterViewInit.ngAfterViewInit
AngularJSUrlCodec.areEqual
AngularJSUrlCodec.decodeHash
AngularJSUrlCodec.decodePath
AngularJSUrlCodec.decodeSearch
AngularJSUrlCodec.encodeHash
AngularJSUrlCodec.encodePath
AngularJSUrlCodec.encodeSearch
AngularJSUrlCodec.normalize
AngularJSUrlCodec.parse
AnimationBuilder.build
AnimationDriver.animate
AnimationDriver.computeStyle
AnimationDriver.containsElement
AnimationDriver.getParentElement
AnimationDriver.matchesElement
AnimationDriver.query
AnimationDriver.validateAnimatableStyleProperty
AnimationDriver.validateStyleProperty
AnimationFactory.create
AnimationPlayer.beforeDestroy
AnimationPlayer.destroy
AnimationPlayer.finish
AnimationPlayer.getPosition
AnimationPlayer.hasStarted
AnimationPlayer.init
AnimationPlayer.onDestroy
AnimationPlayer.onDone
AnimationPlayer.onStart
AnimationPlayer.pause
AnimationPlayer.play
AnimationPlayer.reset
AnimationPlayer.restart
AnimationPlayer.setPosition
AnimationTransitionMetadata.expr
ApplicationRef.attachView
ApplicationRef.bootstrap
ApplicationRef.destroy
ApplicationRef.detachView
ApplicationRef.onDestroy
ApplicationRef.tick
AsyncValidator.validate
AsyncValidatorFn.call
BaseRouteReuseStrategy.retrieve
BaseRouteReuseStrategy.shouldAttach
BaseRouteReuseStrategy.shouldDetach
BaseRouteReuseStrategy.shouldReuseRoute
BaseRouteReuseStrategy.store
BrowserPlatformLocation.back
BrowserPlatformLocation.back
BrowserPlatformLocation.forward
BrowserPlatformLocation.forward
BrowserPlatformLocation.getBaseHrefFromDOM
BrowserPlatformLocation.getBaseHrefFromDOM
BrowserPlatformLocation.getState
BrowserPlatformLocation.getState
BrowserPlatformLocation.historyGo
BrowserPlatformLocation.historyGo
BrowserPlatformLocation.onHashChange
BrowserPlatformLocation.onHashChange
BrowserPlatformLocation.onPopState
BrowserPlatformLocation.onPopState
BrowserPlatformLocation.pushState
BrowserPlatformLocation.pushState
BrowserPlatformLocation.replaceState
BrowserPlatformLocation.replaceState
By.all
By.css
By.directive
CanActivate.canActivate
CanActivateChild.canActivateChild
CanDeactivate.canDeactivate
CanLoad.canLoad
CanMatch.canMatch
ChangeDetectorRef.checkNoChanges
ChangeDetectorRef.detach
ChangeDetectorRef.detectChanges
ChangeDetectorRef.markForCheck
ChangeDetectorRef.reattach
ChildActivationEnd.constructor
ChildActivationEnd.toString
ChildActivationStart.constructor
ChildActivationStart.toString
ChildrenOutletContexts.getContext
ChildrenOutletContexts.getOrCreateContext
ChildrenOutletContexts.onChildOutletCreated
ChildrenOutletContexts.onChildOutletDestroyed
ChildrenOutletContexts.onOutletDeactivated
ChildrenOutletContexts.onOutletReAttached
Compiler.clearCache
Compiler.clearCacheFor
Compiler.compileModuleAndAllComponentsAsync
Compiler.compileModuleAndAllComponentsSync
Compiler.compileModuleAsync
Compiler.compileModuleSync
Compiler.getModuleId
CompilerFactory.createCompiler
ComponentFactory.create
ComponentFactoryResolver.resolveComponentFactory
ComponentFixture.autoDetectChanges
ComponentFixture.checkNoChanges
ComponentFixture.destroy
ComponentFixture.detectChanges
ComponentFixture.getDeferBlocks
ComponentFixture.isStable
ComponentFixture.whenRenderingDone
ComponentFixture.whenStable
ComponentRef.destroy
ComponentRef.onDestroy
ComponentRef.setInput
ControlValueAccessor.registerOnChange
ControlValueAccessor.registerOnTouched
ControlValueAccessor.setDisabledState
ControlValueAccessor.writeValue
DebugElement.constructor
DebugElement.constructor
DebugElement.query
DebugElement.queryAll
DebugElement.queryAllNodes
DebugElement.triggerEventHandler
DebugEventListener.constructor
DefaultIterableDiffer.check
DefaultIterableDiffer.constructor
DefaultIterableDiffer.diff
DefaultIterableDiffer.forEachAddedItem
DefaultIterableDiffer.forEachIdentityChange
DefaultIterableDiffer.forEachItem
DefaultIterableDiffer.forEachMovedItem
DefaultIterableDiffer.forEachOperation
DefaultIterableDiffer.forEachPreviousItem
DefaultIterableDiffer.forEachRemovedItem
DefaultIterableDiffer.onDestroy
DefaultTitleStrategy.buildTitle
DefaultTitleStrategy.getResolvedTitleForRoute
DefaultTitleStrategy.updateTitle
DefaultTitleStrategy.updateTitle
DefaultUrlSerializer.parse
DefaultUrlSerializer.serialize
DeferBlockFixture.getDeferBlocks
DeferBlockFixture.render
DestroyRef.onDestroy
DoBootstrap.ngDoBootstrap
DoCheck.ngDoCheck
DomSanitizer.bypassSecurityTrustHtml
DomSanitizer.bypassSecurityTrustResourceUrl
DomSanitizer.bypassSecurityTrustScript
DomSanitizer.bypassSecurityTrustStyle
DomSanitizer.bypassSecurityTrustUrl
DomSanitizer.sanitize
EffectRef.destroy
ElementRef.constructor
EmbeddedViewRef.destroy
EmbeddedViewRef.onDestroy
EnvironmentInjector.destroy
EnvironmentInjector.get
EnvironmentInjector.runInContext
ErrorHandler.handleError
EventEmitter.emit
EventEmitter.new_0
EventEmitter.subscribe
EventManager.addEventListener
EventManager.constructor
EventManager.getZone
EventManagerPlugin.addEventListener
EventManagerPlugin.constructor
EventManagerPlugin.supports
ExtraOptions.errorHandler
FetchBackend.handle
Form.addControl
Form.addFormGroup
Form.getControl
Form.getFormGroup
Form.removeControl
Form.removeFormGroup
Form.updateModel
FormArray.addAsyncValidators
FormArray.addValidators
FormArray.at
FormArray.clear
FormArray.clearAsyncValidators
FormArray.clearValidators
FormArray.constructor
FormArray.constructor
FormArray.disable
FormArray.enable
FormArray.get
FormArray.getError
FormArray.getRawValue
FormArray.getRawValue
FormArray.hasAsyncValidator
FormArray.hasError
FormArray.hasValidator
FormArray.insert
FormArray.markAllAsTouched
FormArray.markAsDirty
FormArray.markAsPending
FormArray.markAsPristine
FormArray.markAsTouched
FormArray.markAsUntouched
FormArray.patchValue
FormArray.patchValue
FormArray.push
FormArray.removeAsyncValidators
FormArray.removeAt
FormArray.removeValidators
FormArray.reset
FormArray.reset
FormArray.setAsyncValidators
FormArray.setControl
FormArray.setErrors
FormArray.setParent
FormArray.setValidators
FormArray.setValue
FormArray.setValue
FormArray.updateValueAndValidity
FormControl.getRawValue
FormControl.new_0
FormControl.patchValue
FormControl.registerOnChange
FormControl.registerOnDisabledChange
FormControl.reset
FormControl.setValue
FormGroup.addControl
FormGroup.constructor
FormGroup.contains
FormGroup.getRawValue
FormGroup.patchValue
FormGroup.registerControl
FormGroup.removeControl
FormGroup.reset
FormGroup.setControl
FormGroup.setValue
FormRecord.addControl
FormRecord.contains
FormRecord.getRawValue
FormRecord.patchValue
FormRecord.registerControl
FormRecord.removeControl
FormRecord.reset
FormRecord.setControl
FormRecord.setValue
ForwardRefFn.call
GetTestability.addToWindow
GetTestability.findTestabilityInTree
GuardsCheckEnd.constructor
GuardsCheckEnd.toString
GuardsCheckStart.constructor
GuardsCheckStart.toString
HammerGestureConfig.buildHammer
HashLocationStrategy.back
HashLocationStrategy.forward
HashLocationStrategy.getBaseHref
HashLocationStrategy.getState
HashLocationStrategy.historyGo
HashLocationStrategy.onPopState
HashLocationStrategy.path
HashLocationStrategy.prepareExternalUrl
HashLocationStrategy.pushState
HashLocationStrategy.replaceState
HttpBackend.handle
HttpClient.delete
HttpClient.get
HttpClient.head
HttpClient.jsonp
HttpClient.options
HttpClient.patch
HttpClient.post
HttpClient.put
HttpClient.request
HttpContext.delete
HttpContext.get
HttpContext.has
HttpContext.keys
HttpContext.set
HttpContextToken.constructor
HttpContextToken.defaultValue
HttpErrorResponse.constructor
HttpHandler.handle
HttpHeaderResponse.clone
HttpHeaderResponse.constructor
HttpHeaderResponse.constructor
HttpHeaders.append
HttpHeaders.constructor
HttpHeaders.delete
HttpHeaders.get
HttpHeaders.getAll
HttpHeaders.has
HttpHeaders.keys
HttpHeaders.set
HttpInterceptor.intercept
HttpParameterCodec.decodeKey
HttpParameterCodec.decodeValue
HttpParameterCodec.encodeKey
HttpParameterCodec.encodeValue
HttpParams.append
HttpParams.appendAll
HttpParams.constructor
HttpParams.delete
HttpParams.get
HttpParams.getAll
HttpParams.has
HttpParams.keys
HttpParams.set
HttpParams.toString
HttpRequest.clone
HttpRequest.constructor
HttpRequest.detectContentTypeHeader
HttpRequest.serializeBody
HttpResponse.clone
HttpResponse.constructor
HttpTestingController.expectNone
HttpTestingController.expectOne
HttpTestingController.match
HttpTestingController.verify
HttpUrlEncodingCodec.decodeKey
HttpUrlEncodingCodec.decodeValue
HttpUrlEncodingCodec.encodeKey
HttpUrlEncodingCodec.encodeValue
HttpXhrBackend.handle
HttpXsrfTokenExtractor.getToken
InjectSetupWrapper.constructor
InjectSetupWrapper.inject
InjectionToken.constructor
InjectionToken.toString
Injector.create
Injector.get
InjectorType.new_0
IterableChanges.forEachAddedItem
IterableChanges.forEachIdentityChange
IterableChanges.forEachItem
IterableChanges.forEachMovedItem
IterableChanges.forEachOperation
IterableChanges.forEachPreviousItem
IterableChanges.forEachRemovedItem
IterableDiffer.diff
IterableDifferFactory.create
IterableDifferFactory.supports
IterableDiffers.constructor
IterableDiffers.create
IterableDiffers.extend
IterableDiffers.find
JitCompilerFactory.createCompiler
JsonpClientBackend.handle
JsonpInterceptor.intercept
KeyValueChanges.forEachAddedItem
KeyValueChanges.forEachChangedItem
KeyValueChanges.forEachItem
KeyValueChanges.forEachPreviousItem
KeyValueChanges.forEachRemovedItem
KeyValueDiffer.diff
KeyValueDifferFactory.create
KeyValueDifferFactory.supports
KeyValueDiffers.constructor
KeyValueDiffers.create
KeyValueDiffers.extend
KeyValueDiffers.find
Listener.callback
Location.back
Location.forward
Location.getState
Location.go
Location.historyGo
Location.isCurrentPathEqualTo
Location.joinWithSlash
Location.normalize
Location.normalizeQueryParams
Location.onUrlChange
Location.path
Location.prepareExternalUrl
Location.replaceState
Location.stripTrailingSlash
Location.subscribe
LocationChangeListener.call
LocationStrategy.back
LocationStrategy.forward
LocationStrategy.getBaseHref
LocationStrategy.getState
LocationStrategy.historyGo
LocationStrategy.onPopState
LocationStrategy.path
LocationStrategy.prepareExternalUrl
LocationStrategy.pushState
LocationStrategy.replaceState
Meta.addTag
Meta.addTags
Meta.getTag
Meta.getTags
Meta.removeTag
Meta.removeTagElement
Meta.updateTag
MockAnimationDriver.animate
MockAnimationDriver.computeStyle
MockAnimationDriver.containsElement
MockAnimationDriver.getParentElement
MockAnimationDriver.matchesElement
MockAnimationDriver.query
MockAnimationDriver.validateAnimatableStyleProperty
MockAnimationDriver.validateStyleProperty
MockAnimationPlayer.beforeDestroy
MockAnimationPlayer.constructor
MockAnimationPlayer.destroy
MockAnimationPlayer.finish
MockAnimationPlayer.hasStarted
MockAnimationPlayer.play
MockAnimationPlayer.reset
MockLocationStrategy.back
MockLocationStrategy.forward
MockLocationStrategy.getBaseHref
MockLocationStrategy.getState
MockLocationStrategy.onPopState
MockLocationStrategy.path
MockLocationStrategy.prepareExternalUrl
MockLocationStrategy.pushState
MockLocationStrategy.replaceState
MockLocationStrategy.simulatePopState
MockPlatformLocation.back
MockPlatformLocation.forward
MockPlatformLocation.getBaseHrefFromDOM
MockPlatformLocation.getState
MockPlatformLocation.historyGo
MockPlatformLocation.onHashChange
MockPlatformLocation.onPopState
MockPlatformLocation.pushState
MockPlatformLocation.replaceState
ModuleWithComponentFactories.constructor
NavigationCancel.constructor
NavigationCancel.toString
NavigationEnd.constructor
NavigationEnd.toString
NavigationError.constructor
NavigationError.constructor
NavigationError.toString
NavigationSkipped.constructor
NavigationStart.constructor
NavigationStart.toString
NgControl.getError
NgControl.hasError
NgControl.reset
NgControl.viewToModelUpdate
NgElement.attributeChangedCallback
NgElement.connectedCallback
NgElement.disconnectedCallback
NgElementConstructor.new
NgElementStrategy.connect
NgElementStrategy.disconnect
NgElementStrategy.getInputValue
NgElementStrategy.setInputValue
NgElementStrategyFactory.create
NgForOfContext.constructor
NgLocaleLocalization.getPluralCategory
NgLocaleLocalization.getPluralCategory
NgModuleFactory.create
NgModuleRef.destroy
NgModuleRef.onDestroy
NgProbeToken.constructor
NgZone.assertInAngularZone
NgZone.assertNotInAngularZone
NgZone.constructor
NgZone.isInAngularZone
NgZone.run
NgZone.runGuarded
NgZone.runOutsideAngular
NgZone.runTask
NoPreloading.preload
NonNullableFormBuilder.array
NonNullableFormBuilder.control
NonNullableFormBuilder.group
NonNullableFormBuilder.record
NoopAnimationDriver.animate
NoopAnimationDriver.computeStyle
NoopAnimationDriver.containsElement
NoopAnimationDriver.getParentElement
NoopAnimationDriver.matchesElement
NoopAnimationDriver.query
NoopAnimationDriver.validateStyleProperty
NoopAnimationPlayer.constructor
NoopAnimationPlayer.destroy
NoopAnimationPlayer.finish
NoopAnimationPlayer.getPosition
NoopAnimationPlayer.hasStarted
NoopAnimationPlayer.init
NoopAnimationPlayer.onDestroy
NoopAnimationPlayer.onDone
NoopAnimationPlayer.onStart
NoopAnimationPlayer.pause
NoopAnimationPlayer.play
NoopAnimationPlayer.reset
NoopAnimationPlayer.restart
NoopAnimationPlayer.setPosition
OnChanges.ngOnChanges
OnDestroy.ngOnDestroy
OnInit.ngOnInit
ParamMap.get
ParamMap.getAll
ParamMap.has
PathLocationStrategy.back
PathLocationStrategy.forward
PathLocationStrategy.getBaseHref
PathLocationStrategy.getState
PathLocationStrategy.historyGo
PathLocationStrategy.onPopState
PathLocationStrategy.path
PathLocationStrategy.prepareExternalUrl
PathLocationStrategy.pushState
PathLocationStrategy.replaceState
PipeTransform.transform
PlatformRef.bootstrapModule
PlatformRef.bootstrapModuleFactory
PlatformRef.destroy
PlatformRef.onDestroy
PlatformState.getDocument
PlatformState.renderToString
Predicate.call
PreloadAllModules.preload
PreloadingStrategy.preload
QueryList.constructor
QueryList.destroy
QueryList.filter
QueryList.find
QueryList.forEach
QueryList.get
QueryList.map
QueryList.notifyOnChanges
QueryList.reduce
QueryList.reset
QueryList.setDirty
QueryList.some
QueryList.toArray
QueryList.toString
Renderer2.addClass
Renderer2.appendChild
Renderer2.createComment
Renderer2.createElement
Renderer2.createText
Renderer2.destroy
Renderer2.destroyNode
Renderer2.insertBefore
Renderer2.listen
Renderer2.nextSibling
Renderer2.parentNode
Renderer2.removeAttribute
Renderer2.removeChild
Renderer2.removeClass
Renderer2.removeStyle
Renderer2.selectRootElement
Renderer2.setAttribute
Renderer2.setProperty
Renderer2.setStyle
Renderer2.setValue
RendererFactory2.begin
RendererFactory2.createRenderer
RendererFactory2.end
RendererFactory2.whenRenderingDone
Resolve.resolve
ResolveEnd.constructor
ResolveEnd.toString
ResolveStart.constructor
ResolveStart.toString
Route.loadComponent
RouteConfigLoadEnd.constructor
RouteConfigLoadEnd.toString
RouteConfigLoadStart.constructor
RouteConfigLoadStart.toString
RouteReuseStrategy.retrieve
RouteReuseStrategy.shouldAttach
RouteReuseStrategy.shouldDetach
RouteReuseStrategy.shouldReuseRoute
RouteReuseStrategy.store
Router.createUrlTree
Router.dispose
Router.errorHandler
Router.getCurrentNavigation
Router.initialNavigation
Router.isActive
Router.navigate
Router.navigateByUrl
Router.parseUrl
Router.resetConfig
Router.serializeUrl
Router.setUpLocationChangeListener
RouterOutletContract.activateWith
RouterOutletContract.attach
RouterOutletContract.deactivate
RouterOutletContract.detach
RouterPreloader.preload
RouterPreloader.setUpPreloading
RouterState.toString
RouterStateSnapshot.toString
RouterTestingHarness.create
RouterTestingHarness.detectChanges
RouterTestingHarness.navigateByUrl
RoutesRecognized.constructor
RoutesRecognized.toString
Sanitizer.sanitize
Scroll.constructor
Scroll.toString
SimpleChange.constructor
SimpleChange.isFirstChange
SimpleChanges.__index
SpyLocation.back
SpyLocation.forward
SpyLocation.getState
SpyLocation.go
SpyLocation.historyGo
SpyLocation.isCurrentPathEqualTo
SpyLocation.normalize
SpyLocation.onUrlChange
SpyLocation.path
SpyLocation.prepareExternalUrl
SpyLocation.replaceState
SpyLocation.setBaseHref
SpyLocation.setInitialPath
SpyLocation.simulateHashChange
SpyLocation.simulateUrlPop
SpyLocation.subscribe
SwPush.requestSubscription
SwPush.unsubscribe
SwRegistrationOptions.registrationStrategy
SwUpdate.activateUpdate
SwUpdate.checkForUpdate
TemplateRef.createEmbeddedView
TestBed.compileComponents
TestBed.configureCompiler
TestBed.configureTestingModule
TestBed.createComponent
TestBed.execute
TestBed.flushEffects
TestBed.get
TestBed.initTestEnvironment
TestBed.inject
TestBed.overrideComponent
TestBed.overrideDirective
TestBed.overrideModule
TestBed.overridePipe
TestBed.overrideProvider
TestBed.overrideTemplate
TestBed.overrideTemplateUsingTestingModule
TestBed.resetTestEnvironment
TestBed.resetTestingModule
TestBed.runInInjectionContext
TestBedStatic.new
TestComponentRenderer.insertRootElement
TestComponentRenderer.removeAllRootElements
TestRequest.constructor
TestRequest.error
TestRequest.event
TestRequest.flush
Testability.decreasePendingRequestCount
Testability.findProviders
Testability.getPendingRequestCount
Testability.increasePendingRequestCount
Testability.isStable
Testability.whenStable
TestabilityRegistry.findTestabilityInTree
TestabilityRegistry.getAllRootElements
TestabilityRegistry.getAllTestabilities
TestabilityRegistry.getTestability
TestabilityRegistry.registerApplication
TestabilityRegistry.unregisterAllApplications
TestabilityRegistry.unregisterApplication
Title.getTitle
Title.setTitle
TrackByFunction.call
TransferState.get
TransferState.hasKey
TransferState.onSerialize
TransferState.remove
TransferState.set
TransferState.toJson
TypeDecorator.call
UntypedFormBuilder.array
UntypedFormBuilder.array
UntypedFormBuilder.control
UntypedFormBuilder.control
UntypedFormBuilder.group
UntypedFormBuilder.group
UntypedFormBuilder.record
UpgradeAdapter.bootstrap
UpgradeAdapter.constructor
UpgradeAdapter.downgradeNg2Component
UpgradeAdapter.downgradeNg2Provider
UpgradeAdapter.registerForNg1Tests
UpgradeAdapter.upgradeNg1Component
UpgradeAdapter.upgradeNg1Provider
UpgradeAdapterRef.dispose
UpgradeAdapterRef.ready
UrlCodec.areEqual
UrlCodec.decodeHash
UrlCodec.decodePath
UrlCodec.decodeSearch
UrlCodec.encodeHash
UrlCodec.encodePath
UrlCodec.encodeSearch
UrlCodec.normalize
UrlCodec.parse
UrlHandlingStrategy.extract
UrlHandlingStrategy.merge
UrlHandlingStrategy.shouldProcessUrl
UrlSegment.constructor
UrlSegment.toString
UrlSegmentGroup.constructor
UrlSegmentGroup.hasChildren
UrlSegmentGroup.toString
UrlSerializer.parse
UrlSerializer.serialize
UrlTree.constructor
UrlTree.toString
Validator.registerOnValidatorChange
Validator.validate
ValidatorFn.call
Validators.compose
Validators.composeAsync
Validators.email
Validators.max
Validators.maxLength
Validators.min
Validators.minLength
Validators.nullValidator
Validators.pattern
Validators.required
Validators.requiredTrue
Version.constructor
ViewContainerRef.clear
ViewContainerRef.createComponent
ViewContainerRef.createEmbeddedView
ViewContainerRef.detach
ViewContainerRef.get
ViewContainerRef.indexOf
ViewContainerRef.insert
ViewContainerRef.move
ViewContainerRef.remove
ViewTransitionsFeatureOptions.onViewTransitionCreated
ViewportScroller.getScrollPosition
ViewportScroller.scrollToAnchor
ViewportScroller.scrollToPosition
ViewportScroller.setHistoryScrollRestoration
ViewportScroller.setOffset
WritableSignal.asReadonly
WritableSignal.set
WritableSignal.update
XhrFactory.build

Modules

common/CommonModule/index
common/http/HttpClientJsonpModule/index
common/http/HttpClientModule/index
common/http/HttpClientXsrfModule/index
common/http/testing/HttpClientTestingModule/index
common/upgrade/LocationUpgradeModule/index
core/ApplicationModule/index
forms/FormsModule/index
forms/ReactiveFormsModule/index
platform-browser-dynamic/testing/BrowserDynamicTestingModule/index
platform-browser/BrowserModule/index
platform-browser/HammerModule/index
platform-browser/animations/BrowserAnimationsModule/index
platform-browser/animations/NoopAnimationsModule/index
platform-browser/testing/BrowserTestingModule/index
platform-server/ServerModule/index
platform-server/ServerTransferStateModule/index
platform-server/testing/ServerTestingModule/index
router/RouterModule/index
router/testing/RouterTestingModule/index
service-worker/ServiceWorkerModule/index
upgrade/static/UpgradeModule/index

Packages

Pipes

AsyncPipe
CurrencyPipe
DatePipe
DecimalPipe
I18nPluralPipe
I18nSelectPipe
JsonPipe
KeyValuePipe
LowerCasePipe
PercentPipe
SlicePipe
TitleCasePipe
UpperCasePipe

Propertys

AbstractControlOptions.asyncValidators
AbstractControlOptions.updateOn
AbstractControlOptions.validators
AbstractType.prototype
ActivatedRoute.children
ActivatedRoute.component
ActivatedRoute.data
ActivatedRoute.firstChild
ActivatedRoute.fragment
ActivatedRoute.outlet
ActivatedRoute.paramMap
ActivatedRoute.params
ActivatedRoute.parent
ActivatedRoute.pathFromRoot
ActivatedRoute.queryParamMap
ActivatedRoute.queryParams
ActivatedRoute.root
ActivatedRoute.routeConfig
ActivatedRoute.snapshot
ActivatedRoute.title
ActivatedRoute.url
ActivatedRouteSnapshot.children
ActivatedRouteSnapshot.component
ActivatedRouteSnapshot.data
ActivatedRouteSnapshot.firstChild
ActivatedRouteSnapshot.fragment
ActivatedRouteSnapshot.outlet
ActivatedRouteSnapshot.paramMap
ActivatedRouteSnapshot.params
ActivatedRouteSnapshot.parent
ActivatedRouteSnapshot.pathFromRoot
ActivatedRouteSnapshot.queryParamMap
ActivatedRouteSnapshot.queryParams
ActivatedRouteSnapshot.root
ActivatedRouteSnapshot.routeConfig
ActivatedRouteSnapshot.title
ActivatedRouteSnapshot.url
ActivationEnd.snapshot
ActivationEnd.type
ActivationStart.snapshot
ActivationStart.type
AfterRenderOptions.injector
AfterRenderOptions.phase
AnimateChildOptions.delay
AnimateChildOptions.duration
AnimateChildOptions.params
AnimationAnimateChildMetadata.options
AnimationAnimateMetadata.styles
AnimationAnimateMetadata.timings
AnimationAnimateRefMetadata.animation
AnimationAnimateRefMetadata.options
AnimationDriver.NOOP
AnimationEvent.disabled
AnimationEvent.element
AnimationEvent.fromState
AnimationEvent.phaseName
AnimationEvent.toState
AnimationEvent.totalTime
AnimationEvent.triggerName
AnimationGroupMetadata.options
AnimationGroupMetadata.steps
AnimationKeyframesSequenceMetadata.steps
AnimationMetadata.type
AnimationPlayer.parentPlayer
AnimationPlayer.totalTime
AnimationQueryMetadata.animation
AnimationQueryMetadata.options
AnimationQueryMetadata.selector
AnimationQueryOptions.limit
AnimationQueryOptions.optional
AnimationReferenceMetadata.animation
AnimationReferenceMetadata.options
AnimationSequenceMetadata.options
AnimationSequenceMetadata.steps
AnimationStaggerMetadata.animation
AnimationStaggerMetadata.timings
AnimationStateMetadata.name
AnimationStateMetadata.options
AnimationStateMetadata.styles
AnimationStyleMetadata.offset
AnimationStyleMetadata.styles
AnimationTransitionMetadata.animation
AnimationTransitionMetadata.options
AnimationTriggerMetadata.definitions
AnimationTriggerMetadata.name
AnimationTriggerMetadata.options
ApplicationConfig.providers
ApplicationInitStatus.done
ApplicationInitStatus.donePromise
ApplicationRef.componentTypes
ApplicationRef.components
ApplicationRef.destroyed
ApplicationRef.injector
ApplicationRef.isStable
ApplicationRef.viewCount
BootstrapOptions.ngZone
BootstrapOptions.ngZoneEventCoalescing
BootstrapOptions.ngZoneRunCoalescing
BrowserAnimationsModuleConfig.disableAnimations
BrowserPlatformLocation.hash
BrowserPlatformLocation.hash
BrowserPlatformLocation.hostname
BrowserPlatformLocation.hostname
BrowserPlatformLocation.href
BrowserPlatformLocation.href
BrowserPlatformLocation.pathname
BrowserPlatformLocation.pathname
BrowserPlatformLocation.port
BrowserPlatformLocation.port
BrowserPlatformLocation.protocol
BrowserPlatformLocation.protocol
BrowserPlatformLocation.search
BrowserPlatformLocation.search
ChildActivationEnd.snapshot
ChildActivationEnd.type
ChildActivationStart.snapshot
ChildActivationStart.type
ClassProvider.multi
ClassProvider.provide
ClassSansProvider.useClass
ComponentDebugMetadata.changeDetection
ComponentDebugMetadata.encapsulation
ComponentDebugMetadata.inputs
ComponentDebugMetadata.outputs
ComponentFactory.componentType
ComponentFactory.inputs
ComponentFactory.ngContentSelectors
ComponentFactory.outputs
ComponentFactory.selector
ComponentFactoryResolver.NULL
ComponentFixture.changeDetectorRef
ComponentFixture.componentInstance
ComponentFixture.componentRef
ComponentFixture.debugElement
ComponentFixture.elementRef
ComponentFixture.nativeElement
ComponentFixture.ngZone
ComponentMirror.inputs
ComponentMirror.isStandalone
ComponentMirror.ngContentSelectors
ComponentMirror.outputs
ComponentMirror.selector
ComponentMirror.type
ComponentRef.changeDetectorRef
ComponentRef.componentType
ComponentRef.hostView
ComponentRef.injector
ComponentRef.instance
ComponentRef.location
ConstructorProvider.deps
ConstructorProvider.multi
ConstructorProvider.provide
ControlContainer.formDirective
ControlContainer.name
ControlContainer.path
CreateComputedOptions.equal
CreateEffectOptions.allowSignalWrites
CreateEffectOptions.injector
CreateEffectOptions.manualCleanup
CreateSignalOptions.equal
DatePipeConfig.dateFormat
DatePipeConfig.timezone
DebugElement.attributes
DebugElement.childNodes
DebugElement.children
DebugElement.classes
DebugElement.componentInstance
DebugElement.context
DebugElement.injector
DebugElement.listeners
DebugElement.name
DebugElement.nativeElement
DebugElement.nativeNode
DebugElement.parent
DebugElement.properties
DebugElement.providerTokens
DebugElement.references
DebugElement.styles
DebugEventListener.callback
DebugEventListener.name
DefaultExport.default
DefaultIterableDiffer.collection
DefaultIterableDiffer.isDirty
DefaultIterableDiffer.length
DefaultTitleStrategy.title
ElementRef.nativeElement
EmbeddedViewRef.context
EmbeddedViewRef.destroyed
EmbeddedViewRef.rootNodes
EventManagerPlugin.manager
ExistingProvider.multi
ExistingProvider.provide
ExistingSansProvider.useExisting
ExtraOptions.anchorScrolling
ExtraOptions.bindToComponentInputs
ExtraOptions.enableTracing
ExtraOptions.enableViewTransitions
ExtraOptions.initialNavigation
ExtraOptions.preloadingStrategy
ExtraOptions.scrollOffset
ExtraOptions.scrollPositionRestoration
ExtraOptions.useHash
FactoryProvider.multi
FactoryProvider.provide
FactorySansProvider.deps
FactorySansProvider.useFactory
FormArray.asyncValidator
FormArray.controls
FormArray.dirty
FormArray.disabled
FormArray.enabled
FormArray.errors
FormArray.invalid
FormArray.length
FormArray.parent
FormArray.pending
FormArray.pristine
FormArray.root
FormArray.status
FormArray.statusChanges
FormArray.touched
FormArray.untouched
FormArray.updateOn
FormArray.valid
FormArray.validator
FormArray.value
FormArray.valueChanges
FormControl.defaultValue
FormControlOptions.initialValueIsDefault
FormControlOptions.nonNullable
FormControlState.disabled
FormControlState.value
FormGroup.controls
GuardsCheckEnd.shouldActivate
GuardsCheckEnd.state
GuardsCheckEnd.type
GuardsCheckEnd.urlAfterRedirects
GuardsCheckStart.state
GuardsCheckStart.type
GuardsCheckStart.urlAfterRedirects
HammerGestureConfig.events
HammerGestureConfig.options
HammerGestureConfig.overrides
HttpDownloadProgressEvent.partialText
HttpDownloadProgressEvent.type
HttpErrorResponse.error
HttpErrorResponse.message
HttpErrorResponse.name
HttpErrorResponse.ok
HttpHeaderResponse.headers
HttpHeaderResponse.ok
HttpHeaderResponse.status
HttpHeaderResponse.statusText
HttpHeaderResponse.type
HttpHeaderResponse.type
HttpHeaderResponse.url
HttpParamsOptions.encoder
HttpParamsOptions.fromObject
HttpParamsOptions.fromString
HttpRequest.body
HttpRequest.context
HttpRequest.headers
HttpRequest.method
HttpRequest.params
HttpRequest.reportProgress
HttpRequest.responseType
HttpRequest.transferCache
HttpRequest.url
HttpRequest.urlWithParams
HttpRequest.withCredentials
HttpResponse.body
HttpResponse.type
HttpSentEvent.type
HttpUploadProgressEvent.loaded
HttpUploadProgressEvent.total
HttpUploadProgressEvent.type
HttpUploadProgressEvent.type
HttpUserEvent.type
ImageLoaderConfig.loaderParams
ImageLoaderConfig.src
ImageLoaderConfig.width
InjectOptions.host
InjectOptions.optional
InjectOptions.self
InjectOptions.skipSelf
InjectionToken._desc
Injector.NULL
Injector.THROW_IF_NOT_FOUND
IsActiveMatchOptions.fragment
IsActiveMatchOptions.matrixParams
IsActiveMatchOptions.paths
IsActiveMatchOptions.queryParams
IterableChangeRecord.currentIndex
IterableChangeRecord.item
IterableChangeRecord.previousIndex
IterableChangeRecord.trackById
KeyValue.key
KeyValue.value
KeyValueChangeRecord.currentValue
KeyValueChangeRecord.key
KeyValueChangeRecord.previousValue
KeyValueDiffers.factories
Listener.element
Listener.name
Listener.type
Listener.useCapture
LocationChangeEvent.state
LocationChangeEvent.type
LocationUpgradeConfig.appBaseHref
LocationUpgradeConfig.hashPrefix
LocationUpgradeConfig.serverBaseHref
LocationUpgradeConfig.urlCodec
LocationUpgradeConfig.useHash
MockAnimationDriver.log
MockAnimationPlayer.currentSnapshot
MockAnimationPlayer.delay
MockAnimationPlayer.duration
MockAnimationPlayer.easing
MockAnimationPlayer.element
MockAnimationPlayer.keyframes
MockAnimationPlayer.previousPlayers
MockAnimationPlayer.previousStyles
MockLocationStrategy.internalBaseHref
MockLocationStrategy.internalPath
MockLocationStrategy.internalTitle
MockLocationStrategy.urlChanges
MockPlatformLocation.hash
MockPlatformLocation.hostname
MockPlatformLocation.href
MockPlatformLocation.pathname
MockPlatformLocation.port
MockPlatformLocation.protocol
MockPlatformLocation.search
MockPlatformLocation.state
MockPlatformLocation.url
MockPlatformLocationConfig.appBaseHref
MockPlatformLocationConfig.startUrl
ModuleTeardownOptions.destroyAfterEach
ModuleTeardownOptions.rethrowErrors
ModuleWithComponentFactories.componentFactories
ModuleWithComponentFactories.ngModuleFactory
ModuleWithProviders.ngModule
ModuleWithProviders.providers
Navigation.extractedUrl
Navigation.extras
Navigation.finalUrl
Navigation.id
Navigation.initialUrl
Navigation.previousNavigation
Navigation.trigger
NavigationBehaviorOptions.onSameUrlNavigation
NavigationBehaviorOptions.replaceUrl
NavigationBehaviorOptions.skipLocationChange
NavigationBehaviorOptions.state
NavigationCancel.code
NavigationCancel.reason
NavigationCancel.type
NavigationEnd.type
NavigationEnd.urlAfterRedirects
NavigationError.error
NavigationError.id
NavigationError.target
NavigationError.type
NavigationError.url
NavigationSkipped.code
NavigationSkipped.reason
NavigationSkipped.type
NavigationStart.navigationTrigger
NavigationStart.restoredState
NavigationStart.type
NgControl.asyncValidator
NgControl.control
NgControl.dirty
NgControl.disabled
NgControl.enabled
NgControl.errors
NgControl.invalid
NgControl.name
NgControl.path
NgControl.pending
NgControl.pristine
NgControl.status
NgControl.statusChanges
NgControl.touched
NgControl.untouched
NgControl.valid
NgControl.validator
NgControl.value
NgControl.valueAccessor
NgControl.valueChanges
NgElement.ngElementEventsSubscription
NgElement.ngElementStrategy
NgElementConfig.injector
NgElementConfig.strategyFactory
NgElementConstructor.observedAttributes
NgElementStrategy.events
NgElementStrategyEvent.name
NgElementStrategyEvent.value
NgForOfContext.$implicit
NgForOfContext.count
NgForOfContext.even
NgForOfContext.first
NgForOfContext.index
NgForOfContext.last
NgForOfContext.ngForOf
NgForOfContext.odd
NgIfContext.$implicit
NgIfContext.ngIf
NgLocaleLocalization.locale
NgModuleFactory.moduleType
NgModuleRef.componentFactoryResolver
NgModuleRef.injector
NgModuleRef.instance
NgProbeToken.name
NgProbeToken.token
NgZone.hasPendingMacrotasks
NgZone.hasPendingMicrotasks
NgZone.isStable
NgZone.onError
NgZone.onMicrotaskEmpty
NgZone.onStable
NgZone.onUnstable
NgZoneOptions.eventCoalescing
NgZoneOptions.runCoalescing
NoNewVersionDetectedEvent.type
NoNewVersionDetectedEvent.version
NoopAnimationPlayer.parentPlayer
NoopAnimationPlayer.totalTime
OutletContext.attachRef
OutletContext.children
OutletContext.injector
OutletContext.outlet
OutletContext.route
ParamMap.keys
PlatformConfig.baseUrl
PlatformConfig.document
PlatformConfig.url
PlatformConfig.useAbsoluteUrl
PlatformRef.destroyed
PlatformRef.injector
PopStateEvent.pop
PopStateEvent.state
PopStateEvent.type
PopStateEvent.url
Query.descendants
Query.emitDistinctChangesOnly
Query.first
Query.isViewQuery
Query.read
Query.selector
Query.static
QueryList.changes
QueryList.dirty
QueryList.first
QueryList.last
QueryList.length
Renderer2.data
RendererType2.data
RendererType2.encapsulation
RendererType2.id
RendererType2.styles
RequestMatch.method
RequestMatch.url
ResolveEnd.state
ResolveEnd.type
ResolveEnd.urlAfterRedirects
ResolveStart.state
ResolveStart.type
ResolveStart.urlAfterRedirects
Route.canActivate
Route.canActivateChild
Route.canDeactivate
Route.canLoad
Route.canMatch
Route.children
Route.component
Route.data
Route.loadChildren
Route.matcher
Route.outlet
Route.path
Route.pathMatch
Route.providers
Route.redirectTo
Route.resolve
Route.runGuardsAndResolvers
Route.title
RouteConfigLoadEnd.route
RouteConfigLoadEnd.type
RouteConfigLoadStart.route
RouteConfigLoadStart.type
Router.componentInputBindingEnabled
Router.config
Router.events
Router.lastSuccessfulNavigation
Router.navigated
Router.onSameUrlNavigation
Router.routeReuseStrategy
Router.routerState
Router.url
RouterConfigOptions.canceledNavigationResolution
RouterConfigOptions.onSameUrlNavigation
RouterConfigOptions.paramsInheritanceStrategy
RouterConfigOptions.urlUpdateStrategy
RouterOutletContract.activateEvents
RouterOutletContract.activatedRoute
RouterOutletContract.activatedRouteData
RouterOutletContract.attachEvents
RouterOutletContract.component
RouterOutletContract.deactivateEvents
RouterOutletContract.detachEvents
RouterOutletContract.isActivated
RouterOutletContract.supportsBindingToComponentInputs
RouterState.snapshot
RouterStateSnapshot.url
RouterTestingHarness.fixture
RouterTestingHarness.routeDebugElement
RouterTestingHarness.routeNativeElement
RoutesRecognized.state
RoutesRecognized.type
RoutesRecognized.urlAfterRedirects
SchemaMetadata.name
Scroll.anchor
Scroll.position
Scroll.routerEvent
Scroll.type
SimpleChange.currentValue
SimpleChange.firstChange
SimpleChange.previousValue
SpyLocation.urlChanges
StaticClassProvider.deps
StaticClassProvider.multi
StaticClassProvider.provide
StaticClassProvider.useClass
SwPush.isEnabled
SwPush.messages
SwPush.notificationClicks
SwPush.subscription
SwRegistrationOptions.enabled
SwRegistrationOptions.scope
SwUpdate.isEnabled
SwUpdate.unrecoverable
SwUpdate.versionUpdates
TemplateRef.elementRef
TestBed.ngModule
TestBed.platform
TestEnvironmentOptions.errorOnUnknownElements
TestEnvironmentOptions.errorOnUnknownProperties
TestEnvironmentOptions.teardown
TestModuleMetadata.declarations
TestModuleMetadata.deferBlockBehavior
TestModuleMetadata.errorOnUnknownElements
TestModuleMetadata.errorOnUnknownProperties
TestModuleMetadata.imports
TestModuleMetadata.providers
TestModuleMetadata.schemas
TestModuleMetadata.teardown
TestRequest.cancelled
TestRequest.request
ToObservableOptions.injector
ToSignalOptions.initialValue
ToSignalOptions.injector
ToSignalOptions.manualCleanup
ToSignalOptions.rejectErrors
ToSignalOptions.requireSync
TransferState.isEmpty
UnrecoverableStateEvent.reason
UnrecoverableStateEvent.type
UntypedFormBuilder.nonNullable
UpgradeAdapterRef.ng1Injector
UpgradeAdapterRef.ng1RootScope
UpgradeAdapterRef.ng2Injector
UpgradeAdapterRef.ng2ModuleRef
UrlCreationOptions.fragment
UrlCreationOptions.preserveFragment
UrlCreationOptions.queryParams
UrlCreationOptions.queryParamsHandling
UrlCreationOptions.relativeTo
UrlSegment.parameterMap
UrlSegment.parameters
UrlSegment.path
UrlSegmentGroup.children
UrlSegmentGroup.numberOfChildren
UrlSegmentGroup.parent
UrlSegmentGroup.segments
UrlTree.fragment
UrlTree.queryParamMap
UrlTree.queryParams
UrlTree.root
ValueProvider.multi
ValueProvider.provide
ValueSansProvider.useValue
Version.full
Version.major
Version.minor
Version.patch
VersionDetectedEvent.type
VersionDetectedEvent.version
VersionInstallationFailedEvent.error
VersionInstallationFailedEvent.type
VersionInstallationFailedEvent.version
VersionReadyEvent.currentVersion
VersionReadyEvent.latestVersion
VersionReadyEvent.type
ViewContainerRef.element
ViewContainerRef.injector
ViewContainerRef.length
ViewContainerRef.parentInjector
ViewTransitionInfo.from
ViewTransitionInfo.to
ViewTransitionInfo.transition
ViewTransitionsFeatureOptions.skipInitialTransition

Sections

<base href> - Common Routing Tasks
@NgModule metadata - NgModule API
@for block - repeaters - Built-in control flow
@if block conditionals - Built-in control flow
@switch block - selection - Built-in control flow
About this guide - Introduction to Angular animations
Accessibility attributes - Accessibility in Angular
Accessing query parameters and fragments - Common Routing Tasks
Activated route - Router reference
Active router links - Router reference
Actively supported versions - Version compatibility
Add a new hero - Building a template-driven form
Add and updating headers - HTTP: Send data to a server
Adding a 404 page - Using Angular routes in a single-page application
Adding a basic form control - Reactive forms
Adding a library to the runtime global scope - Usage of Angular libraries published to npm
Adding a redirect - Using Angular routes in a single-page application
Adding a service worker to your project - Getting started with service workers
Adding a web worker - Background processing using web workers
Adding and removing classes with NgClass - Built-in directives
Adding directives to a component - Directive composition API
Adding directives to another directive - Directive composition API
Adding or removing an element with NgIf - Built-in directives
Adding two-way data binding - Two-way binding
Additional Configurations - Sharing data between child and parent directives and components
Advanced topics - Angular Signals
Advanced topics - Getting started with standalone components
After the migration - Migrate an existing Angular project to standalone
Alerts and callouts - Angular documentation style guide
Aliases :enter and :leave - Animation transitions and triggers
An event is handled by a component with OnPush - Skipping component subtrees
An event is handled by a component with default change detection - Skipping component subtrees
An event is handled by a descendant of a component with OnPush - Skipping component subtrees
An example that uses both - JavaScript modules vs. NgModules
Anatomy of a documentation linter message - Resolve documentation linter messages
Anatomy of a pull request - Update a documentation pull request
Anchors - Angular documentation style guide
Angular CLI configuration options - Angular workspace configuration
Angular Language Service in your editor - Angular Language Service
Angular TestBed - Testing services
Angular UI components - Accessibility in Angular
Angular element - Glossary
Angular modularity - NgModules
Angular package format (APF) - Glossary
Angular versioning - Angular versioning and releases
Animate entering and leaving a view - Animation transitions and triggers
Animate multiple elements using query() and stagger() functions - Complex animation sequences
Animating a transition - Introduction to Angular animations
Animating the items of a reordering list - Complex animation sequences
Animation callbacks - Animation transitions and triggers
Animation definition - Route transition animations
Animation sequence summary - Complex animation sequences
Animations API summary - Introduction to Angular animations
Animations and Component View Encapsulation - Complex animation sequences
Appendix - Angular coding style guide
Appendix: Test using fakeAsync()/waitForAsync() - Setup for upgrading from AngularJS
Appendix: Upgrading PhoneCat Tests - Upgrading from AngularJS to Angular
Application architecture - Next steps: tools and techniques
Application project files - Workspace and project file structure
Application structure and NgModules - Angular coding style guide
Apply specific build options for just one locale - Merge translations into the application
Applying an attribute directive - Attribute directives
Architect - Glossary
Asserts the context - Injection context
Async pipe - Observables in Angular
Auditing Angular applications - Security
Authoring server-compatible components - Server-side rendering
Automated Untyped Forms Migration - Typed Forms
Avoid side effects - Property binding best practices
Avoiding Layout Shifts - Deferrable Views
Awareness - Angular documentation localization guidelines
Basic usage and terms - Using observables for streams of values
Before you begin - Angular documentation localization guidelines
Behavior with NgModule - Deferrable Views
Behavior with Server-side rendering (SSR) and Static site generation (SSG) - Deferrable Views
Bind input controls to data properties - Building a template-driven form
Binding ARIA attributes - Attribute binding
Binding to a property - Property binding
Binding to a second property - Attribute directives
Binding to a single CSS class - Class and style binding
Binding to a single style - Class and style binding
Binding to colspan - Attribute binding
Binding to events - Event binding
Binding to keyboard events - Event binding
Binding to multiple CSS classes - Class and style binding
Binding to multiple styles - Class and style binding
Binding to passive events - Event binding
Binding to user input events - User input
Binding types and targets - Binding syntax
Blocks - Deferrable Views
Boolean values in transitions - Animation transitions and triggers
Bootstrapping an application using a standalone component - Getting started with standalone components
Breaking changes in Angular v15 - Update Angular to v15
Browser support for custom elements - Angular elements overview
BrowserModule and CommonModule - Frequently-used modules
Bug reports - DevTools Overview
Bug reports - Getting started with the Angular CLI's new build system
Build a template-driven form - Building a template-driven form
Build and test the Angular documentation - Prepare to edit Angular documentation
Build from the command line - Merge translations into the application
Build target - Angular workspace configuration
Build the documentation on your local computer - Build and test a documentation update
Build the form - Building a template-driven form
Builder input - Angular CLI builders
Building an attribute directive - Attribute directives
Building your schematics - Schematics for libraries
Built-in attribute directives - Built-in directives
Built-in pipes - Understanding Pipes
Built-in structural directives - Built-in directives
CLI builders - Angular CLI builders
Cache requests - HTTP - interceptor use-cases
Caching HTTP requests - Transforming Data Using Pipes
Caching data when using HttpClient - Server-side rendering
Calling compileComponents() - Component testing scenarios
Can I re-export classes and modules? - NgModule FAQ
Case study: Building a custom progress bar - Accessibility in Angular
Changes and deprecations in version 14 - Update Angular to v14
Checking of *ngFor - Template type checking
Checking your version of Angular - Keeping your Angular projects up-to-date
Choosing a compiler - Ahead-of-time (AOT) compilation
Choosing a routing strategy - Common Routing Tasks
Choosing an approach - Introduction to forms in Angular
Class constructors - Injection context
Clean up after merge - Overview of Angular documentation editorial workflow
Clean up the branch - Update a documentation pull request
Cleaning up on instance destruction - Component Lifecycle
Client-server interaction - Next steps: tools and techniques
Clone - Setup for upgrading from AngularJS
Code coverage enforcement - Find out how much code you're testing
Code snippets - Angular documentation style guide
Collection contents - Authoring schematics
Command Line Interface (CLI) - What is Angular?
Command line options - Angular compiler options
Common change detection scenarios - Skipping component subtrees
Common problems - Migrate an existing Angular project to standalone
Communications - Angular documentation localization guidelines
Comparing built-in control flow to NgIf, NgSwitch and NgFor - Built-in control flow
Complete a contributor's license agreement - Prepare to edit Angular documentation
Completed - Angular Roadmap
Complex configuration values - Angular workspace configuration
Component DOM testing - Basics of testing components
Component binding - Component testing scenarios
Component class testing - Basics of testing components
Component inside a test host - Component testing scenarios
Component marble tests - Component testing scenarios
Component metadata - Introduction to components and templates
Component styling best practices - Component styles
Component with a dependency - Component testing scenarios
Component with async service - Component testing scenarios
Component with external files - Component testing scenarios
Component with inputs and outputs - Component testing scenarios
Components - Angular coding style guide
Components - Introduction to Angular concepts
Components - What is Angular?
Compose dynamic form contents - Building dynamic forms
Conclusion - Upgrading for performance
Conditional content projection - Content projection
Configuration - Router reference
Configuration - Testing
Configuration files - TypeScript configuration
Configuration inheritance with extends - Angular compiler options
Configure a server - Deploy multiple locales
Configure custom cookie/header names - HTTP client - Security: Cross-Site Request Forgery (XSRF) protection
Configure server-side rendering - Server-side rendering
Configure target-specific file replacements - Building and serving Angular apps
Configure your routes for your application - Tutorial: Creating custom route matches
Configuring CommonJS dependencies - Building and serving Angular apps
Configuring an image loader for NgOptimizedImage - Getting started with NgOptimizedImage
Configuring application environments - Building and serving Angular apps
Configuring browser compatibility - Building and serving Angular apps
Configuring compiler options for the Angular Language Service - Angular Language Service
Configuring size budgets - Building and serving Angular apps
Constraints - Hydration
Consuming partial-Ivy code outside the Angular CLI - Creating libraries
Contexts are mutable - HTTP - Pass metadata to interceptors
Control navigation with UI elements - Using Angular routes in a single-page application
Control status CSS classes - Validating form input
Controllers and Components - AngularJS to Angular concepts: Quick reference
Could not resolve type - AOT metadata errors
Create URL parameter using the search method - HTTP - Configure URL parameters
Create URL parameters from a query - HTTP - Configure URL parameters
Create a context token - HTTP - Pass metadata to interceptors
Create a dynamic form template - Building dynamic forms
Create a form object model - Building dynamic forms
Create a sample application - Tutorial: Creating custom route matches
Create a sample application - Using Angular routes in a single-page application
Create a translation file for each language - Work with translation files
Create a working branch for editing - Start to edit a documentation topic
Create a workspace and initial application - Setting up the local environment and workspace
Create reusable animations - Reusable animations
Create your repo and workspace for Angular documentation - Prepare to edit Angular documentation
Creating a builder - Angular CLI builders
Creating a component - Angular components overview
Creating a schematics collection - Schematics for libraries
Creating a structural directive - Structural directives
Creating an injectable service - Creating an injectable service
Creating asynchronous validators - Validating form input
Creating dynamic forms - Reactive forms
Creating libraries - Overview of Angular libraries
Creating observables - Using observables for streams of values
Creating pipes for custom data transformations - Transforming Data Using Pipes
Creating standalone components - Getting started with standalone components
Cross-field validation - Validating form input
Custom JSON parsing - HTTP - interceptor use-cases
DI token - Glossary
Data Services - Angular coding style guide
Data binding and HTML - Binding syntax
Data flow in forms - Introduction to forms in Angular
Deactivating Angular processing with NgNonBindable - Attribute directives
Debug your application - DevTools Overview
Debugging the Angular service worker - Service worker in production
Declaring a component's styles - Angular components overview
Define a generation rule - Schematics for libraries
Define locales in the build configuration - Merge translations into the application
Define your routes - Using Angular routes in a single-page application
Defining a basic route - Common Routing Tasks
Defining a component's template - Angular components overview
Defining custom change detection - Component Lifecycle
Defining custom validators - Validating form input
Defining observers - Using observables for streams of values
Definition of terms - Angular package format
Delegating to styles with lower precedence - Style Precedence
Delete non-essential files (optional) - Setup for upgrading from AngularJS
Delete the working branch - Finish up a documentation pull request
Dependencies - Workspace npm dependencies
Dependency injection (DI) - Introduction to services and dependency injection
Dependency injection - Example applications
Deprecated APIs - Deprecated APIs and features
Deprecated CLI APIs and Options - Deprecated APIs and features
Deprecated features - Deprecated APIs and features
Deprecation practices - Angular versioning and releases
Deprecations highlights in Angular v16 - Update Angular to v16
Deprecations in Angular v15 - Update Angular to v15
Destructured variable or constant not supported - AOT metadata errors
Detecting changes with data binding in pipes - Transforming Data Using Pipes
DevDependencies - Workspace npm dependencies
Developer Preview - Angular versioning and releases
Developing schematics for libraries - Generating code using schematics
Different components from the service - Dynamic component loader
Directives - Angular coding style guide
Directives - What is Angular?
Disabling type checking using $any() - Template type checking
Displaying a 404 page - Common Routing Tasks
Displaying and updating properties with ngModel - Built-in directives
Documentation - Example applications
Domain NgModules - Guidelines for creating NgModules
Download - Setup for upgrading from AngularJS
ECMAScript - Glossary
ESM default imports vs. namespace imports - Getting started with the Angular CLI's new build system
Edge cases - Skipping component subtrees
Edit the documentation - Make and save changes to a documentation topic
Edit the documentation - Start to edit a documentation topic
Effects - Angular Signals
ElementInjector use case examples - Hierarchical injectors
Empower your HTML - Template syntax
Enable performance profiling - Server-side rendering
Enable reactive forms for your project - Building dynamic forms
Enable routing transition animation - Route transition animations
Enable server-side rendering - Server-side rendering
Enhancing HTML - Understanding templates
Ensuring library version compatibility - Creating libraries
Entrypoints and code splitting - Angular package format
Error handling - The RxJS library
Error handling - Using observables for streams of values
Errors - Hydration
Errors reported - Build and test a documentation update
Example: A Popup Service - Angular elements overview
Example: Chaining two pipes together - Transforming Data Using Pipes
Example: Chaining two pipes together - Transforming data with parameters and chained pipes
Example: Formatting a date - Transforming Data Using Pipes
Example: Formatting a date - Transforming data with parameters and chained pipes
Examples - Angular package format
Executing a build - Getting started with the Angular CLI's new build system
Expect and answer requests - HTTP client - Test requests
Experimental - Angular versioning and releases
Explore the translated example application - Example Angular Internationalization application
Exponential backoff - Practical observable usage
Expression best practices - Understanding binding
Expression best practices - Understanding template expressions
Expression context - Understanding binding
Expression context - Understanding template expressions
Expression form not supported - AOT metadata errors
Extending Angular - Next steps: tools and techniques
Extract the source language file - Work with translation files
FAQ - Static query migration guide
Feature highlights in Angular v16 - Update Angular to v16
Feature modules vs. root modules - Feature modules
Features - Angular Language Service
File layout - Angular package format
File structure conventions - Angular coding style guide
File structure, configuration, and dependencies - Next steps: tools and techniques
Filter animation example - Complex animation sequences
Filters / pipes - AngularJS to Angular concepts: Quick reference
Final ad banner - Dynamic component loader
Final application - Router tutorial: tour of heroes
Find topics to review - Review documentation
Finding the current version of Angular - Keeping your Angular projects up-to-date
First-party libraries - What is Angular?
For existing applications - Getting started with the Angular CLI's new build system
For new applications - Getting started with the Angular CLI's new build system
Form validation - Introduction to forms in Angular
FormArray: Dynamic, Homogenous Collections - Typed Forms
FormBuilder and NonNullableFormBuilder - Typed Forms
FormControl: Getting Started - Typed Forms
FormGroup and FormRecord - Typed Forms
Format commit messages for a pull request - Prepare a documentation update for a pull request
Forms - Example applications
Frequently Asked Questions - Getting started with NgOptimizedImage
Function calls are not supported - AOT metadata errors
Fundamentals - Example applications
Fundamentals of change detection - NgZone
Future - Angular Roadmap
General JSON structure - Angular workspace configuration
General examples - Component Lifecycle
Generate an application - Common Routing Tasks
Generate application variants for each locale - Merge translations into the application
Generation schematics - Angular workspace configuration
Geolocation example - Using observables for streams of values
Get user input from a template reference variable - User input
Get user input from the $event object - User input
Getting Started - Getting started with NgOptimizedImage
Getting error details - HTTP client - Handle request errors
Getting notified of new releases - Keeping your Angular projects up-to-date
Getting route information - Common Routing Tasks
Getting started - Angular documentation localization guidelines
Getting started - Creating libraries
Getting started - Introduction to Angular animations
Grouping form controls - Reactive forms
HTTP - Observables in Angular
HTTP client service features - Understanding communicating with backend services using HTTP
HTTP testing library - HTTP client - Test requests
HTTP-level vulnerabilities - Security
Handle interceptor events - HTTP - Intercept requests and responses
Handling events - How event binding works
Handling user events - Attribute directives
Help with documentation style - Angular documentation style guide
Highlighted breaking changes in Angular v16 - Update Angular to v16
Host directive semantics - Directive composition API
Hosting - Angular documentation localization guidelines
Hosting a directive without a DOM element - Built-in directives
How AOT works - Ahead-of-time (AOT) compilation
How Angular assigns values to template variables - Understanding template variables
How can I tell if an NgModule or service was previously loaded? - NgModule FAQ
How do I restrict service scope to a module? - NgModule FAQ
How do you enable hydration in Angular - Hydration
How does Angular find components, directives, and pipes in a template? What is a template reference? - NgModule FAQ
How the Language Service works - Angular Language Service
How to make a feature module - Feature modules
How to prerender a page - Prerendering (SSG)
How to skip hydration for particular components - Hydration
How two-way binding works - Two-way binding
HttpClientTestingModule - Testing services
Hybrid Angular applications - Example applications
Hydration - Server-side rendering
I18N - Hydration
ICU expressions - Prepare component for translation
Identify the active route - Using Angular routes in a single-page application
Identifying slow computations - Slow computations
Identifying unnecessary change detection calls - Resolving zone pollution
If all else fails - Resolve documentation linter messages
Images - Angular documentation style guide
Implement debouncing - HTTP - Optimize server interaction with debouncing
Import provideRouter from @angular/router - Using Angular routes in a single-page application
Importing a feature module - Feature modules
Importing modules - Frequently-used modules
Improving template type checking for custom directives - Structural directives
In progress - Angular Roadmap
Including inputs and outputs - Directive composition API
Index - Deprecated APIs and features
Initializing a component or directive - Component Lifecycle
Inject into a derived class - Dependency injection in action
Inject the component's DOM element - Dependency injection in action
Injecting a dependency - Understanding dependency injection
Injecting services - Creating an injectable service
Injecting services in other services - Creating an injectable service
Injector hierarchy and service instances - Providing dependencies in modules
Input setter coercion - Template type checking
Inputs and type-checking - Template type checking
Inspecting generated CSS - View encapsulation
Install libraries - Usage of Angular libraries published to npm
Install the Angular CLI - Setting up the local environment and workspace
Install the required software - Prepare to edit Angular documentation
Integrating with the CLI using code-generation schematics - Creating libraries
Interaction with native HTML form validation - Validating form input
Intercept input property changes with a setter - Component interaction
Intercept input property changes with ngOnChanges() - Component interaction
Interceptor order - HTTP - Intercept requests and responses
Ivy - Glossary
JIT API changes due to ViewEngine deprecation - Deprecated APIs and features
JavaScript - Glossary
JavaScript modules: Files containing code - JavaScript modules vs. NgModules
Key event filtering (with key.enter) - User input
Keyframes - Animation transitions and triggers
Kinds of Angular documentation - Angular documentation style guide
Known Issues - Getting started with the Angular CLI's new build system
Lazy Loading AngularJS - Upgrading from AngularJS to Angular
Lazy loading - Common Routing Tasks
Lazy loading basics - Lazy-loading feature modules
Learn about Angular basics - Understanding Angular
Learn about Angular dependency injection - Dependency injection in Angular
Learn about Angular internationalization - Angular Internationalization
Learn about Angular routing - Angular Routing
Learn about Angular's features - Angular developer guides
Learn about common Angular internationalization tasks - Common Internationalization tasks
Learn about optional Angular internationalization practices - Optional Internationalization practices
Learning about new features - Keeping your Angular projects up-to-date
Library project files - Workspace and project file structure
Lifecycle hooks - Angular coding style guide
Limitations - Migrate an existing Angular project to standalone
Limiting provider scope by lazy loading modules - Providing dependencies in modules
Limiting provider scope with components - Providing dependencies in modules
Link parameters array - Common Routing Tasks
Listing items with NgFor - Built-in directives
Live examples - Angular documentation style guide
Loading component styles - Component styles
Localize Angular documentation in a new language - Documentation contributors guide
LocationStrategy and browser URL styles - Common Routing Tasks
Log request and response pairs - HTTP - interceptor use-cases
Logical structure of the template - Hierarchical injectors
Make a DELETE request - HTTP: Send data to a server
Make a POST request - HTTP: Send data to a server
Make a PUT request - HTTP: Send data to a server
Make a major change - Documentation contributors guide
Make a minor change - Documentation contributors guide
Make a request - HTTP - Track and show request progress
Managing assets in a library - Creating libraries
Mark element attributes for translations - Prepare component for translation
Mark text in component code - Prepare component for translation
Mark text in component template - Prepare component for translation
Markdown and HTML - Angular documentation style guide
Migration modes - Migrate an existing Angular project to standalone
Migrations steps - Migrate an existing Angular project to standalone
Milestone 1: Getting started - Router tutorial: tour of heroes
Milestone 2: Routing module - Router tutorial: tour of heroes
Milestone 3: Heroes feature - Router tutorial: tour of heroes
Milestone 4: Crisis center feature - Router tutorial: tour of heroes
Milestone 5: Route guards - Router tutorial: tour of heroes
Milestone 6: Asynchronous routing - Router tutorial: tour of heroes
Mixing encapsulation modes - View encapsulation
Modifying service visibility - Hierarchical injectors
Modifying the configuration - Service worker configuration
More about Angular Modules - Launching your app with a root module
More about specific documentation linter messages - Resolve documentation linter messages
More information - Accessibility in Angular
More information - Angular Language Service
More information on testing - Testing
More on Angular animations - Animation transitions and triggers
More on Angular animations - Complex animation sequences
More on Angular animations - Introduction to Angular animations
More on Angular animations - Reusable animations
More on Angular animations - Route transition animations
More on Angular service workers - Getting started with service workers
More on Angular service workers - Service worker communication
More on Angular service workers - Service worker in production
More on Angular service workers - Service worker notifications
More on NgModules - Feature modules
More on NgModules - Frequently-used modules
More on NgModules - NgModule API
More on NgModules - NgModules
More on NgModules - Providing dependencies in modules
More on NgModules - Sharing modules
More on NgModules - Singleton services
More on NgModules and routing - Lazy-loading feature modules
More on dependency injection - Hierarchical injectors
More on template syntax - Template syntax
More on template syntax - Understanding templates
Multi-slot content projection - Content projection
Multiple animation triggers - Animation transitions and triggers
Multiple projects - Workspace and project file structure
Multiple service instances (sandboxing) - Dependency injection in action
Name expected - AOT metadata errors
Naming - Angular coding style guide
Navigation - Angular documentation style guide
Nested @defer blocks and avoiding cascading loads - Deferrable Views
Nested component tests - Component testing scenarios
Nesting routes - Common Routing Tasks
New features in Angular v15 - Update Angular to v15
New inputs to component with OnPush - Skipping component subtrees
Next step - Angular service worker introduction
Next step - Finish up a documentation pull request
Next step - Prepare a documentation update for a pull request
Next steps - Angular components overview
Next steps - Building dynamic forms
Next steps - Guidelines for creating NgModules
Next steps - Introduction to forms in Angular
Next steps - JavaScript modules vs. NgModules
Next steps - Prepare to edit Angular documentation
Next steps - Setting up the local environment and workspace
Next steps - Tutorial: Creating custom route matches
Next steps - Update a documentation pull request
Next steps - Using Angular routes in a single-page application
Next steps - What is Angular?
NgModule - Glossary
NgModules - Example applications
NgModules: Classes with metadata for compiling - JavaScript modules vs. NgModules
NgZone - NgZone
No errors reported - Build and test a documentation update
No visible side effects - Understanding binding
Notification click handling - Service worker notifications
Notification payload - Service worker notifications
Objectives - Building a template-driven form
Objectives - Router tutorial: tour of heroes
Objectives - Tutorial: Creating custom route matches
Objectives - Using Angular routes in a single-page application
Observable - Using observables for streams of values
Observable creation functions - The RxJS library
Observables compared to arrays - Observables compared to other techniques
Observables compared to events API - Observables compared to other techniques
Observables compared to promises - Observables compared to other techniques
On blur - User input
One structural directive per element - Structural directives
Only initialized variables and constants - AOT metadata errors
Operators - The RxJS library
Optimizations - Angular package format
Optimizing slow computations - Slow computations
Options - Add the localize package
Organization - What is Angular?
Override component providers - Component testing scenarios
Override current locale for CurrencyPipe - Format data based on locale
Overview - Deferrable Views
Overview of Typed Forms - Typed Forms
Overview of reactive forms - Reactive forms
Overview of template type checking - Template type checking
Parallel animation using group() function - Complex animation sequences
Parent and children communicate using a service - Component interaction
Parent calls an @ViewChild() - Component interaction
Parent interacts with child using local variable - Component interaction
Parent listens for child event - Component interaction
Partial compilation - Angular package format
Pass data from parent to child with input binding - Component interaction
Passing values into an attribute directive - Attribute directives
Peer dependencies - Creating libraries
Performance Features - Getting started with NgOptimizedImage
Phase 1: Code analysis - Ahead-of-time (AOT) compilation
Phase 2: code generation - Ahead-of-time (AOT) compilation
Phase 3: Template type checking - Ahead-of-time (AOT) compilation
PhoneCat Upgrade Tutorial - Upgrading from AngularJS to Angular
Pipes and precedence - Transforming Data Using Pipes
Polyfills - Browser support
Polyfills for non-CLI users - Browser support
Precedence and bindings from different sources - Style Precedence
Precedence and specificity - Style Precedence
Precedence of bindings and static attributes - Style Precedence
Predefined states and wildcard matching - Animation transitions and triggers
Prefetching - Deferrable Views
Preloading - Lazy-loading feature modules
Preparation - Upgrading for performance
Preparation - Upgrading from AngularJS to Angular
Prepare to edit the docs - Overview of Angular documentation editorial workflow
Prepare your branch for a pull request - Prepare a documentation update for a pull request
Prepare your pull request - Overview of Angular documentation editorial workflow
Preparing source code for code snippets - Angular documentation style guide
Prerequisites - Angular Routing
Prerequisites - Angular components overview
Prerequisites - Angular developer guides
Prerequisites - Angular documentation style guide
Prerequisites - Angular service worker introduction
Prerequisites - Attribute binding
Prerequisites - Building a template-driven form
Prerequisites - Building dynamic forms
Prerequisites - Class and style binding
Prerequisites - Common Internationalization tasks
Prerequisites - Complex animation sequences
Prerequisites - Component Lifecycle
Prerequisites - Dependency injection in Angular
Prerequisites - Displaying values with interpolation
Prerequisites - Event binding
Prerequisites - Getting started with service workers
Prerequisites - Introduction to Angular animations
Prerequisites - Introduction to forms in Angular
Prerequisites - Launching your app with a root module
Prerequisites - Migrate an existing Angular project to standalone
Prerequisites - Optional Internationalization practices
Prerequisites - Property binding
Prerequisites - Reactive forms
Prerequisites - Reusable animations
Prerequisites - Route transition animations
Prerequisites - Router tutorial: tour of heroes
Prerequisites - Service worker communication
Prerequisites - Service worker configuration
Prerequisites - Service worker in production
Prerequisites - Service worker notifications
Prerequisites - Setting up the local environment and workspace
Prerequisites - Setup for upgrading from AngularJS
Prerequisites - Template syntax
Prerequisites - Testing
Prerequisites - Transforming Data Using Pipes
Prerequisites - Tutorial: Creating custom route matches
Prerequisites - Two-way binding
Prerequisites - Typed Forms
Prerequisites - Understanding Angular
Prerequisites - Understanding communicating with backend services using HTTP
Prerequisites - Understanding template variables
Prerequisites - Understanding templates
Prerequisites - Using Angular routes in a single-page application
Prerequisites - Validating form input
Prerequisites - What is Angular?
Prevent reimport of the GreetingModule - Singleton services
Preventing cross-site scripting (XSS) - Security
Preventing unauthorized access - Common Routing Tasks
Production optimizations - Deployment
Profile your application - DevTools Overview
Project configuration options - Angular workspace configuration
Project tool configuration options - Angular workspace configuration
Projecting content in more complex environments - Content projection
Provide the interceptor - HTTP - Intercept requests and responses
Provider scope - Providing dependencies in modules
Provider token alternatives: class interface and 'InjectionToken' - Dependency injection in action
Providing a service - Providing dependencies in modules
Providing a singleton service - Singleton services
Providing dependency - Understanding dependency injection
Providing generation support - Schematics for libraries
Providing installation support - Schematics for libraries
Providing many interceptors - HTTP - Intercept requests and responses
Providing services in @Component() - Hierarchical injectors
Providing services in modules vs. components - Providing dependencies in modules
Proxying to a backend server - Building and serving Angular apps
Public API surface - Angular versioning and releases
Publishing libraries - Creating libraries
Publishing your library - Creating libraries
Put it all together - User input
Qualify dependency lookup with parameter decorators - Dependency injection in action
README.md - Angular package format
Reactive forms - Observables in Angular
Reactive forms API summary - Reactive forms
Read context values in an interceptor - HTTP - Pass metadata to interceptors
Reading and writing the DOM - Component Lifecycle
Reading signals in OnPush components - Angular Signals
Reading the full response - HTTP: Request data from a server
Reading the route parameters - Tutorial: Creating custom route matches
Refactoring parts of an application into a library - Creating libraries
Reference to a local (non-exported) symbol - AOT metadata errors
Reference to a non-exported class - AOT metadata errors
Reference to a non-exported function - AOT metadata errors
Related information - Workspace npm dependencies
Related resources - Angular service worker introduction
Release frequency - Angular versioning and releases
Removed APIs - Deprecated APIs and features
Rendering a feature module's component template - Feature modules
Rendering components dynamically - Dynamic component loader
Repeating elements when a condition is true - Built-in directives
Report missing translations - Merge translations into the application
Request non-JSON data - HTTP: Make a JSONP request
Requesting a typed response - HTTP: Request data from a server
Resolution modifiers - Hierarchical injectors
Resolution rules - Hierarchical injectors
Resolve circular dependencies with a forward class reference (forwardRef) - Dependency injection in action
Resource summary - Keeping your Angular projects up-to-date
Respond to a comment - Update a documentation pull request
Responding to lifecycle events - Component Lifecycle
Responsive programming - Next steps: tools and techniques
Retrying a failed request - HTTP client - Handle request errors
Return the proper type - Property binding best practices
Review the commit log of the upstream repo - Finish up a documentation pull request
Reviewing and updating a topic - Review documentation
Revise topics - Overview of Angular documentation editorial workflow
Route configuration - Route transition animations
Routed NgModules - Guidelines for creating NgModules
Routed components - Component testing scenarios
Router - Observables in Angular
Router events - Router reference
Router imports - Router reference
Router links - Router reference
Router outlet - Route transition animations
Router outlet - Router reference
Router state - Router reference
Router terminology - Router reference
Routine documentation maintenance tasks - Overview of documentation maintenance tasks
Routing - Accessibility in Angular
Routing - Example applications
Routing NgModules - Guidelines for creating NgModules
Routing and lazy-loading - Getting started with standalone components
Routing component - Component testing scenarios
Run tasks outside NgZone - Resolving zone pollution
Run the angular.io end-to-end test on your local computer - Build and test a documentation update
Run the application - Setting up the local environment and workspace
Run within an injection context - Injection context
Running your library schematic - Schematics for libraries
SVG syntax example - SVG as templates
Save your changes - Make and save changes to a documentation topic
Schedule and run - Angular CLI builders
Schematic options - Migrate an existing Angular project to standalone
Schematics CLI - Authoring schematics
Schematics CLI - Glossary
Schematics concepts - Authoring schematics
Schematics for the Angular CLI - Generating code using schematics
Sections - Angular documentation style guide
Select a documentation issue - Overview of Angular documentation editorial workflow
Sending data to a child component - Sharing data between child and parent directives and components
Sending data to a parent component - Sharing data between child and parent directives and components
Sequential vs. parallel animations - Complex animation sequences
Server communication - Example applications
Server configuration - Deployment
Server-side rendering - Glossary
Service NgModules - Guidelines for creating NgModules
Service examples - Creating an injectable service
Service examples - Introduction to services and dependency injection
Service worker and caching of application resources - Service worker in production
Service worker configuration properties - Service worker configuration
Service worker in action: a tour - Getting started with service workers
Service worker safety - Service worker in production
Service workers in Angular - Angular service worker introduction
Services - Angular coding style guide
Services - What is Angular?
Services and dependency injection - Introduction to Angular concepts
Services with dependencies - Testing services
Set context values when making a request - HTTP - Pass metadata to interceptors
Set default headers - HTTP - interceptor use-cases
Set the source locale ID - Refer to locales by ID
Set up testing - Testing
Set up your workspaces - Prepare to edit Angular documentation
Setting an element property to a component property value - Property binding
Setting inline styles with NgStyle - Built-in directives
Setting the page title - Common Routing Tasks
Setting up redirects - Common Routing Tasks
Setting up the form model - Introduction to forms in Angular
Setting up wildcard routes - Common Routing Tasks
Setup for testing - HTTP client - Test requests
Setup with module imports - Component testing scenarios
Shared NgModules - Guidelines for creating NgModules
Should I add application-wide providers to the root AppModule or the root AppComponent? - NgModule FAQ
Should I add other providers to a module or a component? - NgModule FAQ
Should I add the generic type when I add new ModuleWithProviders types to my application? - ModuleWithProviders Migration
Should I import BrowserModule or CommonModule? - NgModule FAQ
Simple deployment options - Deployment
Single responsibility - Angular coding style guide
Single-slot content projection - Content projection
Source code - User input
Special selectors - Component styles
Specifying a component's CSS selector - Angular components overview
Specifying a provider token - Configuring dependency providers
Stack frame in context - Injection context
Starting the development server - Getting started with the Angular CLI's new build system
Starting the request - HTTP: Request data from a server
Statement best practices - Template statements
Statement context - Template statements
Step 1: Generate an application - App shell
Step 2: Create the application shell - App shell
Step 3: Verify the application is built with the shell content - App shell
Step-by-step setup - Lazy-loading feature modules
Strategies to improve your documentation - Resolve documentation linter messages
Structural directive shorthand - Structural directives
Structural directive syntax reference - Structural directives
Style sheets - AngularJS to Angular concepts: Quick reference
Style vocabulary - Angular coding style guide
Styling precedence - Class and style binding
Submit the form with ngSubmit - Building a template-driven form
Subscribing - Using observables for streams of values
Summary - Angular CLI builders
Summary - Building a template-driven form
Summary - User input
Summary of NgModule categories - Guidelines for creating NgModules
Support for the development cycle - Next steps: tools and techniques
Support policy and schedule - Angular versioning and releases
SwUpdate service - Service worker communication
Switching cases with NgSwitch - Built-in directives
Symbol reference expected - AOT metadata errors
Syntax - Attribute binding
Syntax - Template statements
Syntax - Understanding binding
Syntax - Understanding template expressions
Syntax - Understanding template variables
Table of contents - Angular documentation style guide
Tagged template expressions are not supported - AOT metadata errors
Template basics - AngularJS to Angular concepts: Quick reference
Template directives - AngularJS to Angular concepts: Quick reference
Template input variable - Understanding template variables
Template options - Angular compiler options
Template syntax - Introduction to components and templates
Template variable scope - Understanding template variables
Templates and views - Introduction to components and templates
Test for errors - HTTP client - Test requests
Test your custom URL matcher - Tutorial: Creating custom route matches
Test your documentation - Make and save changes to a documentation topic
TestBed class summary - Testing Utility APIs
Testing - Deferrable Views
Testing - Introduction to forms in Angular
Testing HTTP services - Testing services
Testing a builder - Angular CLI builders
Testing in continuous integration - Testing
Testing services with the TestBed - Testing services
Testing the HighlightDirective - Testing Attribute Directives
Testing the TitleCasePipe - Testing Pipes
Testing without beforeEach() - Testing services
The $any() type cast function - Template expression operators
The ComponentFixture - Testing Utility APIs
The base tag - Deployment
The basic NgModule - NgModules
The bootstrap array - Launching your app with a root module
The declarations array - Launching your app with a root module
The deploy url - Deployment
The forRoot() pattern - Singleton services
The imports array - Launching your app with a root module
The next object - HTTP - Intercept requests and responses
The non-null assertion operator (!) - Template expression operators
The observe and responseType options - HTTP: Request data from a server
The providers array - Launching your app with a root module
The query() function - Complex animation sequences
The sample application in action - Router tutorial: tour of heroes
Third Party Libraries with DOM Manipulation - Hydration
Title - Angular documentation style guide
To update search keywords in a topic - Update search keywords
Toggling button features - Property binding
Tour of Heroes tutorial application - Example applications
Track control states - Building a template-driven form
Track form states - Building a template-driven form
Track request progress - HTTP - Track and show request progress
Transforming components to custom elements - Angular elements overview
Transforming data with parameters and chained pipes - Transforming Data Using Pipes
Transition :increment and :decrement - Animation transitions and triggers
Translate alternate expressions - Work with translation files
Translate each translation file - Work with translation files
Translate nested expressions - Work with translation files
Translate plurals - Work with translation files
Transmitting data between components - Observables in Angular
Trees - Angular documentation style guide
Triggers - Deferrable Views
Troubleshooting lazy-loading modules - Lazy-loading feature modules
Troubleshooting template errors - Template type checking
Type-ahead suggestions - Practical observable usage
TypeScript - Glossary
TypeScript configuration file - Glossary
TypeScript typings - TypeScript configuration
Types of data binding - Binding syntax
Types of injector hierarchies - Hierarchical injectors
Typings for custom elements - Angular elements overview
Understanding the flow of data - Property binding
Unimplemented options and behavior - Getting started with the Angular CLI's new build system
Unsupported Angular versions - Version compatibility
Unsupported enum member name - AOT metadata errors
Unwrapping data from an observable - Transforming Data Using Pipes
Update Angular CLI applications - Update Angular to v14
Update dependency versions - Setup for upgrading from AngularJS
Update the last reviewed date - Review documentation
Update your component with router-outlet - Using Angular routes in a single-page application
Update your fork from the upstream repo - Finish up a documentation pull request
Update your fork with the upstream repo - Start to edit a documentation topic
Updating libraries - Usage of Angular libraries published to npm
Updating your environment and apps - Keeping your Angular projects up-to-date
Upgrading with ngUpgrade - Upgrading for performance
Upgrading with ngUpgrade - Upgrading from AngularJS to Angular
Use DatePipe to display the current date - Format data based on locale
Use a page object - Component testing scenarios
Use interceptors to request multiple values - HTTP - interceptor use-cases
Using @Input() and @Output() together - Sharing data between child and parent directives and components
Using Angular Service Worker - Server-side rendering
Using DI outside of a context - Injection context
Using OnPush - Skipping component subtrees
Using a pipe in a template - Transforming Data Using Pipes
Using ahead-of-time compilation with hybrid apps - Upgrading for performance
Using an InjectionToken object - Configuring dependency providers
Using change detection hooks - Component Lifecycle
Using component styles - Component styles
Using custom elements - Angular elements overview
Using downgradeModule() - Upgrading for performance
Using lightweight injection tokens - Optimizing client application size with lightweight injection tokens
Using relative paths - Common Routing Tasks
Using standalone components in NgModule-based applications - Getting started with standalone components
Using the FormBuilder service to generate controls - Reactive forms
Using the Unified Angular Location Service - Upgrading from AngularJS to Angular
Using the switchMap() operator - HTTP - Optimize server interaction with debouncing
Using your own library in applications - Creating libraries
Validating form input - Reactive forms
Validating input in reactive forms - Validating form input
Validating input in template-driven forms - Validating form input
Variable specifying a name - Understanding template variables
View Engine - Glossary
Vite as a development server - Getting started with the Angular CLI's new build system
What are signals? - Angular Signals
What classes should I add to the declarations array? - NgModule FAQ
What classes should I not add to declarations? - NgModule FAQ
What does "Can't bind to 'x' since it isn't a known property of 'y'" mean? - NgModule FAQ
What does this mean for libraries? - ModuleWithProviders Migration
What does this schematic do? - ModuleWithProviders Migration
What happens after you open a pull request - Open a documentation pull request
What if I import the same module twice? - NgModule FAQ
What if two modules provide the same service? - NgModule FAQ
What is a declarable? - NgModule FAQ
What is a pipe - Understanding Pipes
What is hydration - Hydration
What is the Angular compiler? - NgModule FAQ
What is the forRoot() method? - NgModule FAQ
What kinds of modules should I have and how should I use them? - NgModule FAQ
What should I do if the schematic prints a TODO comment? - ModuleWithProviders Migration
What should I export? - NgModule FAQ
What should I import? - NgModule FAQ
What should I not export? - NgModule FAQ
What to localize - Angular documentation localization guidelines
What's Next - Displaying values with interpolation
What's in the QuickStart seed? - Setup for upgrading from AngularJS
What's next - Add the localize package
What's next - Built-in directives
What's next - Configuring dependency providers
What's next - Creating an injectable service
What's next - Event binding
What's next - Format data based on locale
What's next - Introduction to Angular concepts
What's next - Merge translations into the application
What's next - Prepare component for translation
What's next - Property binding
What's next - Refer to locales by ID
What's next - Understanding binding
What's next - Understanding communicating with backend services using HTTP
What's next - Understanding dependency injection
What's next - Understanding template expressions
What's next - Work with translation files
What's the difference between NgModules and JavaScript Modules? - NgModule FAQ
What’s next - Attribute binding
What’s next - Class and style binding
What’s next - Understanding template variables
When to use the lightweight injection token pattern - Optimizing client application size with lightweight injection tokens
When tokens are retained - Optimizing client application size with lightweight injection tokens
Which dependencies are defer-loadable? - Deferrable Views
Why does lazy loading create a child injector? - NgModule FAQ
Why is a service provided in a feature module visible everywhere? - NgModule FAQ
Why is a service provided in a lazy-loaded module visible only to that module? - NgModule FAQ
Why is hydration important? - Hydration
Why is it bad if a shared module provides a service to a lazy-loaded module? - NgModule FAQ
Why is this migration necessary? - ModuleWithProviders Migration
Why list the same component in multiple NgModule properties? - NgModule FAQ
Why specify a package format? - Angular package format
Why use Deferrable Views? - Deferrable Views
Why use SSR? - Server-side rendering
Widget NgModules - Guidelines for creating NgModules
Work in the correct working branch - Make and save changes to a documentation topic
Workflow - Example applications
Working with components - Example applications
Working with templates - Example applications
Workspace configuration files - Workspace and project file structure
Write an interceptor - HTTP - Intercept requests and responses
Writing DOM tests to support a pipe test - Testing Pipes
Zones and async lifecycle hooks - NgZone
Zones and execution contexts - NgZone
ahead-of-time (AOT) compilation - Glossary
annotation - Glossary
app-shell - Glossary
attribute directive - Glossary
binding - Glossary
bootstrap - Glossary
builder - Glossary
case types - Glossary
change detection - Glossary
class decorator - Glossary
class field decorator - Glossary
collection - Glossary
command-line interface (CLI) - Glossary
component - Glossary
configuration - Glossary
content projection - Glossary
custom element - Glossary
data binding - Glossary
declarable - Glossary
decorator | decoration - Glossary
dependency injection (DI) - Glossary
directive - Glossary
domain-specific language (DSL) - Glossary
dynamic component loading - Glossary
eager loading - Glossary
element - Glossary
entry point - Glossary
forRoot() and forChild() - Lazy-loading feature modules
form control - Glossary
form model - Glossary
form validation - Glossary
fr-CA and en-US example - Example Angular Internationalization application
i18n metadata for translation - Prepare component for translation
immutability - Glossary
import example for French - Import global variants of the locale data
injectable - Glossary
injector - Glossary
input - Glossary
interpolation - Glossary
just-in-time (JIT) compilation - Glossary
lazy loading - Glossary
library - Glossary
lifecycle hook - Glossary
module - Glossary
ngc - Glossary
npm package - Glossary
observable - Glossary
observer - Glossary
output - Glossary
package.json - Angular package format
package.json - Workspace npm dependencies
pipe - Glossary
platform - Glossary
polyfill - Glossary
project - Glossary
providedIn and NgModules - Providing dependencies in modules
provider - Glossary
reactive forms - Glossary
resolver - Glossary
route guard - Glossary
router - Glossary
router outlet - Glossary
routing component - Glossary
rule - Glossary
schematic - Glossary
scoped package - Glossary
server-side rendering - Glossary
service - Glossary
standalone - Glossary
structural directive - Glossary
subscriber - Glossary
target - Glossary
template - Glossary
template expression - Glossary
template input variable - Glossary
template reference variable - Glossary
template-driven forms - Glossary
toObservable - RxJS Interop
toSignal - RxJS Interop
token - Glossary
transpile - Glossary
tree - Glossary
unidirectional data flow - Glossary
view - Glossary
view hierarchy - Glossary
web component - Glossary
workspace - Glossary
workspace configuration - Glossary
zone - Glossary

Types