@angular-wave/angular.ts 0.12.0 → 0.14.0

package/@types/interface.d.ts

@@ -10,8 +10,16 @@ export * from "./index.js";
 export * from "./angular.js";
 export * from "./core/di/internal-injector.js";
 export * from "./core/scope/scope.js";
+export * from "./services/cookie/cookie.js";
+export * from "./services/cookie/interface.ts";
+export * from "./services/exception/exception.ts";
+export * from "./services/exception/interface.ts";
+export * from "./core/parse/interface.ts";
+export * from "./filters/interface.ts";
+export * from "./core/filter/filter.js";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
+import { NgModelController } from "./directive/model/model.js";
 /**
  * Configuration options for the AngularTS bootstrap process.
  *
@@ -64,7 +72,7 @@ export type InjectableClass<TInstance = any> = new (...args: any) => TInstance;
  *
  * Parentheses are required around constructor types when used in unions.
  */
-type FactoryFunction<T> = T extends abstract new (...args: any[]) => any
+export type FactoryFunction<T> = T extends abstract new (...args: any[]) => any
   ? (...args: ConstructorParameters<T>) => InstanceType<T>
   : T;
 export type Injectable<
@@ -75,6 +83,12 @@ export type Injectable<
       ? InjectableClass<InstanceType<T>>
       : never)
   | T;
+export interface ServiceProviderClass {
+  new (...args: any[]): ServiceProvider;
+}
+export interface ServiceProviderFactory {
+  (...args: any[]): ServiceProvider;
+}
 /**
  * An object that defines how a service is constructed.
  *
@@ -163,6 +177,57 @@ export interface ChangesObject<T = any> {
  * Mapping of binding property names to their change metadata.
  */
 export type OnChangesObject = Record<string, ChangesObject>;
+/**
+ * Interface for the $onInit lifecycle hook
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ */
+export interface OnInit {
+  /**
+   * 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.
+   */
+  $onInit(): void;
+}
+/**
+ * Interface for the $onChanges lifecycle hook
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ */
+export interface OnChanges {
+  /**
+   * 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 {@link 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.
+   */
+  $onChanges(onChangesObj: OnChangesObject): void;
+}
+/**
+ * Interface for the $onDestroy lifecycle hook
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ */
+export interface OnDestroy {
+  /**
+   * Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources,
+   * watches and event handlers.
+   */
+  $onDestroy(): void;
+}
+/**
+ * Interface for the $postLink lifecycle hook
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ */
+export interface PostLink {
+  /**
+   * 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.
+   */
+  $postLink(): void;
+}
 /**
  * AngularTS component lifecycle interface.
  * Directive controllers have a well-defined lifecycle. Each controller can implement "lifecycle hooks". These are methods that
@@ -388,39 +453,6 @@ export interface NgModelOptions {
   /** Whether to remove trailing :00 seconds */
   timeStripZeroSeconds?: boolean;
 }
-/**
- * Controller API for ngModel directive.
- */
-export interface NgModelController {
-  /** Updates the view when the model changes */
-  $render(): void;
-  /** Sets the validity state of the control */
-  $setValidity(validationErrorKey: string, isValid: boolean): void;
-  /** Updates the model value */
-  $setViewValue(value: any, trigger?: string): void;
-  /** Marks the control as pristine */
-  $setPristine(): void;
-  /** Marks the control as dirty */
-  $setDirty(): void;
-  /** Re-validates the model */
-  $validate(): void;
-  /** Marks the control as touched */
-  $setTouched(): void;
-  /** Marks the control as untouched */
-  $setUntouched(): void;
-  /** Rolls back to previous view value */
-  $rollbackViewValue(): void;
-  /** Commits the current view value to the model */
-  $commitViewValue(): void;
-  /** Processes view-to-model transformations */
-  $processModelValue(): void;
-  /** Determines if value is considered empty */
-  $isEmpty(value: any): boolean;
-  /** Overrides the model options dynamically */
-  $overrideModelOptions(options: NgModelOptions): void;
-  /** Current value shown in the view */
-  $viewValue: any;
-}
 export interface RootElementService extends Element {}
 /**
  * The minimal local definitions required by $controller(ctrl, locals) calls.

package/@types/namespace.d.ts

@@ -13,15 +13,17 @@ import {
   AnchorScrollService as TAnchorScrollService,
 } from "./services/anchor-scroll/anchor-scroll.js";
 import { ControllerService as TControllerService } from "./core/controller/interface.ts";
-import { ErrorHandler as TErrorHandler } from "./services/exception/interface.ts";
+import { ExceptionHandler as TExceptionHandler } from "./services/exception/interface.ts";
 import { ParseService as TParseService } from "./core/parse/interface.ts";
 import { TemplateRequestService as TTemplateRequestService } from "./services/template-request/interface.ts";
 import { HttpParamSerializer as THttpParamSerializer } from "./services/http/interface.ts";
 import { HttpParamSerializerProvider as THttpParamSerializerProvider } from "./services/http/http.js";
 import {
   FilterFactory as TFilterFactory,
+  FilterService as TFilterService,
   FilterFn as TFilterFn,
 } from "./filters/interface.ts";
+import { FilterProvider as TFilterProvider } from "./core/filter/filter.js";
 import { InterpolateService as TInterpolateService } from "./core/interpolate/interface.ts";
 import { InterpolateProvider as TInterpolateProvider } from "./core/interpolate/interpolate.js";
 import {
@@ -38,15 +40,21 @@ import {
 import {
   Directive as TDirective,
   DirectiveFactory as TDirectiveFactory,
+  AnnotatedDirectiveFactory as TAnnotatedDirectiveFactory,
   Component as TComponent,
   Controller as TController,
+  ControllerConstructor as TControllerConstructor,
   Injectable as TInjectable,
+  Expression as TExpression,
 } from "./interface.ts";
 import {
   SseService as TSseService,
   SseConfig as TSseConfig,
 } from "./services/sse/interface.ts";
-import type { ErrorHandlingConfig as TErrorHandlingConfig } from "./shared/interface.ts";
+import type {
+  ErrorHandlingConfig as TErrorHandlingConfig,
+  Validator as TValidator,
+} from "./shared/interface.ts";
 import {
   BoundTranscludeFn as TBoundTranscludeFn,
   CompileFn as TCompileFn,
@@ -64,8 +72,23 @@ import {
 import { Provider as TProvideService } from "./interface.ts";
 import { Location as TLocationService } from "./services/location/location.js";
 import { AnimateService as TAnimateService } from "./animations/interface.ts";
-import { StorageBackend as TStorageBackend } from "./services/storage/interface.ts";
+import {
+  StorageBackend as TStorageBackend,
+  StorageType as TStorageType,
+} from "./services/storage/interface.ts";
 import { StreamConnectionConfig as TStreamConnectionConfig } from "./services/stream/interface.ts";
+import { CookieService as TCookieService } from "./services/cookie/cookie.js";
+import {
+  CookieStoreOptions as TCookieStoreOptions,
+  CookieOptions as TCookieOptions,
+} from "./services/cookie/interface.ts";
+import {
+  RestDefinition as TRestDefinition,
+  EntityClass as TEntityClass,
+} from "./services/rest/interface.ts";
+import { RestService as TRestService } from "./services/rest/rest.js";
+import { ServiceProvider as TServiceProvider } from "./interface.ts";
+import { NgModelController as TNgModelController } from "./directive/model/model.js";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -77,18 +100,23 @@ declare global {
     type Angular = TAngular;
     type Attributes = TAttributes & Record<string, any>;
     type Directive<TController = any> = TDirective<TController>;
-    type DirectiveFactory = TDirectiveFactory;
-    type Component = TComponent;
+    type DirectiveFactory = TDirectiveFactory & Function;
+    type AnnotatedDirectiveFactory = TAnnotatedDirectiveFactory;
+    type Component = TComponent & Record<string, any>;
     type Controller = TController;
-    type Scope = TScope;
+    type Scope = TScope & Record<string, any>;
     type NgModule = TNgModule;
     type PubSubProvider = TPubSubProvider;
-    type FilterFn = TFilterFn;
     type CompositeLinkFn = TCompositeLinkFn;
-    type PublicLinkFn = TPublicLinkFn;
+    type PublicLinkFn = TPublicLinkFn & {
+      pre: any;
+      post: any;
+    };
     type NodeLinkFn = TNodeLinkFn;
     type NodeLinkFnCtx = TNodeLinkFnCtx;
-    type TranscludeFn = TTranscludeFn;
+    type TranscludeFn = TTranscludeFn & {
+      $$slots: any;
+    };
     type BoundTranscludeFn = TBoundTranscludeFn;
     type LinkFnMapping = TLinkFnMapping;
     type AnchorScrollProvider = TAnchorScrollProvider;
@@ -96,12 +124,18 @@ declare global {
     type HttpParamSerializerProvider = THttpParamSerializerProvider;
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
+    type FilterProvider = TFilterProvider;
     type AnchorScrollService = TAnchorScrollService;
     type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
     type ControllerService = TControllerService;
-    type ExceptionHandlerService = TErrorHandler;
-    type FilterService = TFilterFactory;
+    type CookieService = TCookieService;
+    type ExceptionHandlerService = TExceptionHandler;
+    type FilterFn = TFilterFn;
+    type FilterFactory = TFilterFactory & {
+      $$moduleName: string;
+    };
+    type FilterService = TFilterService;
     type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
@@ -112,7 +146,7 @@ declare global {
     type ProvideService = TProvideService;
     type PubSubService = TPubSub;
     type RootElementService = Element;
-    type RootScopeService = TScope;
+    type RootScopeService = TScope & Record<string, any>;
     type StateService = TStateProvider;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
@@ -129,8 +163,21 @@ declare global {
       T extends
         | ((...args: any[]) => any)
         | (abstract new (...args: any[]) => any),
-    > = TInjectable<T>;
+    > = TInjectable<T> & {
+      $$moduleName: string;
+    };
     type StorageBackend = TStorageBackend;
+    type StorageType = TStorageType;
     type StreamConnectionConfig = TStreamConnectionConfig;
+    type CookieOptions = TCookieOptions;
+    type ControllerConstructor = TControllerConstructor;
+    type CookieStoreOptions = TCookieStoreOptions;
+    type RestService<T, ID> = TRestService<T, ID>;
+    type RestDefinition<T> = TRestDefinition<T>;
+    type EntityClass<T> = TEntityClass<T>;
+    type ServiceProvider = TServiceProvider;
+    type Expression = TExpression;
+    type NgModelController = TNgModelController;
+    type Validator = TValidator;
   }
 }

package/@types/router/common/trace.d.ts

@@ -12,6 +12,7 @@ export namespace Category {
 export class Trace {
   _enabled: {};
   approximateDigests: number;
+  $logger: any;
   _set(enabled: any, categories: any): void;
   enable(...categories: any[]): void;
   disable(...categories: any[]): void;

package/@types/router/directives/view-directive.d.ts

@@ -4,7 +4,7 @@ export function $ViewDirectiveFill(
   $transitions: any,
 ): {
   priority: number;
-  compile: (tElement: any) => (scope: any, $element: any) => void;
+  compile(tElement: any): (scope: any, $element: any) => void;
 };
 export namespace $ViewDirectiveFill {
   let $inject: string[];
@@ -135,4 +135,4 @@ export namespace $ViewDirectiveFill {
  * ```
  */
 /** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
-export let ngView: import("../../interface.ts").AnnotatedDirectiveFactory;
+export const ngView: import("../../interface.ts").AnnotatedDirectiveFactory;

package/@types/router/transition/transition.d.ts

@@ -1,4 +1,3 @@
-/** @typedef {import('./interface.ts').IHookRegistry} IHookRegistry */
 /**
  * Represents a transition between two states.
  *

package/@types/router/url/url-config.d.ts

@@ -20,7 +20,7 @@ export class UrlConfigProvider {
   _isStrictMode: boolean;
   /** @type {boolean} */
   _defaultSquashPolicy: boolean;
-  $get: (() => any)[];
+  $get: () => this;
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
    *

package/@types/router/url/url-rule.d.ts

@@ -1,13 +1,3 @@
-/**
- * Creates a [[UrlRule]]
- *
- * Creates a [[UrlRule]] from a:
- *
- * - `string`
- * - [[UrlMatcher]]
- * - `RegExp`
- * - [[StateObject]]
- */
 export class UrlRuleFactory {
   /**
    * @param {import('../url/url-service.js').UrlService} urlService

package/@types/router/url/url-service.d.ts

@@ -60,10 +60,7 @@ export class UrlService {
   getHash(): string;
   $get: (
     | string
-    | ((
-        $location: import("../../services/location/location.js").Location,
-        $rootScope: import("../../core/scope/scope.js").Scope,
-      ) => UrlService)
+    | (($location: ng.LocationService, $rootScope: ng.Scope) => UrlService)
   )[];
   /**
    * @returns {string}
@@ -234,11 +231,11 @@ export class UrlService {
   /**
    * Creates a [[UrlMatcher]] for the specified pattern.
    *
-   * @param pattern  The URL pattern.
+   * @param urlPattern  The URL pattern.
    * @param config  The config object hash.
    * @returns The UrlMatcher.
    */
-  compile(pattern: any, config: any): UrlMatcher;
+  compile(urlPattern: any, config: any): UrlMatcher;
   /**
    * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
    *

package/@types/router/view/view.d.ts

@@ -1,19 +1,3 @@
-/**
- * The View service
- *
- * This service pairs existing `ng-view` components (which live in the DOM)
- * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
- *
- * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
- *   The views from exited states are deactivated via [[deactivateViewConfig]].
- *   (See: the [[registerActivateViews]] Transition Hook)
- *
- * - As `ng-view` components pop in and out of existence, they register themselves using [[registerUIView]].
- *
- * - When the [[sync]] function is called, the registered `ng-view`(s) ([[ActiveUIView]])
- * are configured with the matching [[ViewConfig]](s)
- *
- */
 export class ViewService {
   _ngViews: any[];
   _viewConfigs: any[];

package/@types/services/anchor-scroll/anchor-scroll.d.ts

@@ -14,7 +14,7 @@ export class AnchorScrollProvider {
     | string
     | ((
         $location: import("../../services/location/location.js").Location,
-        $rootScope: import("../../core/scope/scope.js").Scope,
+        $rootScope: ng.Scope,
       ) => AnchorScrollFunction)
   )[];
 }

package/@types/services/cookie/cookie.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Service provider that creates a {@link CookieService $cookie} service.
+ * @type {ng.ServiceProvider}
+ */
+export class CookieProvider {
+  defaults: {};
+  $get: (
+    | string
+    | (($exceptionHandler: ng.ExceptionHandlerService) => CookieService)
+  )[];
+}
+/**
+ *
+ * Provides high-level APIs for interacting with browser cookies:
+ *  - Raw get/set/remove
+ *  - JSON serialization helpers
+ *  - Global defaults supplied by $cookiesProvider
+ */
+export class CookieService {
+  /**
+   * @param {ng.CookieOptions} defaults
+   *   Default cookie attributes defined by `$cookiesProvider.defaults`.
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   */
+  constructor(
+    defaults: ng.CookieOptions,
+    $exceptionHandler: ng.ExceptionHandlerService,
+  );
+  /** @type {ng.CookieOptions} */
+  defaults: ng.CookieOptions;
+  $exceptionHandler: import("../exception/interface.ts").ExceptionHandler;
+  /**
+   * Retrieves a raw cookie value.
+   *
+   * @param {string} key
+   * @returns {string|null}
+   * @throws {URIError} – If decodeURIComponent fails.
+   */
+  get(key: string): string | null;
+  /**
+   * Retrieves a cookie and deserializes its JSON content.
+   *
+   * @template T
+   * @param {string} key
+   * @returns {T|null}
+   * @throws {SyntaxError} if cookie JSON is invalid
+   */
+  getObject<T>(key: string): T | null;
+  /**
+   * Returns an object containing all raw cookies.
+   *
+   * @returns {Record<string, string>}
+   * @throws {URIError} – If decodeURIComponent fails
+   */
+  getAll(): Record<string, string>;
+  /**
+   * Sets a raw cookie value.
+   *
+   * @param {string} key
+   * @param {string} value
+   * @param {ng.CookieOptions} [options]
+   */
+  put(key: string, value: string, options?: ng.CookieOptions): void;
+  /**
+   * Serializes an object as JSON and stores it as a cookie.
+   *
+   * @param {string} key
+   * @param {any} value
+   * @param {ng.CookieOptions} [options]
+   * @throws {TypeError} if Object cannot be converted to JSON
+   */
+  putObject(key: string, value: any, options?: ng.CookieOptions): void;
+  /**
+   * Removes a cookie by setting an expired date.
+   *
+   * @param {string} key
+   * @param {ng.CookieOptions} [options]
+   */
+  remove(key: string, options?: ng.CookieOptions): void;
+}

package/@types/services/cookie/interface.d.ts

@@ -0,0 +1,12 @@
+export interface CookieOptions {
+  path?: string;
+  domain?: string;
+  expires?: Date | string | number;
+  secure?: boolean;
+  samesite?: "Lax" | "Strict" | "None";
+}
+export interface CookieStoreOptions {
+  serialize?: (value: any) => string;
+  deserialize?: (text: string) => any;
+  cookie?: CookieOptions;
+}

package/@types/services/exception/exception.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Unified exception handler used throughout AngularTS.
+ *
+ * This service receives uncaught exceptions from both synchronous and asynchronous operations.
+ * Its purpose is to provide a central point through which the framework
+ * processes errors.
+ *
+ * By default, `$exceptionHandler` simply rethrows the exception. This ensures fail-fast
+ * behavior, making errors visible immediately in development and in unit tests.
+ * Applications may override this service to introduce custom error handling.
+ *
+ * ### Example: Custom `$exceptionHandler`
+ *
+ * ```js
+ * angular
+ *   .module('app')
+ *   .factory('$exceptionHandler', function(myLogger) {
+ *     return function handleError(error) {
+ *       myLogger.capture(error);
+ *       // Rethrow to preserve fail-fast behavior:
+ *       throw error;
+ *     };
+ *   });
+ * ```
+ *
+ * IMPORTANT: custom implementation should always rethrow the error as the framework assumes that `$exceptionHandler` always does the throwing.
+ *
+ * ### Manual Invocation
+ *
+ * You can invoke the exception handler directly when catching errors in your own code:
+ *
+ * ```js
+ * try {
+ *   riskyOperation();
+ * } catch (err) {
+ *   $exceptionHandler(err);
+ * }
+ * ```
+ *
+ * @see {@link ng.ExceptionHandlerService} ExceptionHandlerService
+ */
+/**
+ * Provider for the `$exceptionHandler` service.
+ *
+ * The default implementation rethrows exceptions, enabling strict fail-fast behavior.
+ * Applications may replace the handler via by setting `errorHandler`property or by providing their own
+ * `$exceptionHandler` factory.
+ */
+export class ExceptionHandlerProvider {
+  /** @type {ng.ExceptionHandlerService} */
+  handler: ng.ExceptionHandlerService;
+  /**
+   * @returns {ng.ExceptionHandlerService}
+   */
+  $get(): ng.ExceptionHandlerService;
+}

package/@types/services/exception/interface.d.ts

@@ -1,7 +1,7 @@
 /**
  * A callback type for handling errors.
  *
- * @param exception - The exception associated with the error.
- * @param [cause] - Optional information about the context in which the error was thrown.
+ * @param {Error} exception - The exception associated with the error.
+ * @throws {Error}
  */
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type ExceptionHandler = (exception: Error) => never;

package/@types/services/http/http.d.ts

@@ -25,7 +25,7 @@ export function HttpProvider(): void;
 export class HttpProvider {
   defaults: {
     transformResponse: (typeof defaultHttpResponseTransform)[];
-    transformRequest: ((d: any) => any)[];
+    transformRequest: ((data: any) => any)[];
     headers: {
       common: {
         Accept: string;
@@ -108,6 +108,7 @@ export class HttpProvider {
     | ((
         $injector: ng.InjectorService,
         $sce: any,
+        $cookie: ng.CookieService,
       ) => {
         (requestConfig: any): Promise<any>;
         pendingRequests: any[];
@@ -119,7 +120,7 @@ export class HttpProvider {
          */
         defaults: {
           transformResponse: (typeof defaultHttpResponseTransform)[];
-          transformRequest: ((d: any) => any)[];
+          transformRequest: ((data: any) => any)[];
           headers: {
             common: {
               Accept: string;
@@ -170,3 +171,10 @@ export function http(
   eventHandlers?: Record<string, EventListener>,
   uploadEventHandlers?: Record<string, EventListener>,
 ): void;
+export const Http: Readonly<{
+  OK: 200;
+  MultipleChoices: 300;
+  BadRequest: 400;
+  NotFound: 404;
+  ErrorMax: 599;
+}>;

package/@types/services/location/location.d.ts

@@ -94,10 +94,10 @@ export function parseAppUrl(url: string, html5Mode: boolean): void;
  * Returns `undefined` if `url` does not start with `base`.
  * @param {string} base
  * @param {string} url
- * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
+ * @returns {string|undefined} returns text from `url` after `base` or `undefined` if it does not begin with
  *                   the expected string.
  */
-export function stripBaseUrl(base: string, url: string): string;
+export function stripBaseUrl(base: string, url: string): string | undefined;
 /**
  * @ignore
  * Removes the hash fragment (including the '#') from the given URL string.
@@ -143,11 +143,11 @@ export function serverBase(url: string): string;
  * Determine if two URLs are equal despite potential differences in encoding,
  * trailing slashes, or empty hash fragments, such as between $location.absUrl() and $browser.url().
  *
- * @param {string} a - First URL to compare.
- * @param {string} b - Second URL to compare.
+ * @param {string} x - First URL to compare.
+ * @param {string} y - Second URL to compare.
  * @returns {boolean} True if URLs are equivalent after normalization.
  */
-export function urlsEqual(a: string, b: string): boolean;
+export function urlsEqual(x: string, y: string): boolean;
 export class Location {
   /**
    * @param {string} appBase application base URL
@@ -321,7 +321,11 @@ export class LocationProvider {
   lastCachedState: any;
   $get: (
     | string
-    | (($rootScope: ng.Scope, $rootElement: Element) => Location)
+    | ((
+        $rootScope: ng.Scope,
+        $rootElement: Element,
+        $exceptionHandler: ng.ExceptionHandlerService,
+      ) => Location)
   )[];
   #private;
 }

package/@types/services/pubsub/pubsub.d.ts

@@ -15,6 +15,7 @@ export class PubSubProvider {
   $get: () => PubSub;
 }
 export class PubSub {
+  static $nonscope: any;
   /**
    * Runs a function asynchronously.
    *
@@ -153,7 +154,7 @@ export class PubSub {
    * the order in which they were added, passing all arguments along.
    *
    * If this object was created with async=true, subscribed functions are called
-   * via Promise.resolve().  Otherwise, the functions are called directly, and if
+   * via `queueMicrotask`.  Otherwise, the functions are called directly, and if
    * any of them throw an uncaught error, publishing is aborted.
    *
    * @param {string} topic Topic to publish to.

package/@types/services/rest/interface.d.ts

@@ -0,0 +1,17 @@
+export interface RestDefinition<T = any> {
+  name: string;
+  url: string;
+  /** Constructor for mapping JSON to class instance */
+  entityClass?: EntityClass<T>;
+  options?: Record<string, any>;
+}
+/**
+ * A constructor type for mapping JSON objects to entity instances
+ */
+export interface EntityClass<T = any> {
+  /**
+   * Creates a new instance of the entity from a raw object
+   * @param data - Raw data (typically JSON) to map
+   */
+  new (data: any): T;
+}