@angular-wave/angular.ts 0.12.0 → 0.13.0

package/@types/angular.d.ts

@@ -122,13 +122,13 @@ export class Angular {
    *     function that will be invoked by the injector as a `config` block.
    *     See: {@link angular.module modules}
    * @param {import("./interface.ts").AngularBootstrapConfig} [config]
-   * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
+   * @returns {ng.InjectorService} The created injector instance for this application.
    */
   bootstrap(
     element: string | Element | Document,
     modules?: Array<string | any>,
     config?: import("./interface.ts").AngularBootstrapConfig,
-  ): import("./core/di/internal-injector.js").InjectorService;
+  ): ng.InjectorService;
   $rootScope: import("./interface.ts").Scope;
   $injector: import("./interface.ts").InjectorService;
   /**

package/@types/animations/raf-scheduler.d.ts

@@ -1,10 +1,9 @@
 /**
  * @typedef {import('./interface.ts').RafScheduler} RafScheduler
- * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
- * @type {ServiceProvider}
+ * @type {ng.ServiceProvider}
  */
 export class RafSchedulerProvider {
   /**
@@ -34,4 +33,3 @@ export class RafSchedulerProvider {
   $get(): RafScheduler;
 }
 export type RafScheduler = import("./interface.ts").RafScheduler;
-export type ServiceProvider = import("../interface.ts").ServiceProvider;

package/@types/core/compile/attributes.d.ts

@@ -18,7 +18,7 @@ export class Attributes {
   );
   $rootScope: import("../scope/scope.js").Scope;
   $animate: import("../../interface.ts").AnimateService;
-  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
+  $exceptionHandler: import("../../interface.ts").ExceptionHandler;
   $sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */

package/@types/core/compile/compile.d.ts

@@ -126,11 +126,11 @@ export class CompileProvider {
     | ((
         $injector: ng.InjectorService,
         $interpolate: any,
-        $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+        $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
         $controller: any,
-        $rootScope: import("../scope/scope.js").Scope,
+        $rootScope: ng.Scope,
         $sce: any,
         $animate: ng.AnimateService,
       ) => (

package/@types/core/di/ng-module/ng-module.d.ts

@@ -50,6 +50,7 @@ export class NgModule {
   runBlocks: Array<ng.Injectable<any>>;
   services: any[];
   wasmModules: any[];
+  restDefinitions: any[];
   /**
    * @param {string} name
    * @param {any} object
@@ -180,18 +181,29 @@ export class NgModule {
   /**
    * @param {string} name
    * @param {Function} ctor
+   * @param {ng.StorageType} type
+   * @param {ng.StorageBackend} [backendOrConfig]
    * @returns {NgModule}
    */
-  local(name: string, ctor: Function): NgModule;
+  store(
+    name: string,
+    ctor: Function,
+    type: ng.StorageType,
+    backendOrConfig?: ng.StorageBackend,
+  ): NgModule;
   /**
-   * @param {string} name
-   * @param {Function} ctor
-   * @param {ng.StorageBackend} backendOrConfig
+   * @template T, ID
+   * Register a REST resource during module configuration.
+   * @param {string} name - Service name
+   * @param {string} url - Base URL or URI template
+   * @param {ng.EntityClass<T>} entityClass - Optional constructor for mapping JSON
+   * @param {Object=} options - Optional RestService options (interceptors, etc)
    * @returns {NgModule}
    */
-  store(
+  rest<T, ID>(
     name: string,
-    ctor: Function,
-    backendOrConfig: ng.StorageBackend,
+    url: string,
+    entityClass: ng.EntityClass<T>,
+    options?: any | undefined,
   ): NgModule;
 }

package/@types/directive/bind/bind.d.ts

@@ -1,7 +1,7 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngBindDirective(): import("../../interface.ts").Directive;
+export function ngBindDirective(): ng.Directive;
 /**
  * @returns {import('../../interface.ts').Directive}
  */

package/@types/directive/include/include.d.ts

@@ -3,15 +3,15 @@
  * @param {ng.TemplateRequestService} $templateRequest
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {ng.AnimateService} $animate
- * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @returns {ng.Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: ng.TemplateRequestService,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: ng.AnimateService,
-  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.ts").Directive;
+  $exceptionHandler: ng.ExceptionHandlerService,
+): ng.Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

package/@types/directive/model/model.d.ts

@@ -49,20 +49,20 @@ export class NgModelController {
   static $nonscope: boolean;
   static $inject: string[];
   /**
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
-   * @param {import('../../core/compile/attributes.js').Attributes} $attr
+   * @param {ng.Scope} $scope
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   * @param {ng.Attributes} $attr
    * @param {Element} $element
-   * @param {import("../../core/parse/interface.ts").ParseService} $parse
+   * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
-    $scope: import("../../core/scope/scope.js").Scope,
-    $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-    $attr: import("../../core/compile/attributes.js").Attributes,
+    $scope: ng.Scope,
+    $exceptionHandler: ng.ExceptionHandlerService,
+    $attr: ng.Attributes,
     $element: Element,
-    $parse: import("../../core/parse/interface.ts").ParseService,
+    $parse: ng.ParseService,
     $animate: ng.AnimateService,
     $interpolate: any,
   );
@@ -123,11 +123,11 @@ export class NgModelController {
   $$parsedNgModelAssign: (context: any, value: any) => any;
   /**
    * @type {import("../../core/parse/interface.ts").CompiledExpression |
-   *        (function(import("../../core/scope/scope.js").Scope): any)}
+   *        (function(ng.Scope): any)}
    */
   $$ngModelGet:
     | import("../../core/parse/interface.ts").CompiledExpression
-    | ((arg0: import("../../core/scope/scope.js").Scope) => any);
+    | ((arg0: ng.Scope) => any);
   $$ngModelSet: (context: any, value: any) => any;
   $$pendingDebounce: number;
   $$parserValid: boolean;
@@ -135,13 +135,13 @@ export class NgModelController {
   $$parserName: string;
   /** @type {number} */
   $$currentValidationRunId: number;
-  /** @type {import('../../core/scope/scope.js').Scope} */
-  $$scope: import("../../core/scope/scope.js").Scope;
-  $$attr: import("../../core/compile/attributes.js").Attributes;
+  /** @type {ng.Scope} */
+  $$scope: ng.Scope;
+  $$attr: ng.Attributes;
   $$element: Element;
   $$animate: import("../../interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
+  $$exceptionHandler: import("../../interface.ts").ExceptionHandler;
   $$hasNativeValidators: boolean;
   $$classCache: {};
   $$eventRemovers: Set<any>;

package/@types/directive/options/options.d.ts

@@ -1,13 +1,13 @@
 /**
  *
  * @param {ng.CompileService} $compile
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 export function ngOptionsDirective(
   $compile: ng.CompileService,
-  $parse: import("../../core/parse/interface.ts").ParseService,
-): import("../../interface.ts").Directive;
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace ngOptionsDirective {
   let $inject: string[];
 }

package/@types/interface.d.ts

@@ -10,6 +10,11 @@ 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";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 /**
@@ -64,7 +69,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 +80,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 +174,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

package/@types/namespace.d.ts

@@ -13,7 +13,7 @@ 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";
@@ -64,8 +64,22 @@ 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";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -100,7 +114,8 @@ declare global {
     type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
     type ControllerService = TControllerService;
-    type ExceptionHandlerService = TErrorHandler;
+    type CookieService = TCookieService;
+    type ExceptionHandlerService = TExceptionHandler;
     type FilterService = TFilterFactory;
     type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
@@ -131,6 +146,13 @@ declare global {
         | (abstract new (...args: any[]) => any),
     > = TInjectable<T>;
     type StorageBackend = TStorageBackend;
+    type StorageType = TStorageType;
     type StreamConnectionConfig = TStreamConnectionConfig;
+    type CookieOptions = TCookieOptions;
+    type CookieStoreOptions = TCookieStoreOptions;
+    type RestService<T, ID> = TRestService<T, ID>;
+    type RestDefinition<T> = TRestDefinition<T>;
+    type EntityClass<T> = TEntityClass<T>;
+    type ServiceProvider = TServiceProvider;
   }
 }

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}

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

@@ -0,0 +1,78 @@
+/**
+ * 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}
+   */
+  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>}
+   */
+  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,6 @@
 /**
  * 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.
  */
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type ExceptionHandler = (exception: Error) => void;

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;
+}

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

@@ -0,0 +1,110 @@
+/**
+ * @template T, ID
+ */
+export class RestService<T, ID> {
+  static $nonscope: boolean;
+  /**
+   * Core REST service for CRUD operations.
+   * Safe, predictable, and optionally maps raw JSON to entity class instances.
+   *
+   * @param {ng.HttpService} $http Angular-like $http service
+   * @param {string} baseUrl Base URL or URI template
+   * @param {{new(data: any): T}=} entityClass Optional constructor to map JSON to objects
+   * @param {Object=} options Optional settings (interceptors, headers, etc.)
+   */
+  constructor(
+    $http: ng.HttpService,
+    baseUrl: string,
+    entityClass?:
+      | {
+          new (data: any): T;
+        }
+      | undefined,
+    options?: any | undefined,
+  );
+  /** @private */
+  private $http;
+  /** @private */
+  private baseUrl;
+  /** @private */
+  private entityClass;
+  /** @private */
+  private options;
+  /**
+   * Build full URL from template and parameters
+   * @param {string} template
+   * @param {Record<string, any>} params
+   * @returns {string}
+   */
+  buildUrl(template: string, params: Record<string, any>): string;
+  /**
+   * List entities
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T[]>}
+   */
+  list(params?: Record<string, any> | undefined): Promise<T[]>;
+  /**
+   * Read single entity by ID
+   * @param {ID} id
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T|null>}
+   */
+  read(id: ID, params?: Record<string, any> | undefined): Promise<T | null>;
+  /**
+   * Create a new entity
+   * @param {T} item
+   * @returns {Promise<T>}
+   */
+  create(item: T): Promise<T>;
+  /**
+   * Update entity by ID
+   * @param {ID} id
+   * @param {Partial<T>} item
+   * @returns {Promise<T|null>}
+   */
+  update(id: ID, item: Partial<T>): Promise<T | null>;
+  /**
+   * Delete entity by ID
+   * @param {ID} id
+   * @returns {Promise<boolean>}
+   */
+  delete(id: ID): Promise<boolean>;
+  #private;
+}
+/**
+ * Provider for registering REST endpoints during module configuration.
+ */
+export class RestProvider {
+  /** @private @type {ng.RestDefinition<any>[]} */
+  private definitions;
+  /**
+   * Register a REST resource at config phase
+   * @template T
+   * @param {string} name Service name
+   * @param {string} url Base URL or URI template
+   * @param {{new(data:any):T}=} entityClass Optional entity constructor
+   * @param {Object=} options Optional service options
+   */
+  rest<T>(
+    name: string,
+    url: string,
+    entityClass?:
+      | {
+          new (data: any): T;
+        }
+      | undefined,
+    options?: any | undefined,
+  ): void;
+  /**
+   * $get factory: returns a factory function and allows access to named services
+   * @returns {(baseUrl:string, entityClass?:Function, options?:object) => RestService & { get(name:string): RestService, listNames(): string[] }}
+   */
+  $get: (
+    | string
+    | (($http: any) => {
+        (baseUrl: any, entityClass: any, options?: {}): RestService<any, any>;
+        get(name: any): any;
+        listNames(): any[];
+      })
+  )[];
+}