@angular-wave/angular.ts 0.11.0 → 0.13.0

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

@@ -1,10 +1,8 @@
 /**
- * @param {*} $animate
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngSwitchDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngSwitchDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngSwitchDirective {
   let $inject: string[];
 }

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

@@ -0,0 +1,4 @@
+/**
+ * @return {ng.Directive}
+ */
+export function ngWasmDirective(): ng.Directive;

package/@types/{services → directive}/worker/interface.d.ts

@@ -9,4 +9,5 @@ export interface WorkerConnection {
   post(data: any): void;
   terminate(): void;
   restart(): void;
+  config: WorkerConfig;
 }

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

@@ -1,15 +1,25 @@
 /**
- * ngWorker directive factory
  * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.LogService} $log
+ * @returns {ng.Directive}
  */
 export function ngWorkerDirective(
-  $worker: any,
-  $parse: any,
-  $log: any,
-): {
-  restrict: string;
-  link(scope: any, element: any, attrs: any): void;
-};
+  $parse: ng.ParseService,
+  $log: ng.LogService,
+): ng.Directive;
 export namespace ngWorkerDirective {
   let $inject: string[];
 }
+/**
+ * Creates a managed Web Worker connection.
+ *
+ * @param {string | URL} scriptPath
+ * @param {ng.WorkerConfig} [config]
+ * @returns {ng.WorkerConnection}
+ */
+export function createWorkerConnection(
+  scriptPath: string | URL,
+  config?: ng.WorkerConfig,
+): ng.WorkerConnection;

package/@types/interface.d.ts

@@ -1,3 +1,4 @@
+export * from "./animations/interface.ts";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
@@ -9,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";
 /**
@@ -63,18 +69,23 @@ export type InjectableClass<TInstance = any> = new (...args: any) => TInstance;
  *
  * Parentheses are required around constructor types when used in unions.
  */
+export type FactoryFunction<T> = T extends abstract new (...args: any[]) => any
+  ? (...args: ConstructorParameters<T>) => InstanceType<T>
+  : T;
 export type Injectable<
   T extends ((...args: any[]) => any) | (abstract new (...args: any[]) => any),
 > =
-  | AnnotatedFactory<
-      T extends abstract new (...args: any[]) => any
-        ? (...args: ConstructorParameters<T>) => InstanceType<T>
-        : T
-    >
+  | AnnotatedFactory<FactoryFunction<T>>
   | (T extends abstract new (...args: any[]) => any
       ? 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
@@ -271,22 +333,22 @@ export type DirectiveController =
 /**
  * Represents a controller used within directive link functions.
  */
-export type TController = DirectiveController | NgModelController;
+export type TController<T> = DirectiveController | NgModelController | T;
 /**
  * Defines optional pre/post link functions in directive compile phase.
  */
 export interface DirectivePrePost {
-  pre?: DirectiveLinkFn;
-  post?: DirectiveLinkFn;
+  pre?: DirectiveLinkFn<any>;
+  post?: DirectiveLinkFn<any>;
 }
 /**
  * A link function executed during directive linking.
  */
-export type DirectiveLinkFn = (
+export type DirectiveLinkFn<T> = (
   scope: Scope,
   element: HTMLElement,
   attrs: Attributes & Record<string, any>,
-  controller?: TController,
+  controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;
 /**
@@ -296,12 +358,11 @@ export type DirectiveCompileFn = (
   templateElement?: HTMLElement,
   templateAttributes?: Attributes & Record<string, any>,
   transclude?: (...args: any[]) => any,
-) => void | DirectiveLinkFn | DirectivePrePost;
+) => void | DirectiveLinkFn<any> | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
- * @typedef {Object} Directive
  */
-export interface Directive {
+export interface Directive<TController = any> {
   /** Optional name (usually inferred) */
   name?: string;
   /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
@@ -315,7 +376,7 @@ export interface Directive {
   /** Whether to bind scope to controller */
   bindToController?: boolean | Record<string, string>;
   /** Link function(s) executed during linking */
-  link?: DirectiveLinkFn | DirectivePrePost;
+  link?: DirectiveLinkFn<TController> | DirectivePrePost;
   /** Priority of the directive */
   priority?: number;
   /** Stops further directive processing if true */
@@ -340,7 +401,7 @@ export interface Directive {
 }
 export type DirectiveFactoryFn = (
   ...args: any[]
-) => Directive | DirectiveLinkFn;
+) => Directive | DirectiveLinkFn<any>;
 export type AnnotatedDirectiveFactory = Array<string | DirectiveFactoryFn>;
 export type DirectiveFactory = DirectiveFactoryFn | AnnotatedDirectiveFactory;
 /**

package/@types/namespace.d.ts

@@ -2,14 +2,18 @@ export { angular } from "./index.js";
 import { Angular as TAngular } from "./angular.js";
 import { Attributes as TAttributes } from "./core/compile/attributes.js";
 import { Scope as TScope } from "./core/scope/scope.js";
-import { NgModule as TNgModule } from "./core/di/ng-module.js";
+import {
+  ListenerFn as TListenerFn,
+  Listener as TListener,
+} from "./core/scope/interface.ts";
+import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
 import {
   AnchorScrollProvider as TAnchorScrollProvider,
   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";
@@ -36,6 +40,7 @@ import {
   DirectiveFactory as TDirectiveFactory,
   Component as TComponent,
   Controller as TController,
+  Injectable as TInjectable,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -55,17 +60,37 @@ import {
 import {
   WorkerConnection as TWorkerConnection,
   WorkerConfig as TWorkerConfig,
-} from "./services/worker/interface.ts";
+} from "./directive/worker/interface.ts";
 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,
+  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;
   }
+  interface Window {
+    angular: TAngular;
+  }
   export namespace ng {
     type Angular = TAngular;
     type Attributes = TAttributes & Record<string, any>;
-    type Directive = TDirective;
+    type Directive<TController = any> = TDirective<TController>;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
     type Controller = TController;
@@ -86,9 +111,11 @@ declare global {
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
     type AnchorScrollService = TAnchorScrollService;
+    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;
@@ -107,9 +134,25 @@ declare global {
     type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
-    type WindowService = Window;
+    type ListenerFn = TListenerFn;
+    type Listener = TListener;
     type DocumentService = Document;
+    type WindowService = Window;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
+    type Injectable<
+      T extends
+        | ((...args: any[]) => any)
+        | (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/log/log.d.ts

@@ -19,7 +19,7 @@ export class LogProvider {
    */
   private consoleLog;
   /**
-   * @returns {import("./interface.ts").LogService}
+   * @returns {ng.LogService}
    */
-  $get(): import("./interface.ts").LogService;
+  $get(): ng.LogService;
 }

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[];
+      })
+  )[];
+}

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

@@ -0,0 +1,40 @@
+/**
+ * RFC 6570 Level 4 URI Template expander
+ *
+ * Supports operators: (none), +, #, ., /, ;, ?, &
+ * Supports varspec modifiers: explode (*) and prefix (:len)
+ *
+ * Usage:
+ *   expandUriTemplate("/users/{id}", { id: 10 }) === "/users/10"
+ *   expandUriTemplate("/search{?q,lang}", { q: "a b", lang: "en" }) === "/search?q=a%20b&lang=en"
+ *   expandUriTemplate("/repos/{owner}/{repo}/issues{?labels*}", { labels: ["bug","ui"] }) === "/repos/x/y/issues?labels=bug&labels=ui"
+ *
+ * @param {string} template
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+export function expandUriTemplate(
+  template: string,
+  vars?: {
+    [x: string]: any;
+  },
+): string;
+/**
+ * Helper: percent-encode a string. If allowReserved true, reserved chars are NOT encoded.
+ * @param {string} str
+ * @param {boolean} allowReserved
+ * @returns {string}
+ */
+export function pctEncode(str: string, allowReserved: boolean): string;
+/**
+ * Parse and expand a single expression (content between { and }).
+ * @param {string} expression
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+export function expandExpression(
+  expression: string,
+  vars: {
+    [x: string]: any;
+  },
+): string;