@types/angular

  • Version 1.8.3
  • Published
  • 179 kB
  • No dependencies
  • MIT license

Install

npm i @types/angular
yarn add @types/angular
pnpm add @types/angular

Overview

TypeScript definitions for Angular JS

Index

Variables

Interfaces

Type Aliases

Namespaces

Variables

variable angular

var angular: ng.IAngularStatic;

    Interfaces

    interface HttpHeaderType

    interface HttpHeaderType {}

      index signature

      [requestType: string]: string | ((config: IRequestConfig) => string);

        interface IAnchorScrollProvider

        interface IAnchorScrollProvider extends IServiceProvider {}

          method disableAutoScrolling

          disableAutoScrolling: () => void;

            interface IAnchorScrollService

            interface IAnchorScrollService {}

              property yOffset

              yOffset: any;

                call signature

                (): void;

                  call signature

                  (hash: string): void;

                    interface IAngularBootstrapConfig

                    interface IAngularBootstrapConfig {}

                      property strictDi

                      strictDi?: boolean | undefined;

                        interface IAngularEvent

                        interface IAngularEvent {}

                          property currentScope

                          currentScope: IScope;
                          • the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.

                          property defaultPrevented

                          defaultPrevented: boolean;
                          • true if preventDefault was called.

                          property name

                          name: string;
                          • name of the event.

                          property targetScope

                          targetScope: IScope;
                          • the scope on which the event was $emit-ed or $broadcast-ed.

                          method preventDefault

                          preventDefault: () => void;
                          • calling preventDefault sets defaultPrevented flag to true.

                          method stopPropagation

                          stopPropagation: () => void;
                          • calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed).

                          interface IAngularStatic

                          interface IAngularStatic {}

                            property element

                            element: JQueryStatic;
                            • Wraps a raw DOM element or HTML string as a jQuery element.

                              If jQuery is available, angular.element is an alias for the jQuery function. If jQuery is not available, angular.element delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."

                            property version

                            version: {
                            full: string;
                            major: number;
                            minor: number;
                            dot: number;
                            codeName: string;
                            };

                              method bind

                              bind: (context: any, fn: Function, ...args: any[]) => Function;

                                method bootstrap

                                bootstrap: (
                                element: string | Element | JQuery | Document,
                                modules?: Array<string | Function | any[]>,
                                config?: IAngularBootstrapConfig
                                ) => auto.IInjectorService;
                                • Use this function to manually start up angular application.

                                  Parameter element

                                  DOM element which is the root of angular application.

                                  Parameter modules

                                  An array of modules to load into the application. Each item in the array should be the name of a predefined module or a (DI annotated) function that will be invoked by the injector as a config block.

                                  Parameter config

                                  an object for defining configuration options for the application. The following keys are supported: - strictDi: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.

                                method copy

                                copy: <T>(source: T, destination?: T) => T;
                                • Creates a deep copy of source, which should be an object or an array.

                                  - If no destination is supplied, a copy of the object or array is created. - If a destination is provided, all of its elements (for array) or properties (for objects) are deleted and then all elements/properties from the source are copied to it. - If source is not an object or array (inc. null and undefined), source is returned. - If source is identical to 'destination' an exception will be thrown.

                                  Parameter source

                                  The source that will be used to make a copy. Can be any type, including primitives, null, and undefined.

                                  Parameter destination

                                  Destination into which the source is copied. If provided, must be of the same type as source.

                                method equals

                                equals: (value1: any, value2: any) => boolean;

                                  method errorHandlingConfig

                                  errorHandlingConfig: {
                                  (): IErrorHandlingConfig;
                                  (config: IErrorHandlingConfig): void;
                                  };
                                  • Configure several aspects of error handling in AngularJS if used as a setter or return the current configuration if used as a getter

                                  method extend

                                  extend: (destination: any, ...sources: any[]) => any;

                                    method forEach

                                    forEach: {
                                    <T, U extends ArrayLike<T> = T[]>(
                                    obj: U,
                                    iterator: (value: U[number], key: number, obj: U) => void,
                                    context?: any
                                    ): U;
                                    <T>(
                                    obj: { [index: string]: T },
                                    iterator: (value: T, key: string, obj: { [index: string]: T }) => void,
                                    context?: any
                                    ): { [index: string]: T };
                                    (
                                    obj: any,
                                    iterator: (value: any, key: any, obj: any) => void,
                                    context?: any
                                    ): any;
                                    };
                                    • Invokes the iterator function once for each item in obj collection, which can be either an object or an array. The iterator function is invoked with iterator(value, key), where value is the value of an object property or an array element and key is the object property key or array element index. Specifying a context for the function is optional.

                                      It is worth noting that .forEach does not iterate over inherited properties because it filters using the hasOwnProperty method.

                                      Parameter obj

                                      Object to iterate over.

                                      Parameter iterator

                                      Iterator function.

                                      Parameter context

                                      Object to become context (this) for the iterator function.

                                    method fromJson

                                    fromJson: (json: string) => any;

                                      method identity

                                      identity: <T>(arg?: T) => T;

                                        method injector

                                        injector: (modules?: any[], strictDi?: boolean) => auto.IInjectorService;

                                          method isArray

                                          isArray: (value: any) => value is any[];

                                            method isDate

                                            isDate: (value: any) => value is Date;

                                              method isDefined

                                              isDefined: (value: any) => boolean;

                                                method isElement

                                                isElement: (value: any) => boolean;

                                                  method isFunction

                                                  isFunction: (value: any) => value is Function;

                                                    method isNumber

                                                    isNumber: (value: any) => value is number;

                                                      method isObject

                                                      isObject: { (value: any): value is Object; <T>(value: any): value is T };

                                                        method isString

                                                        isString: (value: any) => value is string;

                                                          method isUndefined

                                                          isUndefined: (value: any) => boolean;

                                                            method merge

                                                            merge: (dst: any, ...src: any[]) => any;
                                                            • Deeply extends the destination object dst by copying own enumerable properties from the src object(s) to dst. You can specify multiple src objects. If you want to preserve original objects, you can do so by passing an empty object as the target: var object = angular.merge({}, object1, object2).

                                                              Unlike extend(), merge() recursively descends into object properties of source objects, performing a deep copy.

                                                              Parameter dst

                                                              Destination object.

                                                              Parameter src

                                                              Source object(s).

                                                            method module

                                                            module: (
                                                            name: string,
                                                            requires?: string[],
                                                            configFn?: Injectable<Function>
                                                            ) => IModule;
                                                            • The angular.module is a global place for creating, registering and retrieving Angular modules. All modules (angular core or 3rd party) that should be available to an application must be registered using this mechanism.

                                                              When passed two or more arguments, a new module is created. If passed only one argument, an existing module (the name passed as the first argument to module) is retrieved.

                                                              Parameter name

                                                              The name of the module to create or retrieve.

                                                              Parameter requires

                                                              The names of modules this module depends on. If specified then new module is being created. If unspecified then the module is being retrieved for further configuration.

                                                              Parameter configFn

                                                              Optional configuration function for the module.

                                                            method noop

                                                            noop: (...args: any[]) => void;

                                                              method reloadWithDebugInfo

                                                              reloadWithDebugInfo: () => void;

                                                                method resumeBootstrap

                                                                resumeBootstrap: (extraModules?: string[]) => ng.auto.IInjectorService;
                                                                • If window.name contains prefix NG_DEFER_BOOTSTRAP! when angular.bootstrap is called, the bootstrap process will be paused until angular.resumeBootstrap() is called.

                                                                  Parameter extraModules

                                                                  An optional array of modules that should be added to the original list of modules that the app was about to be bootstrapped with.

                                                                method toJson

                                                                toJson: (obj: any, pretty?: boolean | number) => string;

                                                                  method UNSAFE_restoreLegacyJqLiteXHTMLReplacement

                                                                  UNSAFE_restoreLegacyJqLiteXHTMLReplacement: () => void;
                                                                  • Restores the pre-1.8 behavior of jqLite that turns XHTML-like strings like <div /><span /> to <div></div><span></span> instead of <div><span></span></div>. The new behavior is a security fix so if you use this method, please try to adjust to the change & remove the call as soon as possible. Note that this only patches jqLite. If you use jQuery 3.5.0 or newer, please read [jQuery 3.5 upgrade guide](https://jquery.com/upgrade-guide/3.5/) for more details about the workarounds.

                                                                  interface IAsyncModelValidators

                                                                  interface IAsyncModelValidators {}

                                                                    index signature

                                                                    [index: string]: (modelValue: any, viewValue: any) => IPromise<any>;

                                                                      interface IAttributes

                                                                      interface IAttributes {}

                                                                        property $attr

                                                                        $attr: Object;
                                                                        • A map of DOM element attribute names to the normalized name. This is needed to do reverse lookup from normalized name back to actual name.

                                                                        method $addClass

                                                                        $addClass: (classVal: string) => void;
                                                                        • Adds the CSS class value specified by the classVal parameter to the element. If animations are enabled then an animation will be triggered for the class addition.

                                                                        method $normalize

                                                                        $normalize: (name: string) => string;
                                                                        • Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with x- or data-) to its normalized, camelCase form.

                                                                          Also there is special case for Moz prefix starting with upper case letter.

                                                                          For further information check out the guide on

                                                                          See Also

                                                                          • https://docs.angularjs.org/guide/directive#matching-directives

                                                                        method $observe

                                                                        $observe: <T>(name: string, fn: (value?: T) => any) => Function;
                                                                        • Observes an interpolated attribute. The observer function will be invoked once during the next $digest following compilation. The observer is then invoked whenever the interpolated value changes.

                                                                        method $removeClass

                                                                        $removeClass: (classVal: string) => void;
                                                                        • Removes the CSS class value specified by the classVal parameter from the element. If animations are enabled then an animation will be triggered for the class removal.

                                                                        method $set

                                                                        $set: (key: string, value: any) => void;
                                                                        • Set DOM element attribute value.

                                                                        method $updateClass

                                                                        $updateClass: (newClasses: string, oldClasses: string) => void;
                                                                        • Adds and removes the appropriate CSS class values to the element based on the difference between the new and old CSS class values (specified as newClasses and oldClasses).

                                                                        index signature

                                                                        [name: string]: any;
                                                                        • this is necessary to be able to access the scoped attributes. it's not very elegant because you have to use attrs['foo'] instead of attrs.foo but I don't know of a better way this should really be limited to return string but it creates this problem: http://stackoverflow.com/q/17201854/165656

                                                                        interface IAugmentedJQuery

                                                                        interface IAugmentedJQuery extends JQLite {}

                                                                          interface IAugmentedJQueryStatic

                                                                          interface IAugmentedJQueryStatic extends JQueryStatic {}
                                                                          • These interfaces are kept for compatibility with older versions of these type definitions. Actually, Angular doesn't create a special subclass of jQuery objects. It extends jQuery.prototype like jQuery plugins do, that's why all jQuery objects have these Angular-specific methods, not only those returned from angular.element. See: http://docs.angularjs.org/api/angular.element

                                                                          interface ICacheFactoryService

                                                                          interface ICacheFactoryService {}
                                                                          • $cacheFactory - service in module ng

                                                                            Factory that constructs Cache objects and gives access to them.

                                                                            see https://docs.angularjs.org/api/ng/service/$cacheFactory

                                                                          method get

                                                                          get: (cacheId: string) => ICacheObject;
                                                                          • Get access to a cache object by the cacheId used when it was created.

                                                                            Parameter cacheId

                                                                            Name or id of a cache to access.

                                                                          method info

                                                                          info: () => any;
                                                                          • Get information about all the caches that have been created.

                                                                            Returns

                                                                            key-value map of cacheId to the result of calling cache#info

                                                                          call signature

                                                                          (cacheId: string, optionsMap?: { capacity?: number | undefined }): ICacheObject;
                                                                          • Factory that constructs Cache objects and gives access to them.

                                                                            Parameter cacheId

                                                                            Name or id of the newly created cache.

                                                                            Parameter optionsMap

                                                                            Options object that specifies the cache behavior. Properties:

                                                                            capacity — turns the cache into LRU cache.

                                                                          interface ICacheObject

                                                                          interface ICacheObject {}
                                                                          • $cacheFactory.Cache - type in module ng

                                                                            A cache object used to store and retrieve data, primarily used by $http and the script directive to cache templates and other data.

                                                                            see https://docs.angularjs.org/api/ng/type/$cacheFactory.Cache

                                                                          method destroy

                                                                          destroy: () => void;
                                                                          • Destroys the Cache object entirely, removing it from the $cacheFactory set.

                                                                          method get

                                                                          get: <T>(key: string) => T | undefined;
                                                                          • Retrieves named data stored in the Cache object.

                                                                            Parameter key

                                                                            the key of the data to be retrieved

                                                                          method info

                                                                          info: () => { id: string; size: number };
                                                                          • Retrieve information regarding a particular Cache.

                                                                          method put

                                                                          put: <T>(key: string, value?: T) => T;
                                                                          • Inserts a named entry into the Cache object to be retrieved later, and incrementing the size of the cache if the key was not already present in the cache. If behaving like an LRU cache, it will also remove stale entries from the set.

                                                                            It will not insert undefined values into the cache.

                                                                            Parameter key

                                                                            the key under which the cached data is stored.

                                                                            Parameter value

                                                                            the value to store alongside the key. If it is undefined, the key will not be stored.

                                                                          method remove

                                                                          remove: (key: string) => void;
                                                                          • Removes an entry from the Cache object.

                                                                            Parameter key

                                                                            the key of the entry to be removed

                                                                          method removeAll

                                                                          removeAll: () => void;
                                                                          • Clears the cache object of any entries.

                                                                          interface IChangesObject

                                                                          interface IChangesObject<T> {}

                                                                            property currentValue

                                                                            currentValue: T;

                                                                              property previousValue

                                                                              previousValue: T;

                                                                                method isFirstChange

                                                                                isFirstChange: () => boolean;

                                                                                  interface ICloneAttachFunction

                                                                                  interface ICloneAttachFunction {}

                                                                                    call signature

                                                                                    (clonedElement?: JQLite, scope?: IScope): any;

                                                                                      interface ICompiledExpression

                                                                                      interface ICompiledExpression {}

                                                                                        property constant

                                                                                        constant: boolean;

                                                                                          property literal

                                                                                          literal: boolean;

                                                                                            method assign

                                                                                            assign: (context: any, value: any) => any;

                                                                                              call signature

                                                                                              (context: any, locals?: any): any;

                                                                                                interface ICompileProvider

                                                                                                interface ICompileProvider extends IServiceProvider {}

                                                                                                  method aHrefSanitizationTrustedUrlList

                                                                                                  aHrefSanitizationTrustedUrlList: {
                                                                                                  (): RegExp;
                                                                                                  (regexp: RegExp): ICompileProvider;
                                                                                                  };

                                                                                                    method aHrefSanitizationWhitelist

                                                                                                    aHrefSanitizationWhitelist: { (): RegExp; (regexp: RegExp): ICompileProvider };
                                                                                                    • Deprecated

                                                                                                      The old name of aHrefSanitizationTrustedUrlList. Kept for compatibility.

                                                                                                    method commentDirectivesEnabled

                                                                                                    commentDirectivesEnabled: { (): boolean; (enabled: boolean): ICompileProvider };
                                                                                                    • It indicates to the compiler whether or not directives on comments should be compiled. It results in a compilation performance gain since the compiler doesn't have to check comments when looking for directives. Defaults to true. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#commentDirectivesEnabled

                                                                                                    method component

                                                                                                    component: {
                                                                                                    (name: string, options: IComponentOptions): ICompileProvider;
                                                                                                    (object: { [componentName: string]: IComponentOptions }): ICompileProvider;
                                                                                                    };

                                                                                                      method cssClassDirectivesEnabled

                                                                                                      cssClassDirectivesEnabled: { (): boolean; (enabled: boolean): ICompileProvider };
                                                                                                      • It indicates to the compiler whether or not directives on element classes should be compiled. It results in a compilation performance gain since the compiler doesn't have to check element classes when looking for directives. Defaults to true. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#cssClassDirectivesEnabled

                                                                                                      method debugInfoEnabled

                                                                                                      debugInfoEnabled: { (): boolean; (enabled: boolean): ICompileProvider };

                                                                                                        method directive

                                                                                                        directive: {
                                                                                                        <
                                                                                                        TScope extends IScope = IScope,
                                                                                                        TElement extends JQLite = JQLite,
                                                                                                        TAttributes extends IAttributes = IAttributes,
                                                                                                        TController extends IDirectiveController = IController
                                                                                                        >(
                                                                                                        name: string,
                                                                                                        directiveFactory: Injectable<
                                                                                                        IDirectiveFactory<TScope, TElement, TAttributes, TController>
                                                                                                        >
                                                                                                        ): ICompileProvider;
                                                                                                        <
                                                                                                        TScope extends IScope = IScope,
                                                                                                        TElement extends JQLite = JQLite,
                                                                                                        TAttributes extends IAttributes = IAttributes,
                                                                                                        TController extends IDirectiveController = IController
                                                                                                        >(object: {
                                                                                                        [directiveName: string]: Injectable<
                                                                                                        IDirectiveFactory<TScope, TElement, TAttributes, TController>
                                                                                                        >;
                                                                                                        }): ICompileProvider;
                                                                                                        };

                                                                                                          method imgSrcSanitizationTrustedUrlList

                                                                                                          imgSrcSanitizationTrustedUrlList: {
                                                                                                          (): RegExp;
                                                                                                          (regexp: RegExp): ICompileProvider;
                                                                                                          };

                                                                                                            method imgSrcSanitizationWhitelist

                                                                                                            imgSrcSanitizationWhitelist: { (): RegExp; (regexp: RegExp): ICompileProvider };
                                                                                                            • Deprecated

                                                                                                              The old name of imgSrcSanitizationTrustedUrlList. Kept for compatibility.

                                                                                                            method onChangesTtl

                                                                                                            onChangesTtl: { (): number; (limit: number): ICompileProvider };
                                                                                                            • Sets the number of times $onChanges hooks can trigger new changes before giving up and assuming that the model is unstable. Increasing the TTL could have performance implications, so you should not change it without proper justification. Default: 10. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#onChangesTtl

                                                                                                            method strictComponentBindingsEnabled

                                                                                                            strictComponentBindingsEnabled: {
                                                                                                            (): boolean;
                                                                                                            (enabled: boolean): ICompileProvider;
                                                                                                            };
                                                                                                            • Call this method to enable/disable strict component bindings check. If enabled, the compiler will enforce that for all bindings of a component that are not set as optional with ?, an attribute needs to be provided on the component's HTML tag. Defaults to false. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#strictComponentBindingsEnabled

                                                                                                            interface ICompileService

                                                                                                            interface ICompileService {}

                                                                                                              call signature

                                                                                                              (
                                                                                                              element: string | Element | JQuery,
                                                                                                              transclude?: ITranscludeFunction,
                                                                                                              maxPriority?: number
                                                                                                              ): ITemplateLinkingFunction;

                                                                                                                interface IComponentController

                                                                                                                interface IComponentController extends IController {}
                                                                                                                • Same as IController. Keeping it for compatibility with older versions of these type definitions.

                                                                                                                interface IComponentOptions

                                                                                                                interface IComponentOptions {}
                                                                                                                • Component definition object (a simplified directive definition object)

                                                                                                                property bindings

                                                                                                                bindings?: { [boundProperty: string]: string } | undefined;
                                                                                                                • Define DOM attribute binding to component properties. Component properties are always bound to the component controller and not to the scope.

                                                                                                                property controller

                                                                                                                controller?: string | Injectable<IControllerConstructor> | undefined;
                                                                                                                • Controller constructor function that should be associated with newly created scope or the name of a registered controller if passed as a string. Empty function by default. Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

                                                                                                                property controllerAs

                                                                                                                controllerAs?: string | undefined;
                                                                                                                • An identifier name for a reference to the controller. If present, the controller will be published to its scope under the specified name. If not present, this will default to '$ctrl'.

                                                                                                                property require

                                                                                                                require?: { [controller: string]: string } | undefined;
                                                                                                                • Requires the controllers of other directives and binds them to this component's controller. The object keys specify the property names under which the required controllers (object values) will be bound. Note that the required controllers will not be available during the instantiation of the controller, but they are guaranteed to be available just before the $onInit method is executed!

                                                                                                                property template

                                                                                                                template?: string | Injectable<(...args: any[]) => string> | undefined;
                                                                                                                • html template as a string or a function that returns an html template as a string which should be used as the contents of this component. Empty string by default. If template is a function, then it is injected with the following locals: $element - Current element $attrs - Current attributes object for the element Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

                                                                                                                property templateUrl

                                                                                                                templateUrl?: string | Injectable<(...args: any[]) => string> | undefined;
                                                                                                                • Path or function that returns a path to an html template that should be used as the contents of this component. If templateUrl is a function, then it is injected with the following locals: $element - Current element $attrs - Current attributes object for the element Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

                                                                                                                property transclude

                                                                                                                transclude?: boolean | { [slot: string]: string } | undefined;
                                                                                                                • Whether transclusion is enabled. Disabled by default.

                                                                                                                interface IController

                                                                                                                interface IController {}
                                                                                                                • 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

                                                                                                                method $doCheck

                                                                                                                $doCheck: () => void;
                                                                                                                • Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes. Any actions that you wish to take in response to the changes that you detect must be invoked from this hook; implementing this has no effect on when $onChanges is called. For example, this hook could be useful if you wish to perform a deep equality check, or to check a Date object, changes to which would not be detected by Angular's change detector and thus not trigger $onChanges. This hook is invoked with no arguments; if detecting changes, you must store the previous value(s) for comparison to the current values.

                                                                                                                method $onChanges

                                                                                                                $onChanges: (onChangesObj: IOnChangesObject) => void;
                                                                                                                • Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound properties that have changed, and the values are an IChangesObject object of the form { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as cloning the bound value to prevent accidental mutation of the outer value.

                                                                                                                method $onDestroy

                                                                                                                $onDestroy: () => void;
                                                                                                                • Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources, watches and event handlers.

                                                                                                                method $onInit

                                                                                                                $onInit: () => void;
                                                                                                                • Called on each controller after all the controllers on an element have been constructed and had their bindings initialized (and before the pre & post linking functions for the directives on this element). This is a good place to put initialization code for your controller.

                                                                                                                $postLink: () => void;
                                                                                                                • Called after this controller's element and its children have been linked. Similar to the post-link function this hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain templateUrl directives will not have been compiled and linked since they are waiting for their template to load asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather different in Angular 1 there is no direct mapping and care should be taken when upgrading.

                                                                                                                index signature

                                                                                                                [s: string]: any;

                                                                                                                  interface IControllerLocals

                                                                                                                  interface IControllerLocals {}
                                                                                                                  • The minimal local definitions required by $controller(ctrl, locals) calls.

                                                                                                                  property $element

                                                                                                                  $element: JQuery;

                                                                                                                    property $scope

                                                                                                                    $scope: ng.IScope;

                                                                                                                      interface IControllerProvider

                                                                                                                      interface IControllerProvider extends IServiceProvider {}

                                                                                                                        method register

                                                                                                                        register: {
                                                                                                                        (name: string, controllerConstructor: Function): void;
                                                                                                                        (name: string, dependencyAnnotatedConstructor: any[]): void;
                                                                                                                        };

                                                                                                                          interface IControllerService

                                                                                                                          interface IControllerService {}

                                                                                                                            call signature

                                                                                                                            <T>(controllerConstructor: new (...args: any[]) => T, locals?: any): T;

                                                                                                                              call signature

                                                                                                                              <T>(controllerConstructor: (...args: any[]) => T, locals?: any): T;

                                                                                                                                call signature

                                                                                                                                <T>(controllerName: string, locals?: any): T;

                                                                                                                                  interface IDeferred

                                                                                                                                  interface IDeferred<T> {}

                                                                                                                                    property promise

                                                                                                                                    promise: IPromise<T>;

                                                                                                                                      method notify

                                                                                                                                      notify: (state?: any) => void;

                                                                                                                                        method reject

                                                                                                                                        reject: (reason?: any) => void;

                                                                                                                                          method resolve

                                                                                                                                          resolve: (value?: T | IPromise<T>) => void;

                                                                                                                                            interface IDirective

                                                                                                                                            interface IDirective<
                                                                                                                                            TScope extends IScope = IScope,
                                                                                                                                            TElement extends JQLite = JQLite,
                                                                                                                                            TAttributes extends IAttributes = IAttributes,
                                                                                                                                            TController extends IDirectiveController = IController
                                                                                                                                            > {}

                                                                                                                                              property bindToController

                                                                                                                                              bindToController?: boolean | { [boundProperty: string]: string } | undefined;
                                                                                                                                              • Deprecation warning: although bindings for non-ES6 class controllers are currently bound to this before the controller constructor is called, this use is now deprecated. Please place initialization code that relies upon bindings inside a $onInit method on the controller, instead.

                                                                                                                                              property compile

                                                                                                                                              compile?:
                                                                                                                                              | IDirectiveCompileFn<TScope, TElement, TAttributes, TController>
                                                                                                                                              | undefined;

                                                                                                                                                property controller

                                                                                                                                                controller?: string | Injectable<IControllerConstructor> | undefined;

                                                                                                                                                  property controllerAs

                                                                                                                                                  controllerAs?: string | undefined;
                                                                                                                                                    link?:
                                                                                                                                                    | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
                                                                                                                                                    | IDirectivePrePost<TScope, TElement, TAttributes, TController>
                                                                                                                                                    | undefined;

                                                                                                                                                      property multiElement

                                                                                                                                                      multiElement?: boolean | undefined;

                                                                                                                                                        property priority

                                                                                                                                                        priority?: number | undefined;

                                                                                                                                                          property replace

                                                                                                                                                          replace?: boolean | undefined;
                                                                                                                                                          • Deprecated

                                                                                                                                                          property require

                                                                                                                                                          require?: string | string[] | { [controller: string]: string } | undefined;

                                                                                                                                                            property restrict

                                                                                                                                                            restrict?: string | undefined;

                                                                                                                                                              property scope

                                                                                                                                                              scope?: boolean | { [boundProperty: string]: string } | undefined;

                                                                                                                                                                property template

                                                                                                                                                                template?:
                                                                                                                                                                | string
                                                                                                                                                                | ((tElement: TElement, tAttrs: TAttributes) => string)
                                                                                                                                                                | undefined;

                                                                                                                                                                  property templateNamespace

                                                                                                                                                                  templateNamespace?: string | undefined;

                                                                                                                                                                    property templateUrl

                                                                                                                                                                    templateUrl?:
                                                                                                                                                                    | string
                                                                                                                                                                    | ((tElement: TElement, tAttrs: TAttributes) => string)
                                                                                                                                                                    | undefined;

                                                                                                                                                                      property terminal

                                                                                                                                                                      terminal?: boolean | undefined;

                                                                                                                                                                        property transclude

                                                                                                                                                                        transclude?: boolean | 'element' | { [slot: string]: string } | undefined;

                                                                                                                                                                          interface IDirectiveCompileFn

                                                                                                                                                                          interface IDirectiveCompileFn<
                                                                                                                                                                          TScope extends IScope = IScope,
                                                                                                                                                                          TElement extends JQLite = JQLite,
                                                                                                                                                                          TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                          TController extends IDirectiveController = IController
                                                                                                                                                                          > {}

                                                                                                                                                                            call signature

                                                                                                                                                                            (
                                                                                                                                                                            templateElement: TElement,
                                                                                                                                                                            templateAttributes: TAttributes,
                                                                                                                                                                            /**
                                                                                                                                                                            * @deprecated
                                                                                                                                                                            * Note: The transclude function that is passed to the compile function is deprecated,
                                                                                                                                                                            * as it e.g. does not know about the right outer scope. Please use the transclude function
                                                                                                                                                                            * that is passed to the link function instead.
                                                                                                                                                                            */
                                                                                                                                                                            transclude: ITranscludeFunction
                                                                                                                                                                            ):
                                                                                                                                                                            | void
                                                                                                                                                                            | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
                                                                                                                                                                            | IDirectivePrePost<TScope, TElement, TAttributes, TController>;

                                                                                                                                                                              interface IDirectiveFactory

                                                                                                                                                                              interface IDirectiveFactory<
                                                                                                                                                                              TScope extends IScope = IScope,
                                                                                                                                                                              TElement extends JQLite = JQLite,
                                                                                                                                                                              TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                              TController extends IDirectiveController = IController
                                                                                                                                                                              > {}

                                                                                                                                                                                call signature

                                                                                                                                                                                (...args: any[]):
                                                                                                                                                                                | IDirective<TScope, TElement, TAttributes, TController>
                                                                                                                                                                                | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>;

                                                                                                                                                                                  interface IDirectiveLinkFn

                                                                                                                                                                                  interface IDirectiveLinkFn<
                                                                                                                                                                                  TScope extends IScope = IScope,
                                                                                                                                                                                  TElement extends JQLite = JQLite,
                                                                                                                                                                                  TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                                  TController extends IDirectiveController = IController
                                                                                                                                                                                  > {}

                                                                                                                                                                                    call signature

                                                                                                                                                                                    (
                                                                                                                                                                                    scope: TScope,
                                                                                                                                                                                    instanceElement: TElement,
                                                                                                                                                                                    instanceAttributes: TAttributes,
                                                                                                                                                                                    controller?: TController,
                                                                                                                                                                                    transclude?: ITranscludeFunction
                                                                                                                                                                                    ): void;

                                                                                                                                                                                      interface IDirectivePrePost

                                                                                                                                                                                      interface IDirectivePrePost<
                                                                                                                                                                                      TScope extends IScope = IScope,
                                                                                                                                                                                      TElement extends JQLite = JQLite,
                                                                                                                                                                                      TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                                      TController extends IDirectiveController = IController
                                                                                                                                                                                      > {}

                                                                                                                                                                                        property post

                                                                                                                                                                                        post?: IDirectiveLinkFn<TScope, TElement, TAttributes, TController> | undefined;

                                                                                                                                                                                          property pre

                                                                                                                                                                                          pre?: IDirectiveLinkFn<TScope, TElement, TAttributes, TController> | undefined;

                                                                                                                                                                                            interface IDoCheck

                                                                                                                                                                                            interface IDoCheck {}
                                                                                                                                                                                            • Interface for the $doCheck lifecycle hook https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks

                                                                                                                                                                                            method $doCheck

                                                                                                                                                                                            $doCheck: () => void;
                                                                                                                                                                                            • Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes. Any actions that you wish to take in response to the changes that you detect must be invoked from this hook; implementing this has no effect on when $onChanges is called. For example, this hook could be useful if you wish to perform a deep equality check, or to check a Date object, changes to which would not be detected by Angular's change detector and thus not trigger $onChanges. This hook is invoked with no arguments; if detecting changes, you must store the previous value(s) for comparison to the current values.

                                                                                                                                                                                            interface IDocumentService

                                                                                                                                                                                            interface IDocumentService extends JQLite {}

                                                                                                                                                                                              index signature

                                                                                                                                                                                              [index: number]: HTMLElement & Document;

                                                                                                                                                                                                interface IErrorHandlingConfig

                                                                                                                                                                                                interface IErrorHandlingConfig {}

                                                                                                                                                                                                  property objectMaxDepth

                                                                                                                                                                                                  objectMaxDepth?: number | undefined;
                                                                                                                                                                                                  • The max depth for stringifying objects. Setting to a non-positive or non-numeric value, removes the max depth limit 5

                                                                                                                                                                                                  property urlErrorParamsEnabled

                                                                                                                                                                                                  urlErrorParamsEnabled?: boolean | undefined;
                                                                                                                                                                                                  • Specifies whether the generated error url will contain the parameters of the thrown error. Disabling the parameters can be useful if the generated error url is very long. true;

                                                                                                                                                                                                  interface IExceptionHandlerService

                                                                                                                                                                                                  interface IExceptionHandlerService {}

                                                                                                                                                                                                    call signature

                                                                                                                                                                                                    (exception: Error, cause?: string): void;

                                                                                                                                                                                                      interface IFilterCurrency

                                                                                                                                                                                                      interface IFilterCurrency {}

                                                                                                                                                                                                        call signature

                                                                                                                                                                                                        (amount: number, symbol?: string, fractionSize?: number): string;
                                                                                                                                                                                                        • Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default symbol for current locale is used.

                                                                                                                                                                                                          Parameter amount

                                                                                                                                                                                                          Input to filter.

                                                                                                                                                                                                          Parameter symbol

                                                                                                                                                                                                          Currency symbol or identifier to be displayed.

                                                                                                                                                                                                          Parameter fractionSize

                                                                                                                                                                                                          Number of decimal places to round the amount to, defaults to default max fraction size for current locale Formatted number

                                                                                                                                                                                                        interface IFilterDate

                                                                                                                                                                                                        interface IFilterDate {}

                                                                                                                                                                                                          call signature

                                                                                                                                                                                                          (date: Date | number | string, format?: string, timezone?: string): string;
                                                                                                                                                                                                          • Formats date to a string based on the requested format.

                                                                                                                                                                                                            Parameter date

                                                                                                                                                                                                            Date to format either as Date object, milliseconds (string or number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.sssZ and its shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is specified in the string input, the time is considered to be in the local timezone.

                                                                                                                                                                                                            Parameter format

                                                                                                                                                                                                            Formatting rules (see Description). If not specified, mediumDate is used.

                                                                                                                                                                                                            Parameter timezone

                                                                                                                                                                                                            Timezone to be used for formatting. It understands UTC/GMT and the continental US time zone abbreviations, but for general use, use a time zone offset, for example, '+0430' (4 hours, 30 minutes east of the Greenwich meridian) If not specified, the timezone of the browser will be used. Formatted string or the input if input is not recognized as date/millis.

                                                                                                                                                                                                          interface IFilterFilter

                                                                                                                                                                                                          interface IFilterFilter {}

                                                                                                                                                                                                            call signature

                                                                                                                                                                                                            <T>(
                                                                                                                                                                                                            array: T[],
                                                                                                                                                                                                            expression:
                                                                                                                                                                                                            | string
                                                                                                                                                                                                            | IFilterFilterPatternObject
                                                                                                                                                                                                            | IFilterFilterPredicateFunc<T>,
                                                                                                                                                                                                            comparator?: IFilterFilterComparatorFunc<T> | boolean
                                                                                                                                                                                                            ): T[];

                                                                                                                                                                                                              interface IFilterFilterComparatorFunc

                                                                                                                                                                                                              interface IFilterFilterComparatorFunc<T> {}

                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                (actual: T, expected: T): boolean;

                                                                                                                                                                                                                  interface IFilterFilterPatternObject

                                                                                                                                                                                                                  interface IFilterFilterPatternObject {}

                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                    [name: string]: any;

                                                                                                                                                                                                                      interface IFilterFilterPredicateFunc

                                                                                                                                                                                                                      interface IFilterFilterPredicateFunc<T> {}

                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                        (value: T, index: number, array: T[]): boolean;

                                                                                                                                                                                                                          interface IFilterFunction

                                                                                                                                                                                                                          interface IFilterFunction extends Function {}

                                                                                                                                                                                                                            property $stateful

                                                                                                                                                                                                                            $stateful?: boolean | undefined;
                                                                                                                                                                                                                            • By default, filters are only run once the input value changes. By marking the filter as $stateful, the filter will be run on every $digest to update the output. **This is strongly discouraged.** See https://docs.angularjs.org/guide/filter#stateful-filters

                                                                                                                                                                                                                            interface IFilterJson

                                                                                                                                                                                                                            interface IFilterJson {}

                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                              (object: any, spacing?: number): string;
                                                                                                                                                                                                                              • Allows you to convert a JavaScript object into JSON string.

                                                                                                                                                                                                                                Parameter object

                                                                                                                                                                                                                                Any JavaScript object (including arrays and primitive types) to filter.

                                                                                                                                                                                                                                Parameter spacing

                                                                                                                                                                                                                                The number of spaces to use per indentation, defaults to 2. JSON string.

                                                                                                                                                                                                                              interface IFilterLimitTo

                                                                                                                                                                                                                              interface IFilterLimitTo {}

                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                <T>(input: T[], limit: string | number, begin?: string | number): T[];
                                                                                                                                                                                                                                • Creates a new array containing only a specified number of elements. The elements are taken from either the beginning or the end of the source array, string or number, as specified by the value and sign (positive or negative) of limit.

                                                                                                                                                                                                                                  Parameter input

                                                                                                                                                                                                                                  Source array to be limited.

                                                                                                                                                                                                                                  Parameter limit

                                                                                                                                                                                                                                  The length of the returned array. If the limit number is positive, limit number of items from the beginning of the source array/string are copied. If the number is negative, limit number of items from the end of the source array are copied. The limit will be trimmed if it exceeds array.length. If limit is undefined, the input will be returned unchanged.

                                                                                                                                                                                                                                  Parameter begin

                                                                                                                                                                                                                                  Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0. A new sub-array of length limit or less if input array had less than limit elements.

                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                input: string | number,
                                                                                                                                                                                                                                limit: string | number,
                                                                                                                                                                                                                                begin?: string | number
                                                                                                                                                                                                                                ): string;
                                                                                                                                                                                                                                • Creates a new string containing only a specified number of elements. The elements are taken from either the beginning or the end of the source string or number, as specified by the value and sign (positive or negative) of limit. If a number is used as input, it is converted to a string.

                                                                                                                                                                                                                                  Parameter input

                                                                                                                                                                                                                                  Source string or number to be limited.

                                                                                                                                                                                                                                  Parameter limit

                                                                                                                                                                                                                                  The length of the returned string. If the limit number is positive, limit number of items from the beginning of the source string are copied. If the number is negative, limit number of items from the end of the source string are copied. The limit will be trimmed if it exceeds input.length. If limit is undefined, the input will be returned unchanged.

                                                                                                                                                                                                                                  Parameter begin

                                                                                                                                                                                                                                  Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0. A new substring of length limit or less if input had less than limit elements.

                                                                                                                                                                                                                                interface IFilterLowercase

                                                                                                                                                                                                                                interface IFilterLowercase {}

                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                  (value: string): string;
                                                                                                                                                                                                                                  • Converts string to lowercase.

                                                                                                                                                                                                                                  interface IFilterNumber

                                                                                                                                                                                                                                  interface IFilterNumber {}

                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                    (value: number | string, fractionSize?: number | string): string;
                                                                                                                                                                                                                                    • Formats a number as text.

                                                                                                                                                                                                                                      Parameter number

                                                                                                                                                                                                                                      Number to format.

                                                                                                                                                                                                                                      Parameter fractionSize

                                                                                                                                                                                                                                      Number of decimal places to round the number to. If this is not provided then the fraction size is computed from the current locale's number formatting pattern. In the case of the default locale, it will be 3. Number rounded to decimalPlaces and places a “,” after each third digit.

                                                                                                                                                                                                                                    interface IFilterOrderBy

                                                                                                                                                                                                                                    interface IFilterOrderBy {}

                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                      <T>(
                                                                                                                                                                                                                                      array: T[],
                                                                                                                                                                                                                                      expression:
                                                                                                                                                                                                                                      | string
                                                                                                                                                                                                                                      | ((value: T) => any)
                                                                                                                                                                                                                                      | Array<((value: T) => any) | string>,
                                                                                                                                                                                                                                      reverse?: boolean,
                                                                                                                                                                                                                                      comparator?: IFilterOrderByComparatorFunc
                                                                                                                                                                                                                                      ): T[];
                                                                                                                                                                                                                                      • Orders a specified array by the expression predicate. It is ordered alphabetically for strings and numerically for numbers. Note: if you notice numbers are not being sorted as expected, make sure they are actually being saved as numbers and not strings.

                                                                                                                                                                                                                                        Parameter array

                                                                                                                                                                                                                                        The array to sort.

                                                                                                                                                                                                                                        Parameter expression

                                                                                                                                                                                                                                        A predicate to be used by the comparator to determine the order of elements.

                                                                                                                                                                                                                                        Parameter reverse

                                                                                                                                                                                                                                        Reverse the order of the array.

                                                                                                                                                                                                                                        Parameter comparator

                                                                                                                                                                                                                                        Function used to determine the relative order of value pairs. An array containing the items from the specified collection, ordered by a comparator function based on the values computed using the expression predicate.

                                                                                                                                                                                                                                      interface IFilterOrderByComparatorFunc

                                                                                                                                                                                                                                      interface IFilterOrderByComparatorFunc {}

                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                        (left: IFilterOrderByItem, right: IFilterOrderByItem): -1 | 0 | 1;

                                                                                                                                                                                                                                          interface IFilterOrderByItem

                                                                                                                                                                                                                                          interface IFilterOrderByItem {}

                                                                                                                                                                                                                                            property index

                                                                                                                                                                                                                                            index: any;

                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                value: any;

                                                                                                                                                                                                                                                  interface IFilterProvider

                                                                                                                                                                                                                                                  interface IFilterProvider extends IServiceProvider {}
                                                                                                                                                                                                                                                  • $filterProvider - $filter - provider in module ng

                                                                                                                                                                                                                                                    Filters are just functions which transform input to an output. However filters need to be Dependency Injected. To achieve this a filter definition consists of a factory function which is annotated with dependencies and is responsible for creating a filter function.

                                                                                                                                                                                                                                                    see https://docs.angularjs.org/api/ng/provider/$filterProvider

                                                                                                                                                                                                                                                  method register

                                                                                                                                                                                                                                                  register: (name: string | {}) => IServiceProvider;
                                                                                                                                                                                                                                                  • register(name);

                                                                                                                                                                                                                                                    Parameter name

                                                                                                                                                                                                                                                    Name of the filter function, or an object map of filters where the keys are the filter names and the values are the filter factories. Note: Filter names must be valid angular Expressions identifiers, such as uppercase or orderBy. Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace your filters, then you can use capitalization (myappSubsectionFilterx) or underscores (myapp_subsection_filterx).

                                                                                                                                                                                                                                                  interface IFilterService

                                                                                                                                                                                                                                                  interface IFilterService {}
                                                                                                                                                                                                                                                  • $filter - $filterProvider - service in module ng

                                                                                                                                                                                                                                                    Filters are used for formatting data displayed to the user.

                                                                                                                                                                                                                                                    see https://docs.angularjs.org/api/ng/service/$filter

                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                  (name: 'filter'): IFilterFilter;

                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                    (name: 'currency'): IFilterCurrency;

                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                      (name: 'number'): IFilterNumber;

                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                        (name: 'date'): IFilterDate;

                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                          (name: 'json'): IFilterJson;

                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                            (name: 'lowercase'): IFilterLowercase;

                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                              (name: 'uppercase'): IFilterUppercase;

                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                (name: 'limitTo'): IFilterLimitTo;

                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                  (name: 'orderBy'): IFilterOrderBy;

                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                    <T>(name: string): T;
                                                                                                                                                                                                                                                                    • Usage: $filter(name);

                                                                                                                                                                                                                                                                      Parameter name

                                                                                                                                                                                                                                                                      Name of the filter function to retrieve

                                                                                                                                                                                                                                                                    interface IFilterUppercase

                                                                                                                                                                                                                                                                    interface IFilterUppercase {}

                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                      (value: string): string;
                                                                                                                                                                                                                                                                      • Converts string to uppercase.

                                                                                                                                                                                                                                                                      interface IFormController

                                                                                                                                                                                                                                                                      interface IFormController {}
                                                                                                                                                                                                                                                                      • form.FormController - type in module ng see https://docs.angularjs.org/api/ng/type/form.FormController

                                                                                                                                                                                                                                                                      property $dirty

                                                                                                                                                                                                                                                                      $dirty: boolean;

                                                                                                                                                                                                                                                                        property $error

                                                                                                                                                                                                                                                                        $error: {
                                                                                                                                                                                                                                                                        [validationErrorKey: string]: Array<INgModelController | IFormController>;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          property $invalid

                                                                                                                                                                                                                                                                          $invalid: boolean;

                                                                                                                                                                                                                                                                            property $name

                                                                                                                                                                                                                                                                            $name?: string | undefined;

                                                                                                                                                                                                                                                                              property $pending

                                                                                                                                                                                                                                                                              $pending?:
                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                              [validationErrorKey: string]: Array<
                                                                                                                                                                                                                                                                              INgModelController | IFormController
                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                property $pristine

                                                                                                                                                                                                                                                                                $pristine: boolean;

                                                                                                                                                                                                                                                                                  property $submitted

                                                                                                                                                                                                                                                                                  $submitted: boolean;

                                                                                                                                                                                                                                                                                    property $valid

                                                                                                                                                                                                                                                                                    $valid: boolean;

                                                                                                                                                                                                                                                                                      method $addControl

                                                                                                                                                                                                                                                                                      $addControl: (control: INgModelController | IFormController) => void;

                                                                                                                                                                                                                                                                                        method $commitViewValue

                                                                                                                                                                                                                                                                                        $commitViewValue: () => void;

                                                                                                                                                                                                                                                                                          method $getControls

                                                                                                                                                                                                                                                                                          $getControls: () => ReadonlyArray<INgModelController | IFormController>;

                                                                                                                                                                                                                                                                                            method $removeControl

                                                                                                                                                                                                                                                                                            $removeControl: (control: INgModelController | IFormController) => void;

                                                                                                                                                                                                                                                                                              method $rollbackViewValue

                                                                                                                                                                                                                                                                                              $rollbackViewValue: () => void;

                                                                                                                                                                                                                                                                                                method $setDirty

                                                                                                                                                                                                                                                                                                $setDirty: () => void;

                                                                                                                                                                                                                                                                                                  method $setPristine

                                                                                                                                                                                                                                                                                                  $setPristine: () => void;

                                                                                                                                                                                                                                                                                                    method $setSubmitted

                                                                                                                                                                                                                                                                                                    $setSubmitted: () => void;

                                                                                                                                                                                                                                                                                                      method $setUntouched

                                                                                                                                                                                                                                                                                                      $setUntouched: () => void;

                                                                                                                                                                                                                                                                                                        method $setValidity

                                                                                                                                                                                                                                                                                                        $setValidity: (
                                                                                                                                                                                                                                                                                                        validationErrorKey: string,
                                                                                                                                                                                                                                                                                                        isValid: boolean,
                                                                                                                                                                                                                                                                                                        control: INgModelController | IFormController
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                          [name: string]: any;
                                                                                                                                                                                                                                                                                                          • Indexer which should return ng.INgModelController for most properties but cannot because of "All named properties must be assignable to string indexer type" constraint - see https://github.com/Microsoft/TypeScript/issues/272

                                                                                                                                                                                                                                                                                                          interface IHttpBackendService

                                                                                                                                                                                                                                                                                                          interface IHttpBackendService {}

                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                            method: string,
                                                                                                                                                                                                                                                                                                            url: string,
                                                                                                                                                                                                                                                                                                            post?: any,
                                                                                                                                                                                                                                                                                                            callback?: Function,
                                                                                                                                                                                                                                                                                                            headers?: any,
                                                                                                                                                                                                                                                                                                            timeout?: number,
                                                                                                                                                                                                                                                                                                            withCredentials?: boolean
                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                              interface IHttpHeadersGetter

                                                                                                                                                                                                                                                                                                              interface IHttpHeadersGetter {}

                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                (): { [name: string]: string };

                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                  (headerName: string): string;

                                                                                                                                                                                                                                                                                                                    interface IHttpInterceptor

                                                                                                                                                                                                                                                                                                                    interface IHttpInterceptor {}

                                                                                                                                                                                                                                                                                                                      method request

                                                                                                                                                                                                                                                                                                                      request: (config: IRequestConfig) => IRequestConfig | IPromise<IRequestConfig>;

                                                                                                                                                                                                                                                                                                                        method requestError

                                                                                                                                                                                                                                                                                                                        requestError: (rejection: any) => IRequestConfig | IPromise<IRequestConfig>;

                                                                                                                                                                                                                                                                                                                          method response

                                                                                                                                                                                                                                                                                                                          response: <T>(
                                                                                                                                                                                                                                                                                                                          response: IHttpResponse<T>
                                                                                                                                                                                                                                                                                                                          ) => IPromise<IHttpResponse<T>> | IHttpResponse<T>;

                                                                                                                                                                                                                                                                                                                            method responseError

                                                                                                                                                                                                                                                                                                                            responseError: <T>(
                                                                                                                                                                                                                                                                                                                            rejection: any
                                                                                                                                                                                                                                                                                                                            ) => IPromise<IHttpResponse<T>> | IHttpResponse<T>;

                                                                                                                                                                                                                                                                                                                              interface IHttpInterceptorFactory

                                                                                                                                                                                                                                                                                                                              interface IHttpInterceptorFactory {}

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (...args: any[]): IHttpInterceptor;

                                                                                                                                                                                                                                                                                                                                  interface IHttpParamSerializer

                                                                                                                                                                                                                                                                                                                                  interface IHttpParamSerializer {}
                                                                                                                                                                                                                                                                                                                                  • $http params serializer that converts objects to strings see https://docs.angularjs.org/api/ng/service/$httpParamSerializer

                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                  (obj: Object): string;

                                                                                                                                                                                                                                                                                                                                    interface IHttpPromiseCallback

                                                                                                                                                                                                                                                                                                                                    interface IHttpPromiseCallback<T> {}

                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                      data: T,
                                                                                                                                                                                                                                                                                                                                      status: number,
                                                                                                                                                                                                                                                                                                                                      headers: IHttpHeadersGetter,
                                                                                                                                                                                                                                                                                                                                      config: IRequestConfig
                                                                                                                                                                                                                                                                                                                                      ): void;

                                                                                                                                                                                                                                                                                                                                        interface IHttpProvider

                                                                                                                                                                                                                                                                                                                                        interface IHttpProvider extends IServiceProvider {}

                                                                                                                                                                                                                                                                                                                                          property defaults

                                                                                                                                                                                                                                                                                                                                          defaults: IHttpProviderDefaults;

                                                                                                                                                                                                                                                                                                                                            property interceptors

                                                                                                                                                                                                                                                                                                                                            interceptors: Array<string | Injectable<IHttpInterceptorFactory>>;
                                                                                                                                                                                                                                                                                                                                            • Register service factories (names or implementations) for interceptors which are called before and after each request.

                                                                                                                                                                                                                                                                                                                                            property xsrfTrustedOrigins

                                                                                                                                                                                                                                                                                                                                            xsrfTrustedOrigins: string[];
                                                                                                                                                                                                                                                                                                                                            • Array containing URLs whose origins are trusted to receive the XSRF token.

                                                                                                                                                                                                                                                                                                                                            property xsrfWhitelistedOrigins

                                                                                                                                                                                                                                                                                                                                            xsrfWhitelistedOrigins: string[];
                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                              The old name of xsrfTrustedOrigins. Kept for compatibility.

                                                                                                                                                                                                                                                                                                                                            method useApplyAsync

                                                                                                                                                                                                                                                                                                                                            useApplyAsync: { (): boolean; (value: boolean): IHttpProvider };

                                                                                                                                                                                                                                                                                                                                              interface IHttpProviderDefaults

                                                                                                                                                                                                                                                                                                                                              interface IHttpProviderDefaults {}
                                                                                                                                                                                                                                                                                                                                              • Object that controls the defaults for $http provider. Not all fields of IRequestShortcutConfig can be configured via defaults and the docs do not say which. The following is based on the inspection of the source code. https://docs.angularjs.org/api/ng/service/$http#defaults https://docs.angularjs.org/api/ng/service/$http#usage https://docs.angularjs.org/api/ng/provider/$httpProvider The properties section

                                                                                                                                                                                                                                                                                                                                              property cache

                                                                                                                                                                                                                                                                                                                                              cache?: any;
                                                                                                                                                                                                                                                                                                                                              • {boolean|Cache} If true, a default $http cache will be used to cache the GET request, otherwise if a cache instance built with $cacheFactory, this cache will be used for caching.

                                                                                                                                                                                                                                                                                                                                              property headers

                                                                                                                                                                                                                                                                                                                                              headers?: IHttpRequestConfigHeaders | undefined;
                                                                                                                                                                                                                                                                                                                                              • Map of strings or functions which return strings representing HTTP headers to send to the server. If the return value of a function is null, the header will not be sent. The key of the map is the request verb in lower case. The "common" key applies to all requests.

                                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                              property paramSerializer

                                                                                                                                                                                                                                                                                                                                              paramSerializer?: string | ((obj: any) => string) | undefined;
                                                                                                                                                                                                                                                                                                                                              • A function used to the prepare string representation of request parameters (specified as an object). If specified as string, it is interpreted as a function registered with the $injector. Defaults to $httpParamSerializer.

                                                                                                                                                                                                                                                                                                                                              property transformRequest

                                                                                                                                                                                                                                                                                                                                              transformRequest?:
                                                                                                                                                                                                                                                                                                                                              | IHttpRequestTransformer
                                                                                                                                                                                                                                                                                                                                              | IHttpRequestTransformer[]
                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                              property transformResponse

                                                                                                                                                                                                                                                                                                                                              transformResponse?:
                                                                                                                                                                                                                                                                                                                                              | IHttpResponseTransformer
                                                                                                                                                                                                                                                                                                                                              | IHttpResponseTransformer[]
                                                                                                                                                                                                                                                                                                                                              | undefined;
                                                                                                                                                                                                                                                                                                                                              • Transform function or an array of such functions. The transform function takes the http response body and headers and returns its transformed (typically deserialized) version.

                                                                                                                                                                                                                                                                                                                                              property withCredentials

                                                                                                                                                                                                                                                                                                                                              withCredentials?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                              • whether to to set the withCredentials flag on the XHR object. See [requests with credentials]https://developer.mozilla.org/en/http_access_control#section_5 for more information.

                                                                                                                                                                                                                                                                                                                                              property xsrfCookieName

                                                                                                                                                                                                                                                                                                                                              xsrfCookieName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                              • Name of cookie containing the XSRF token.

                                                                                                                                                                                                                                                                                                                                              property xsrfHeaderName

                                                                                                                                                                                                                                                                                                                                              xsrfHeaderName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                              • Name of HTTP header to populate with the XSRF token.

                                                                                                                                                                                                                                                                                                                                              interface IHttpRequestConfigHeaders

                                                                                                                                                                                                                                                                                                                                              interface IHttpRequestConfigHeaders {}

                                                                                                                                                                                                                                                                                                                                                property common

                                                                                                                                                                                                                                                                                                                                                common?: any;

                                                                                                                                                                                                                                                                                                                                                  property get

                                                                                                                                                                                                                                                                                                                                                  get?: any;

                                                                                                                                                                                                                                                                                                                                                    property patch

                                                                                                                                                                                                                                                                                                                                                    patch?: any;

                                                                                                                                                                                                                                                                                                                                                      property post

                                                                                                                                                                                                                                                                                                                                                      post?: any;

                                                                                                                                                                                                                                                                                                                                                        property put

                                                                                                                                                                                                                                                                                                                                                        put?: any;

                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                          [requestType: string]: any;

                                                                                                                                                                                                                                                                                                                                                            interface IHttpRequestTransformer

                                                                                                                                                                                                                                                                                                                                                            interface IHttpRequestTransformer {}

                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                              (data: any, headersGetter: IHttpHeadersGetter): any;

                                                                                                                                                                                                                                                                                                                                                                interface IHttpResponse

                                                                                                                                                                                                                                                                                                                                                                interface IHttpResponse<T> {}

                                                                                                                                                                                                                                                                                                                                                                  property config

                                                                                                                                                                                                                                                                                                                                                                  config: IRequestConfig;

                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                    data: T;

                                                                                                                                                                                                                                                                                                                                                                      property headers

                                                                                                                                                                                                                                                                                                                                                                      headers: IHttpHeadersGetter;

                                                                                                                                                                                                                                                                                                                                                                        property status

                                                                                                                                                                                                                                                                                                                                                                        status: number;

                                                                                                                                                                                                                                                                                                                                                                          property statusText

                                                                                                                                                                                                                                                                                                                                                                          statusText: string;

                                                                                                                                                                                                                                                                                                                                                                            property xhrStatus

                                                                                                                                                                                                                                                                                                                                                                            xhrStatus: 'complete' | 'error' | 'timeout' | 'abort';
                                                                                                                                                                                                                                                                                                                                                                            • Added in AngularJS 1.6.6

                                                                                                                                                                                                                                                                                                                                                                            interface IHttpResponseTransformer

                                                                                                                                                                                                                                                                                                                                                                            interface IHttpResponseTransformer {}

                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                              (data: any, headersGetter: IHttpHeadersGetter, status: number): any;

                                                                                                                                                                                                                                                                                                                                                                                interface IHttpService

                                                                                                                                                                                                                                                                                                                                                                                interface IHttpService {}
                                                                                                                                                                                                                                                                                                                                                                                • HttpService see http://docs.angularjs.org/api/ng/service/$http

                                                                                                                                                                                                                                                                                                                                                                                property defaults

                                                                                                                                                                                                                                                                                                                                                                                defaults: IHttpProviderDefaults;
                                                                                                                                                                                                                                                                                                                                                                                • Runtime equivalent of the $httpProvider.defaults property. Allows configuration of default headers, withCredentials as well as request and response transformations.

                                                                                                                                                                                                                                                                                                                                                                                property pendingRequests

                                                                                                                                                                                                                                                                                                                                                                                pendingRequests: IRequestConfig[];
                                                                                                                                                                                                                                                                                                                                                                                • Array of config objects for currently pending requests. This is primarily meant to be used for debugging purposes.

                                                                                                                                                                                                                                                                                                                                                                                method delete

                                                                                                                                                                                                                                                                                                                                                                                delete: <T>(url: string, config?: IRequestShortcutConfig) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform DELETE request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                                                                                                                                get: <T>(url: string, config?: IRequestShortcutConfig) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform GET request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method head

                                                                                                                                                                                                                                                                                                                                                                                head: <T>(url: string, config?: IRequestShortcutConfig) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform HEAD request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method jsonp

                                                                                                                                                                                                                                                                                                                                                                                jsonp: <T>(url: string, config?: IRequestShortcutConfig) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform JSONP request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method patch

                                                                                                                                                                                                                                                                                                                                                                                patch: <T>(
                                                                                                                                                                                                                                                                                                                                                                                url: string,
                                                                                                                                                                                                                                                                                                                                                                                data: any,
                                                                                                                                                                                                                                                                                                                                                                                config?: IRequestShortcutConfig
                                                                                                                                                                                                                                                                                                                                                                                ) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform PATCH request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter data

                                                                                                                                                                                                                                                                                                                                                                                  Request content

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method post

                                                                                                                                                                                                                                                                                                                                                                                post: <T>(
                                                                                                                                                                                                                                                                                                                                                                                url: string,
                                                                                                                                                                                                                                                                                                                                                                                data: any,
                                                                                                                                                                                                                                                                                                                                                                                config?: IRequestShortcutConfig
                                                                                                                                                                                                                                                                                                                                                                                ) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform POST request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter data

                                                                                                                                                                                                                                                                                                                                                                                  Request content

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                method put

                                                                                                                                                                                                                                                                                                                                                                                put: <T>(
                                                                                                                                                                                                                                                                                                                                                                                url: string,
                                                                                                                                                                                                                                                                                                                                                                                data: any,
                                                                                                                                                                                                                                                                                                                                                                                config?: IRequestShortcutConfig
                                                                                                                                                                                                                                                                                                                                                                                ) => IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Shortcut method to perform PUT request.

                                                                                                                                                                                                                                                                                                                                                                                  Parameter url

                                                                                                                                                                                                                                                                                                                                                                                  Relative or absolute URL specifying the destination of the request

                                                                                                                                                                                                                                                                                                                                                                                  Parameter data

                                                                                                                                                                                                                                                                                                                                                                                  Request content

                                                                                                                                                                                                                                                                                                                                                                                  Parameter config

                                                                                                                                                                                                                                                                                                                                                                                  Optional configuration object

                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                <T>(config: IRequestConfig): IHttpPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                • Object describing the request to be made and how it should be processed.

                                                                                                                                                                                                                                                                                                                                                                                interface IInterpolateProvider

                                                                                                                                                                                                                                                                                                                                                                                interface IInterpolateProvider extends IServiceProvider {}

                                                                                                                                                                                                                                                                                                                                                                                  method endSymbol

                                                                                                                                                                                                                                                                                                                                                                                  endSymbol: { (): string; (value: string): IInterpolateProvider };

                                                                                                                                                                                                                                                                                                                                                                                    method startSymbol

                                                                                                                                                                                                                                                                                                                                                                                    startSymbol: { (): string; (value: string): IInterpolateProvider };

                                                                                                                                                                                                                                                                                                                                                                                      interface IInterpolateService

                                                                                                                                                                                                                                                                                                                                                                                      interface IInterpolateService {}

                                                                                                                                                                                                                                                                                                                                                                                        method endSymbol

                                                                                                                                                                                                                                                                                                                                                                                        endSymbol: () => string;

                                                                                                                                                                                                                                                                                                                                                                                          method startSymbol

                                                                                                                                                                                                                                                                                                                                                                                          startSymbol: () => string;

                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                            text: string,
                                                                                                                                                                                                                                                                                                                                                                                            mustHaveExpression?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                            trustedContext?: string,
                                                                                                                                                                                                                                                                                                                                                                                            allOrNothing?: boolean
                                                                                                                                                                                                                                                                                                                                                                                            ): IInterpolationFunction;

                                                                                                                                                                                                                                                                                                                                                                                              interface IInterpolationFunction

                                                                                                                                                                                                                                                                                                                                                                                              interface IInterpolationFunction {}

                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                (context: any): string;

                                                                                                                                                                                                                                                                                                                                                                                                  interface IIntervalService

                                                                                                                                                                                                                                                                                                                                                                                                  interface IIntervalService {}

                                                                                                                                                                                                                                                                                                                                                                                                    method cancel

                                                                                                                                                                                                                                                                                                                                                                                                    cancel: (promise: IPromise<any>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                      func: Function,
                                                                                                                                                                                                                                                                                                                                                                                                      delay: number,
                                                                                                                                                                                                                                                                                                                                                                                                      count?: number,
                                                                                                                                                                                                                                                                                                                                                                                                      invokeApply?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                      ): IPromise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ILocaleDateTimeFormatDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                        interface ILocaleDateTimeFormatDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                          property AMPMS

                                                                                                                                                                                                                                                                                                                                                                                                          AMPMS: string[];

                                                                                                                                                                                                                                                                                                                                                                                                            property DAY

                                                                                                                                                                                                                                                                                                                                                                                                            DAY: string[];

                                                                                                                                                                                                                                                                                                                                                                                                              property fullDate

                                                                                                                                                                                                                                                                                                                                                                                                              fullDate: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property longDate

                                                                                                                                                                                                                                                                                                                                                                                                                longDate: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  property medium

                                                                                                                                                                                                                                                                                                                                                                                                                  medium: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    property mediumDate

                                                                                                                                                                                                                                                                                                                                                                                                                    mediumDate: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property mediumTime

                                                                                                                                                                                                                                                                                                                                                                                                                      mediumTime: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property MONTH

                                                                                                                                                                                                                                                                                                                                                                                                                        MONTH: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                          property short

                                                                                                                                                                                                                                                                                                                                                                                                                          short: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property shortDate

                                                                                                                                                                                                                                                                                                                                                                                                                            shortDate: string;

                                                                                                                                                                                                                                                                                                                                                                                                                              property SHORTDAY

                                                                                                                                                                                                                                                                                                                                                                                                                              SHORTDAY: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                property SHORTMONTH

                                                                                                                                                                                                                                                                                                                                                                                                                                SHORTMONTH: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  property shortTime

                                                                                                                                                                                                                                                                                                                                                                                                                                  shortTime: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ILocaleNumberFormatDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ILocaleNumberFormatDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property CURRENCY_SYM

                                                                                                                                                                                                                                                                                                                                                                                                                                      CURRENCY_SYM: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property DECIMAL_SEP

                                                                                                                                                                                                                                                                                                                                                                                                                                        DECIMAL_SEP: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property GROUP_SEP

                                                                                                                                                                                                                                                                                                                                                                                                                                          GROUP_SEP: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property PATTERNS

                                                                                                                                                                                                                                                                                                                                                                                                                                            PATTERNS: ILocaleNumberPatternDescriptor[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ILocaleNumberPatternDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ILocaleNumberPatternDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property gSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                gSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property lgSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                  lgSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property maxFrac

                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxFrac: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property minFrac

                                                                                                                                                                                                                                                                                                                                                                                                                                                      minFrac: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property minInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                        minInt: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property negPre

                                                                                                                                                                                                                                                                                                                                                                                                                                                          negPre: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property negSuf

                                                                                                                                                                                                                                                                                                                                                                                                                                                            negSuf: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property posPre

                                                                                                                                                                                                                                                                                                                                                                                                                                                              posPre: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property posSuf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                posSuf: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILocaleService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILocaleService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property DATETIME_FORMATS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DATETIME_FORMATS: ILocaleDateTimeFormatDescriptor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property NUMBER_FORMATS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NUMBER_FORMATS: ILocaleNumberFormatDescriptor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pluralCat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pluralCat: (num: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ILocationProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ILocationProvider extends IServiceProvider {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method hashPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hashPrefix: { (): string; (prefix: string): ILocationProvider };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method html5Mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                html5Mode: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (active: boolean): ILocationProvider;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (mode: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requireBase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rewriteLinks?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }): ILocationProvider;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILocationService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILocationService {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $location - $locationProvider - service in module ng see https://docs.angularjs.org/api/ng/service/$location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method absUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  absUrl: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hash: { (): string; (newHash: string): ILocationService };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns the hash fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Changes the hash fragment and returns $location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    host: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: { (): string; (path: string): ILocationService };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Return path of current url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Change path when called with parameter and return $location. Note: Path should always begin with forward slash (/), this method will add the forward slash if it is missing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        New path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protocol: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replace: () => ILocationService;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (search: any): ILocationService;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            paramValue: string | number | boolean | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): ILocationService;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Return search part (as object) of current url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Change search part when called with parameter and return $location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When called with a single argument the method acts as a setter, setting the search component of $location to the specified value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If the argument is a hash object containing an array of values, these values will be encoded as duplicate search parameters in the url.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Change search part when called with parameter and return $location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              New search params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter paramValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If search is a string or a Number, then paramValue will override only a single search property. If paramValue is null, the property specified via the first argument will be deleted. If paramValue is an array, it will override the property of the search component of $location specified via the first argument. If paramValue is true, the property specified via the first argument will be added with no value nor trailing equal sign.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: { (): any; (state: any): ILocationService };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url: { (): string; (url: string): ILocationService };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILogCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILogCall {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (...args: any[]): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ILogProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ILogProvider extends IServiceProvider {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method debugEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      debugEnabled: { (): boolean; (enabled: boolean): ILogProvider };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILogService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILogService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          debug: ILogCall;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            error: ILogCall;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              info: ILogCall;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                log: ILogCall;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warn: ILogCall;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IModelFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IModelFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (value: any): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IModelParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IModelParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (value: any): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IModelValidators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IModelValidators {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [index: string]: (modelValue: any, viewValue: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewValue is any because it can be an object that is called in the view like $viewValue.name:$viewValue.subName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IModelViewChangeListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IModelViewChangeListener {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property requires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requires: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        component: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (name: string, options: IComponentOptions): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (object: { [componentName: string]: IComponentOptions }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use this method to register a component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A definition object passed into the component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use this method to register a component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Object map of components where the keys are the names and the values are the component definition objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (configFn: Function): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (inlineAnnotatedFunction: any[]): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (object: Object): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use this method to register work which needs to be performed on module loading.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter configFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Execute this function on module load. Useful for service configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use this method to register work which needs to be performed on module loading.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter inlineAnnotatedFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Execute this function on module load. Useful for service configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method constant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constant: { <T>(name: string, value: T): IModule; (object: Object): IModule };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a constant service, such as a string, a number, an array, an object or a function, with the $injector. Unlike value it can be injected into a module configuration function (see config) and it cannot be overridden by an Angular decorator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the constant.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The constant value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method controller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        controller: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        controllerConstructor: Injectable<IControllerConstructor>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (object: { [name: string]: Injectable<IControllerConstructor> }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The $controller service is used by Angular to create new controllers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This provider allows controller registration via the register method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controller name, or an object map of controllers where the keys are the names and the values are the constructors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter controllerConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controller constructor fn (optionally decorated with DI annotations in the array notation).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decorator: (name: string, decorator: Injectable<Function>) => IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a service decorator with the $injector. A service decorator intercepts the creation of a service, allowing it to override or modify the behaviour of the service. The object returned by the decorator may be the original service, or a new service object which replaces or wraps and delegates to the original service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the service to decorate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This function will be invoked when the service needs to be instantiated and should return the decorated service instance. The function is called using the injector.invoke method and is therefore fully injectable. Local injection arguments: $delegate - The original service instance, which can be monkey patched, configured, decorated or delegated to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method directive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directive: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TScope extends IScope = IScope,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TElement extends JQLite = JQLite,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TController extends IDirectiveController = IController
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directiveFactory: Injectable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IDirectiveFactory<TScope, TElement, TAttributes, TController>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TScope extends IScope = IScope,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TElement extends JQLite = JQLite,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TAttributes extends IAttributes = IAttributes,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TController extends IDirectiveController = IController
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(object: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [directiveName: string]: Injectable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IDirectiveFactory<TScope, TElement, TAttributes, TController>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a new directive with the compiler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name of the directive in camel-case (i.e. ngBind which will match as ng-bind)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter directiveFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An injectable directive factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        factory: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (name: string, $getFn: Injectable<Function>): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (object: { [name: string]: Injectable<Function> }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a service factory, which will be called to return the service instance. This is short for registering a service where its provider consists of only a $get property, which is the given service factory function. You should use $provide.factory(getFn) if you do not need to configure your service in a provider.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter $getFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The $getFn for the instance creation. Internally this is a short hand for $provide.provider(name, {$get: $getFn}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filter: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (name: string, filterFactoryFunction: Injectable<FilterFactory>): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (object: { [name: string]: Injectable<FilterFactory> }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          provider: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (name: string, serviceProviderFactory: IServiceProviderFactory): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (name: string, serviceProviderConstructor: IServiceProviderClass): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (name: string, inlineAnnotatedConstructor: any[]): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (name: string, providerObject: IServiceProvider): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (object: Object): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            run: (initializationFunction: Injectable<Function>) => IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Run blocks are the closest thing in Angular to the main method. A run block is the code which needs to run to kickstart the application. It is executed after all of the service have been configured and the injector has been created. Run blocks typically contain code which is hard to unit-test, and for this reason should be declared in isolated modules, so that they can be ignored in the unit-tests.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            service: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (name: string, serviceConstructor: Injectable<Function>): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (object: { [name: string]: Injectable<Function> }): IModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Register a service constructor, which will be invoked with new to create the service instance. This is short for registering a service where its provider's $get property is a factory function that returns an instance instantiated by the injector from the service constructor function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The name of the instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter serviceConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An injectable class (constructor function) that will be instantiated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: { <T>(name: string, value: T): IModule; (object: Object): IModule };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Register a value service with the $injector, such as a string, a number, an array, an object or a function. This is short for registering a service where its provider's $get property is a factory function that takes no arguments and returns the value service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value services are similar to constant services, except that they cannot be injected into a module configuration function (see config) but they can be overridden by an Angular decorator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The name of the instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface INgModelController

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface INgModelController {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property $asyncValidators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $asyncValidators: IAsyncModelValidators;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $dirty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $dirty: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property $error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $error: { [validationErrorKey: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property $formatters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $formatters: IModelFormatter[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property $invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $invalid: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $modelValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $modelValue: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property $name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property $parsers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $parsers: IModelParser[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property $pending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $pending?: { [validationErrorKey: string]: boolean } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $pristine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $pristine: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property $touched

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $touched: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property $untouched

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $untouched: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property $valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $valid: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $validators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $validators: IModelValidators;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property $viewChangeListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $viewChangeListeners: IModelViewChangeListener[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property $viewValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $viewValue: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method $commitViewValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $commitViewValue: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method $isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $isEmpty: (value: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method $overrideModelOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $overrideModelOptions: (options: INgModelOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $processModelValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $processModelValue: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method $render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $render: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $rollbackViewValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $rollbackViewValue: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method $setDirty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $setDirty: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method $setPristine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $setPristine: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method $setTouched

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $setTouched: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method $setUntouched

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $setUntouched: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method $setValidity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $setValidity: (validationErrorKey: string, isValid: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $setViewValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $setViewValue: (value: any, trigger?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method $validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $validate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface INgModelOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface INgModelOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property allowInvalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowInvalid?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property debounce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            debounce?: number | { [key: string]: number } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getterSetter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getterSetter?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeSecondsFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeSecondsFormat?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Defines if the time and datetime-local types should show seconds and milliseconds. The option follows the format string of date filter. By default, the options is undefined which is equal to 'ss.sss' (seconds and milliseconds)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeStripZeroSeconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeStripZeroSeconds?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Defines if the time and datetime-local types should strip the seconds and milliseconds from the formatted value if they are zero. This option is applied after timeSecondsFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timezone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timezone?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property updateOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateOn?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IOnChanges {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Interface for the $onChanges lifecycle hook https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $onChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $onChanges: (onChangesObj: IOnChangesObject) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound properties that have changed, and the values are an IChangesObject object of the form { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as cloning the bound value to prevent accidental mutation of the outer value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IOnChangesObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IOnChangesObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [property: string]: IChangesObject<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IOnDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IOnDestroy {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Interface for the $onDestroy lifecycle hook https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $onDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $onDestroy: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources, watches and event handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IOnInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IOnInit {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Interface for the $onInit lifecycle hook https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $onInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $onInit: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Called on each controller after all the controllers on an element have been constructed and had their bindings initialized (and before the pre & post linking functions for the directives on this element). This is a good place to put initialization code for your controller.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IParseProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IParseProvider {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addLiteral: (literalName: string, literalValue: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configure $parse service to add literal values that will be present as literal at expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter literalName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Token for the literal value. The literal name value must be a valid literal name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter literalValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value for this literal. All literal values must be primitives or undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method logPromiseWarnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          logPromiseWarnings: { (): boolean; (value: boolean): IParseProvider };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setIdentifierFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setIdentifierFns: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            identifierStart?: (character: string, codePoint: number) => boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            identifierContinue?: (character: string, codePoint: number) => boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Allows defining the set of characters that are allowed in Angular expressions. The function identifierStart will get called to know if a given character is a valid character to be the first character for an identifier. The function identifierContinue will get called to know if a given character is a valid character to be a follow-up identifier character. The functions identifierStart and identifierContinue will receive as arguments the single character to be identifier and the character code point. These arguments will be string and numeric. Keep in mind that the string parameter can be two characters long depending on the character representation. It is expected for the function to return true or false, whether that character is allowed or not. Since this function will be called extensivelly, keep the implementation of these functions fast, as the performance of these functions have a direct impact on the expressions parsing speed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter identifierStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The function that will decide whether the given character is a valid identifier start character.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter identifierContinue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The function that will decide whether the given character is a valid identifier continue character.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method unwrapPromises

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unwrapPromises: { (): boolean; (value: boolean): IParseProvider };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IParseService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IParseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expression: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interceptorFn?: (value: any, scope: IScope, locals: any) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expensiveChecks?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ICompiledExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPostLink {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Interface for the $postLink lifecycle hook https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $postLink: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Called after this controller's element and its children have been linked. Similar to the post-link function this hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain templateUrl directives will not have been compiled and linked since they are waiting for their template to load asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather different in Angular 1 there is no direct mapping and care should be taken when upgrading.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPromise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPromise<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method catch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catch: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <TResult = never>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onRejected?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reason: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<never> | PromiseLike<TResult> | TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): IPromise<T | TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <TResult = never>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onRejected?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reason: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => IPromise<never> | TResult | IPromise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): IPromise<T | TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shorthand for promise.then(null, errorCallback)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method finally

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    finally: (finallyCallback: () => void) => IPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful to release resources or do some clean-up that needs to be done whether the promise was rejected or resolved. See the full specification for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Because finally is a reserved word in JavaScript and reserved keywords are not supported as property names by ES3, you'll need to invoke the method like promise['finally'](callback) to make your code IE8 and Android 2.x compatible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method then

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    then: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <TResult1 = T, TResult2 = never>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    successCallback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<never> | PromiseLike<TResult1> | TResult1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errorCallback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reason: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<never> | PromiseLike<TResult2> | TResult2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notifyCallback?: (state: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): IPromise<TResult1 | TResult2>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <TResult1 = T, TResult2 = never>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    successCallback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => IPromise<never> | TResult1 | IPromise<TResult1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errorCallback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reason: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => IPromise<never> | TResult2 | IPromise<TResult2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notifyCallback?: (state: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): IPromise<TResult1 | TResult2>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Regardless of when the promise was or will be resolved or rejected, then calls one of the success or error callbacks asynchronously as soon as the result is available. The callbacks are called with a single argument: the result or rejection reason. Additionally, the notify callback may be called zero or more times to provide a progress indication, before the promise is resolved or rejected. The successCallBack may return IPromise<never> for when a $q.reject() needs to be returned. This method returns a new promise which is resolved or rejected via the return value of the successCallback, errorCallback. It also notifies via the return value of the notifyCallback method. The promise can not be resolved or rejected from the notifyCallback method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IQProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IQProvider {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method errorOnUnhandledRejections

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      errorOnUnhandledRejections: { (): boolean; (value: boolean): IQProvider };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Retrieves or overrides whether to generate an error when a rejected promise is not handled. This feature is enabled by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Current value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Retrieves or overrides whether to generate an error when a rejected promise is not handled. This feature is enabled by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Whether to generate an error when a rejected promise is not handled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Self for chaining otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IQResolveReject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IQResolveReject<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (value: T): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IQService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IQService {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $q - service in module ng A promise/deferred implementation inspired by Kris Kowal's Q. See http://docs.angularjs.org/api/ng/service/$q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            all: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T6 | IPromise<T6>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T7 | IPromise<T7>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T8 | IPromise<T8>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T9 | IPromise<T9>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T10 | IPromise<T10>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5, T6, T7, T8, T9>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T6 | IPromise<T6>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T7 | IPromise<T7>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T8 | IPromise<T8>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T9 | IPromise<T9>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5, T6, T7, T8>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T6 | IPromise<T6>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T7 | IPromise<T7>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T8 | IPromise<T8>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5, T6, T7>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T6 | IPromise<T6>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T7 | IPromise<T7>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5, T6, T7]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5, T6>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T6 | IPromise<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5, T6]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4, T5>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T5 | IPromise<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4, T5]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3, T4>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T1 | IPromise<T1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T2 | IPromise<T2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T3 | IPromise<T3>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T4 | IPromise<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3, T4]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2, T3>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<[T1, T2, T3]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>]): IPromise<[T1, T2]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <TAll>(promises: (TAll | IPromise<TAll>)[]): IPromise<TAll[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T>(promises: { [K in keyof T]: T[K] | IPromise<T[K]> }): IPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns a single promise that will be resolved with an array of values, each value corresponding to the promise at the same index in the promises array. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter promises

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An array of promises.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns a single promise that will be resolved with a hash of values, each value corresponding to the promise at the same key in the promises hash. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter promises

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A hash of promises.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            defer: <T>() => IDeferred<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Creates a Deferred object which represents a task which will finish in the future.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method race

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            race: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            promises: IPromise<T>[] | { [key: string]: IPromise<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => IPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Returns a promise that resolves or rejects as soon as one of those promises resolves or rejects, with the value or reason from that promise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter promises

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A list or hash of promises.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method reject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reject: (reason?: any) => IPromise<never>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Creates a promise that is resolved as rejected with the specified reason. This api should be used to forward rejection in a chain of promises. If you are dealing with the last promise in a promise chain, you don't need to worry about it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of reject as the throw keyword in JavaScript. This also means that if you "catch" an error via a promise error callback and you want to forward the error to the promise derived from the current promise, you have to "rethrow" the error by returning a rejection constructed via reject.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter reason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Constant, message, exception or an object representing the rejection reason.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolve: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T>(value: PromiseLike<T> | T): IPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2>(value: T2 | PromiseLike<T1>): IPromise<T1 | T2>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (): IPromise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value or a promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Since TS 2.4, inference is stricter and no longer produces the desired type when T1 !== T2. To use resolve with two different types, pass a union type to the single-type-argument overload.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method when

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            when: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T>(value: PromiseLike<T> | T): IPromise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T1, T2>(value: T2 | PromiseLike<T1>): IPromise<T1 | T2>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <TResult, T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T | PromiseLike<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            successCallback: (promiseValue: T) => TResult | PromiseLike<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <TResult, T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            successCallback: (promiseValue: T) => TResult | PromiseLike<TResult>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errorCallback: (reason: any) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notifyCallback?: (state: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <TResult, TResult2, T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PromiseLike<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            successCallback: (promiseValue: T) => TResult | PromiseLike<TResult>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errorCallback: (reason: any) => TResult2 | PromiseLike<TResult2>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notifyCallback?: (state: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<TResult | TResult2>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (): IPromise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value or a promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            new <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolver: (resolve: IQResolveReject<T>, reject: IQResolveReject<any>) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): IPromise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolver: (resolve: IQResolveReject<T>, reject: IQResolveReject<any>) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): IPromise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRepeatScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRepeatScope extends IScope {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $scope for ngRepeat directive. see https://docs.angularjs.org/api/ng/directive/ngRepeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $even

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $even: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the iterator position $index is even (otherwise false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $first: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the repeated element is first in the iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $index: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • iterator offset of the repeated element (0..length-1).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $last: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the repeated element is last in the iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $middle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $middle: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the repeated element is between the first and last in the iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $odd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $odd: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the iterator position $index is odd (otherwise false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRequestConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRequestConfig extends IRequestShortcutConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Object describing the request to be made and how it should be processed. see http://docs.angularjs.org/api/ng/service/$http#usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property eventHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                eventHandlers?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { [type: string]: EventListenerOrEventListenerObject }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Event listeners to be bound to the XMLHttpRequest object. To bind events to the XMLHttpRequest upload object, use uploadEventHandlers. The handler will be called in the context of a $apply block.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTTP method (e.g. 'GET', 'POST', etc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property uploadEventHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                uploadEventHandlers?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { [type: string]: EventListenerOrEventListenerObject }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Event listeners to be bound to the XMLHttpRequest upload object. To bind events to the XMLHttpRequest object, use eventHandlers. The handler will be called in the context of a $apply block.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Absolute or relative URL of the resource that is being requested.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRequestShortcutConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRequestShortcutConfig extends IHttpProviderDefaults {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Object describing the request to be made and how it should be processed. see http://docs.angularjs.org/api/ng/service/$http#usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • {string|Object} Data to be sent as the request message data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property jsonpCallbackParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                jsonpCallbackParam?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Name of the parameter added (by AngularJS) to the request to specify the name (in the server response) of the JSON-P callback to invoke. If unspecified, $http.defaults.jsonpCallbackParam will be used by default. This property is only applicable to JSON-P requests.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • {Object.<string|Object>} Map of strings or objects which will be turned to ?key1=value1&key2=value2 after the url. If the value is not a string, it will be JSONified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property responseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                responseType?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • See [XMLHttpRequest.responseType]https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: number | IPromise<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Timeout in milliseconds, or promise that should abort the request when resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRootElementService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IRootElementService extends JQLite {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IRootScopeService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IRootScopeService {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $rootScope - $rootScopeProvider - service in module ng see https://docs.angularjs.org/api/ng/type/$rootScope.Scope and https://docs.angularjs.org/api/ng/service/$rootScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property $$isolateBindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $$isolateBindings: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property