Public AngularTS AnchorScrollService contract exposed through the ng namespace.

Main AngularTS runtime entry point with the full built-in ng module configured by default.

Runtime metadata returned after defining a standalone custom element.

Configuration for the application module that owns the custom element.

Options for a standalone AngularTS-backed custom element runtime.

Main AngularTS runtime entry point with the full built-in ng module configured by default.

Public AngularTS AnimateService contract exposed through the ng namespace.

Public AngularTS AnimationContext contract exposed through the ng namespace.

Public AngularTS AnimationHandle contract exposed through the ng namespace.

Public AngularTS AnimationLifecycleCallback contract exposed through the ng namespace.

Public AngularTS AnimationOptions contract exposed through the ng namespace.

Public AngularTS AnimationPhase contract exposed through the ng namespace.

Public AngularTS AnimationPreset contract exposed through the ng namespace.

Public AngularTS AnimationPresetHandler contract exposed through the ng namespace.

Public AngularTS AnimationResult contract exposed through the ng namespace.

Public AngularTS AnnotatedDirectiveFactory contract exposed through the ng namespace.

Dependency-annotated factory array used by AngularTS DI system. Example: [‘dep1’, ‘dep2’, (dep1, dep2) => new MyController(dep1, dep2)]

Public AngularTS AppComponentOptions contract exposed through the ng namespace.

Public AngularTS AriaConfig contract exposed through the ng namespace.

Public AngularTS AriaService contract exposed through the ng namespace.

Configuration for CachedRestBackend.

Boolean class map consumed by ng-class. Each key is a CSS class name. Truthy values add the class; false, null, and undefined remove it.

Public shape accepted by ng-class for class binding expressions.

Entry point for the $compile service.

Defines a component’s configuration object (a simplified directive definition object).

Component registration accepted by NgModule.component(). Programmatic and template-based rendering strategies are mutually exclusive.

Public AngularTS ConnectionConfig contract exposed through the ng namespace.

Public AngularTS ConnectionEvent contract exposed through the ng namespace.

AngularTS component lifecycle interface. Directive controllers have a well-defined lifecycle. Each controller can implement “lifecycle hooks”. These are methods that will be called by Angular at certain points in the life cycle of the directive. https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks https://docs.angularjs.org/guide/component

A controller constructor function used in AngularTS.

Public AngularTS ControllerService contract exposed through the ng namespace.

Public AngularTS CookieOptions contract exposed through the ng namespace.

High-level API for reading, writing, serializing, and removing browser cookies through the injectable $cookie service.

Serialization options for cookie-backed stores.

Public AngularTS CurrencyFilterOptions contract exposed through the ng namespace.

Defines the structure of an AngularTS directive.

A compile function used to prepare directives before linking.

A controller instance or object map used in directives.

Public AngularTS DirectiveFactory contract exposed through the ng namespace.

Public AngularTS DirectiveFactoryFn contract exposed through the ng namespace.

Public AngularTS DirectiveLinkFn contract exposed through the ng namespace.

Defines optional pre/post link functions in directive compile phase.

Supported directive matching locations.

The Document interface represents any web page loaded in the browser and serves as an entry point into the web page’s content, which is the DOM tree. MDN Reference

Public AngularTS ElementScopeOptions contract exposed through the ng namespace.

Element is the most general base class from which all element objects (i.e., objects that represent elements) in a Document inherit. MDN Reference

Creates a new entity instance from raw response data.

Public AngularTS EntryFilterItem contract exposed through the ng namespace.

Controls how values embedded in framework error messages are formatted.

Public AngularTS EventBusConfig contract exposed through the ng namespace.

Application-wide asynchronous publish/subscribe utility. EventBus powers $eventBus for cross-boundary domain events, browser callbacks, worker messages, realtime messages, and non-Angular integrations. It is intentionally not a state store and should not replace scope events for parent/child scope-tree communication.

Public AngularTS EventDeliveryPolicy contract exposed through the ng namespace.

Public AngularTS EventDeliveryPolicyContext contract exposed through the ng namespace.

A callback type for handling errors.

A JavaScript expression represented as a string, typically used in interpolation bindings. Example: html <span title="{{ attrBinding }}">{{ textBinding }}</span>

Public AngularTS FilterFactory contract exposed through the ng namespace.

Public AngularTS FilterFn contract exposed through the ng namespace.

Public AngularTS FilterService contract exposed through the ng namespace.

Declarative config accepted by NgModule.config({ $htmlCanvas: ... }). The integration is disabled by default and has no AngularTS fallback.

Public AngularTS HtmlCanvasRuntimeSupport contract exposed through the ng namespace.

Public AngularTS HtmlCanvasService contract exposed through the ng namespace.

Default request settings configured through app.config({ $http }) and exposed at runtime through $http.defaults. Not every HttpRequestOptions field is supported here; this shape only includes the fields that the runtime reads from provider-level defaults. https://docs.angularjs.org/api/ng/service/http#defaults https://docs.angularjs.org/api/ng/service/http#usage

HTTP method accepted by HttpRequestConfig.method.

Function that serializes query params into a URL-encoded string.

Full request configuration accepted by $http(...). See http://docs.angularjs.org/api/ng/service/$http#usage

Request options shared by the $http shortcut methods. See http://docs.angularjs.org/api/ng/service/$http#usage

Response object returned by $http requests.

Final transport status reported by transport completion handlers.

Runtime surface of the $http service. Call the service directly with a full HttpRequestConfig, or use a shorthand method for common HTTP verbs. All methods return an Promise<HttpResponse<T>> that resolves for successful 2xx responses and rejects with HttpError for errors.

Public AngularTS Injectable contract exposed through the ng namespace.

Public injectable contracts keyed by their canonical runtime token. Every single-dollar token exposed by PublicInjectionTokens must map to a named, documented contract here. Double-dollar framework internals are intentionally excluded.

Injector for factories and services

Delimiter configuration accepted by NgModule.config().

Public AngularTS InterpolateService contract exposed through the ng namespace.

Public AngularTS InterpolationFunction contract exposed through the ng namespace.

A function returned by the $compile service that links a compiled template to a scope.

Public watcher callback shape. The first argument is the resolved watched value. The second argument is the original target object used when the watcher was registered.

Public AngularTS LocationService contract exposed through the ng namespace.

Declarative remote logging configuration for navigator.sendBeacon().

Converts a structured log entry into a Beacon-compatible request body.

Structured record passed to a configured Beacon serializer.

Logging severity attached to a structured remote log entry.

Service for logging messages at various levels.

Public AngularTS Machine contract exposed through the ng namespace.

Public AngularTS MachineConfig contract exposed through the ng namespace.

Labeled type contract carried by a machine definition and instance.

Public AngularTS MachineSendResult contract exposed through the ng namespace.

Public AngularTS MachineSendStatus contract exposed through the ng namespace.

Public AngularTS MachineService contract exposed through the ng namespace.

Public AngularTS MachineSnapshot contract exposed through the ng namespace.

Public AngularTS Model contract exposed through the ng namespace.

Public AngularTS ModelChange contract exposed through the ng namespace.

Public AngularTS ModelRestoreOptions contract exposed through the ng namespace.

Public AngularTS ModelSyncFailureMode contract exposed through the ng namespace.

Public AngularTS ModelSyncOptions contract exposed through the ng namespace.

Public AngularTS ModelSyncTarget contract exposed through the ng namespace.

Public AngularTS NgModelController contract exposed through the ng namespace.

Modules are collections of application configuration information for components: controllers, directives, filters, etc. They provide recipes for the injector to do the actual instantiation. A module itself has no behaviour but only state. A such, it acts as a data structure between the Angular instance and the injector service.

Params declared by one route in a public route map.

Parses a string or expression function into a compiled expression.

Public AngularTS Policy contract exposed through the ng namespace.

Public AngularTS PolicyContext contract exposed through the ng namespace.

Public AngularTS PolicyDecision contract exposed through the ng namespace.

Programmatic real-DOM factory used instead of a template.

DOM content accepted from a programmatic view. Readers are reactive, arrays are flattened recursively, and existing nodes are moved rather than cloned.

Runtime context passed to a programmatic component or directive view.

Primitive accepted as a programmatic view child. Booleans render no content.

Typed DOM properties plus arbitrary attribute and custom-element values.

Static value or reactive reader accepted by a programmatic view property.

Factory that creates one real DOM element without parsing HTML.

Typed HTML tag factories. Calling the object with a namespace URI returns factories for namespaced elements such as SVG and MathML.

A user-defined service recipe accepted by ng.NgModule.provider. Object recipes define an injectable get factory directly. Injectable functions and classes are instantiated first and must produce an object with an injectable get factory.

Public AngularTS RealtimeProtocolEventDetail contract exposed through the ng namespace.

Public AngularTS RealtimeProtocolMessage contract exposed through the ng namespace.

Resolve values declared by one route in a public route map.

Backend abstraction used by RestService. Implement this interface to route REST operations through $http, IndexedDB, the Cache API, a test double, or a composed backend such as CachedRestBackend.

Public AngularTS RestCachePolicy contract exposed through the ng namespace.

Public AngularTS RestCachePolicyContext contract exposed through the ng namespace.

Async cache store used by CachedRestBackend. The interface is deliberately small so implementations can be backed by IndexedDB, the browser Cache API, local storage, memory, or test fixtures.

Cache read strategies shared by HTTP, REST, and router transports.

Factory service exposed as $rest. Creates a typed RestService for a base URL, optional entity mapper, and optional backend request defaults.

Extra backend options merged into requests made by a REST resource.

Normalized request object passed from RestService to a RestBackend. Backends receive expanded URLs and already-separated request options, so they can focus on transport, persistence, or cache policy.

Response shape returned by RestBackend implementations. HTTP-backed responses may include the usual HttpResponse metadata, while local or cached backends can return only data plus optional cache source metadata.

Event emitted after a stale-while-revalidate background refresh succeeds.

Typed REST resource client backed by RestBackend. A RestService is usually created by injecting $rest and calling it with a base URL, optional EntityClass, and optional backend request defaults.

The HTMLElement interface represents any HTML element. MDN Reference

Scope class for the Proxy. It intercepts operations like property access (get) and property setting (set), and adds support for deep change tracking and observer-like behavior.

Public route contract entry used by router helper types. This is an author-written TypeScript shape. It is intentionally separate from built router state records so generated docs and language bindings do not expose internal state/runtime implementation details.

Public route-name to route-contract map used by StateService, generic Transition, ParamsOf, and ResolvesOf.

Public AngularTS RouterConfig contract exposed through the ng namespace.

Public AngularTS RouterModule contract exposed through the ng namespace.

Module-owned router state tree declaration. Use this with NgModule.router when a module owns a route subtree. Child state names are relative to their parent unless they contain a dot.

Derives the public route map for a literal router(...) tree.

Public AngularTS SceDelegateService contract exposed through the ng namespace.

Public AngularTS SceService contract exposed through the ng namespace.

Scope class for the Proxy. It intercepts operations like property access (get) and property setting (set), and adds support for deep change tracking and observer-like behavior.

Native custom element base class backed by an AngularTS child scope.

Public AngularTS ScopeElementConstructor contract exposed through the ng namespace.

Event object passed to emit and broadcast listeners. Tracks target scope, current scope, name, propagation/default flags, and control methods.

Scope class for the Proxy. It intercepts operations like property access (get) and property setting (set), and adds support for deep change tracking and observer-like behavior.

Public AngularTS SecurityConfig contract exposed through the ng namespace.

Public AngularTS SecurityCredentialsConfig contract exposed through the ng namespace.

Public AngularTS SecurityPolicy contract exposed through the ng namespace.

Declarative defaults used when registering an application service worker. This config intentionally maps only browser registration options and safe observation policy. Activation, reload, cache strategy, push, and background sync remain explicit application or adapter policy.

Stable failure codes reported by ServiceWorkerError.

Message event normalized by $serviceWorker.

Explicit message target for $serviceWorker.post(...).

Options for ServiceWorkerService.post.

Template-friendly snapshot of the current registration.

Per-request options for ServiceWorkerService.request.

Injectable service-worker lifecycle and messaging facade.

Template-friendly snapshot of update-related service-worker state.

SSE-specific configuration

Managed SSE connection object returned by $sse. Provides a safe way to close the connection and stop reconnection attempts.

$sse service type Returns a managed SSE connection that automatically reconnects when needed.

The StateDeclaration object is used to define a state or nested state. #### Example: js // StateDeclaration object var foldersState = { name: 'folders', url: '/folders', component: FoldersComponent, resolve: { allfolders: ['FolderService', function(FolderService) { return FolderService.list(); }] }, } registry.register(foldersState);

Public AngularTS StatePolicyDeclaration contract exposed through the ng namespace.

Public $stateRegistry contract for dynamic route registration. Module-owned static routes should normally use NgModule.router. Use this service when routes must be added or removed at runtime.

Public AngularTS StateService contract exposed through the ng namespace.

Public AngularTS StorageBackend contract exposed through the ng namespace.

Creates a proxy that automatically persists an object’s state into a storage backend whenever a property is set. The proxy also restores previously serialized state on creation and persists deletions in addition to property assignments.

Built-in persistent storage backends understood by NgModule.store().

Public AngularTS StreamService contract exposed through the ng namespace.

Possible values for data-swap and realtime protocol swap fields. Union type representing all possible DOM insertion modes.

Public contract implemented by the $templateCache injectable.

Downloads a template using $http and, upon success, stores the contents inside of $templateCache. If the HTTP request fails or the response data of the HTTP request is empty then a $compile error will be thrown (unless {ignoreRequestError} is set to true).

A function passed to directive link functions for transcluded content. It behaves like a linking function, with the scope argument automatically created as a new child of the transcluded parent scope. The function returns the DOM content to be injected (transcluded) into the directive.

Represents a transition between two states. A transition contains the source and destination states, parameters, resolves, and the states entered or exited during navigation.

Names the destination and source routes carried by a typed transition.

This interface specifies the api for registering Transition Hooks. Both the TransitionService and also the Transition object itself implement this interface. Note: the Transition object only allows hooks to be registered before the Transition is started.

Public AngularTS Validator contract exposed through the ng namespace.

Active connection between one AngularTS target and a WebAssembly guest.

Options for binding one reactive target to a WebAssembly guest.

Standard WebAssembly compilation options forwarded without translation.

Structured error raised by the high-level WebAssembly host.

Error categories reported by the high-level WebAssembly host.

Lifecycle stage at which a WebAssembly operation failed.

Declarative options for loading one WebAssembly module.

Loaded WebAssembly module with owned reactive bindings and lifecycle.

Lifecycle state of a WebAssembly resource.

High-level WebAssembly host service.

Source accepted by the WebAssembly loader.

Scope class for the Proxy. It intercepts operations like property access (get) and property setting (set), and adds support for deep change tracking and observer-like behavior.

Application-wide defaults for scoped custom elements.

Public AngularTS WebComponentContext contract exposed through the ng namespace.

Public AngularTS WebComponentInput contract exposed through the ng namespace.

Public AngularTS WebComponentInputConfig contract exposed through the ng namespace.

Public AngularTS WebComponentInputs contract exposed through the ng namespace.

Public AngularTS WebComponentService contract exposed through the ng namespace.

WebSocket-specific configuration

Managed WebSocket connection returned by $websocket.

Public AngularTS WebSocketService contract exposed through the ng namespace.

Public AngularTS WebTransportBufferInput contract exposed through the ng namespace.

Options passed to $webTransport.

Managed WebTransport connection returned by $webTransport. The connection wraps the browser-native WebTransport object and keeps its promise/stream model visible while adding small conveniences for sending bytes, text, datagrams, and unidirectional streams.

Event emitted for each incoming WebTransport datagram.

Event passed to WebTransport reconnect and renegotiation hooks.

Delay, in milliseconds, before a reconnect attempt is opened.

Factory function exposed as $webTransport.

The Window interface represents a window containing a DOM document; the document property points to the DOM document loaded in that window. MDN Reference

Native worker options plus AngularTS decoding and restart policy.

Typed failure reported by a managed worker.

Public AngularTS WorkerErrorCode contract exposed through the ng namespace.

Managed, scope-bindable handle to one page-owned Web Worker.

Standard messages used by WorkerHandle.model.

Request envelope understood by WorkerHandle.request.

Options for one correlated worker request.

Response envelope returned for a correlated worker request.

Injectable factory for typed managed Web Worker connections.

Lifecycle state exposed by a managed WorkerHandle.

Public AngularTS Workflow contract exposed through the ng namespace.

Public AngularTS WorkflowCommand contract exposed through the ng namespace.

Public AngularTS WorkflowCommandContext contract exposed through the ng namespace.

Input and output carried by a workflow command.

Public AngularTS WorkflowCommandDefinition contract exposed through the ng namespace.

Labeled type contract carried by a workflow definition and instance.

Public AngularTS WorkflowResult contract exposed through the ng namespace.

Public AngularTS WorkflowService contract exposed through the ng namespace.

Public AngularTS WorkflowSnapshot contract exposed through the ng namespace.

Public AngularTS WorkflowSupervisor contract exposed through the ng namespace.

Public AngularTS WorkflowSupervisorConfig contract exposed through the ng namespace.

Public AngularTS WorkflowSupervisorPersistence contract exposed through the ng namespace.

Built-in IndexedDB persistence selected by a workflow supervisor.

Public AngularTS WorkflowSupervisorService contract exposed through the ng namespace.

Public AngularTS WorkflowSupervisorSnapshot contract exposed through the ng namespace.