@angular-wave/angular.ts 0.13.0 → 0.14.0

package/@types/angular.d.ts

@@ -129,7 +129,7 @@ export class Angular {
     modules?: Array<string | any>,
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): ng.InjectorService;
-  $rootScope: import("./interface.ts").Scope;
+  $rootScope: ng.Scope;
   $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules

package/@types/animations/animation.d.ts

@@ -8,7 +8,7 @@ export class AnimationProvider {
         $injector: ng.InjectorService,
         $$rAFScheduler: import("./raf-scheduler.js").RafScheduler,
         $$animateCache: any,
-      ) => (element: any, event: any, options: any) => AnimateRunner)
+      ) => (elementParam: any, event: any, options: any) => AnimateRunner)
   )[];
 }
 import { AnimateRunner } from "./runner/animate-runner.js";

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

@@ -16,7 +16,7 @@ export class Attributes {
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  $rootScope: import("../scope/scope.js").Scope;
+  $rootScope: ng.RootScopeService;
   $animate: import("../../interface.ts").AnimateService;
   $exceptionHandler: import("../../interface.ts").ExceptionHandler;
   $sce: any;

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

@@ -1,22 +1,8 @@
-/** @private */
-export const INJECTOR_LITERAL: "$injector";
-/** @private */
-export const COMPILE_LITERAL: "$compileProvider";
-/** @private */
-export const ANIMATION_LITERAL: "$animateProvider";
-/** @private */
-export const FILTER_LITERAL: "$filterProvider";
-/** @private */
-export const CONTROLLER_LITERAL: "$controllerProvider";
 /**
  * Modules are collections of application configuration information for components:
  * controllers, directives, filters, etc. They provide recipes for the injector
  * to do the actual instantiation. A module itself has no behaviour but only state.
  * A such, it acts as a data structure between the Angular instance and the injector service.
- *
- * Since this is an internal structure that is exposed only via the Angular instance,
- * it contains no validation of the items it receives. It is up to the instantiator on
- * modules to do the actual validation.
  */
 export class NgModule {
   /**
@@ -49,20 +35,19 @@ export class NgModule {
   /** @type {!Array.<ng.Injectable<any>>} */
   runBlocks: Array<ng.Injectable<any>>;
   services: any[];
-  wasmModules: any[];
   restDefinitions: any[];
   /**
    * @param {string} name
-   * @param {any} object
+   * @param {any} object - Allows undefined
    * @returns {NgModule}
    */
   value(name: string, object: any): NgModule;
   /**
    * @param {string} name
-   * @param {any} object
+   * @param {Object|string|number} object
    * @returns {NgModule}
    */
-  constant(name: string, object: any): NgModule;
+  constant(name: string, object: any | string | number): NgModule;
   /**
    *
    * @param {ng.Injectable<any>} configFn
@@ -118,16 +103,22 @@ export class NgModule {
   animation(name: string, animationFactory: ng.Injectable<any>): NgModule;
   /**
    * @param {string} name
-   * @param {ng.Injectable<any>} filterFn
+   * @param {ng.FilterFactory} filterFn
    * @return {NgModule}
    */
-  filter(name: string, filterFn: ng.Injectable<any>): NgModule;
+  filter(name: string, filterFn: ng.FilterFactory): NgModule;
   /**
-   * @param {string} name
-   * @param {ng.Injectable<any>} ctlFn
+   * The $controller service is used by Angular to create new controllers.
+   * This provider allows controller registration via the register method.
+   *
+   * @param {string} name Controller name
+   * @param {ng.Injectable<ng.ControllerConstructor>} ctlFn Controller constructor fn (optionally decorated with DI annotations in the array notation)
    * @returns {NgModule}
    */
-  controller(name: string, ctlFn: ng.Injectable<any>): NgModule;
+  controller(
+    name: string,
+    ctlFn: ng.Injectable<ng.ControllerConstructor>,
+  ): NgModule;
   /**
    * Register a named WebAssembly module that will be instantiated via $provide.
    *
@@ -172,12 +163,6 @@ export class NgModule {
     scriptPath: string | URL,
     config?: ng.WorkerConfig,
   ): NgModule;
-  /**
-   * @param {string} name
-   * @param {Function} ctor
-   * @returns {NgModule}
-   */
-  session(name: string, ctor: Function): NgModule;
   /**
    * @param {string} name
    * @param {Function} ctor

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

@@ -1,3 +1,9 @@
+/**
+ * $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.
+ * @extends {ng.ServiceProvider}
+ */
 export class FilterProvider {
   static $inject: string[];
   /**
@@ -6,18 +12,11 @@ export class FilterProvider {
   constructor($provide: ng.ProvideService);
   $provide: import("../../interface.ts").Provider;
   /**
-   * @param {string|Record<string, ng.FilterFn>} name
-   * @param {ng.FilterService} [factory]
-   * @return {import('../../interface.ts').Provider}
+   * Register a filter a config phase;
+   * @param {string} name
+   * @param {ng.FilterFactory} factory
+   * @return {ng.FilterProvider}
    */
-  register(
-    name: string | Record<string, ng.FilterFn>,
-    factory?: ng.FilterService,
-  ): import("../../interface.ts").Provider;
-  $get: (
-    | string
-    | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => ng.FilterService)
-  )[];
+  register(name: string, factory: ng.FilterFactory): ng.FilterProvider;
+  $get: (string | (($injector: ng.InjectorService) => ng.FilterService))[];
 }

package/@types/core/scope/interface.d.ts

@@ -7,7 +7,7 @@ export interface AsyncQueueTask {
 }
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
 export interface Listener {
-  originalTarget: object;
+  originalTarget: any;
   listenerFn: ListenerFn;
   watchFn: CompiledExpression;
   id: number;

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

@@ -10,10 +10,16 @@ export function nextId(): number;
  */
 export function createScope(target?: any, context?: Scope): Scope;
 /**
+ * @ignore
+ * Checks if a target should be excluded from scope observability
  * @param {any} target
  * @returns {boolean}
  */
-export function isUnsafeGlobal(target: any): boolean;
+export function isNonScope(target: any): boolean;
+/**
+ * Decorator for excluding objects from scope observability
+ */
+export const NONSCOPE: "$nonscope";
 export const $postUpdateQueue: any[];
 export let rootScope: any;
 export class RootScopeProvider {
@@ -26,10 +32,6 @@ export class RootScopeProvider {
       ) => Scope)
   )[];
 }
-/**
- * Decorator for excluding objects from scope observability
- */
-export const NONSCOPE: "$nonscope";
 /**
  * Scope class for the Proxy. It intercepts operations like property access (get)
  * and property setting (set), and adds support for deep change tracking and
@@ -84,8 +86,6 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  /** @type {import('./interface.ts').AsyncQueueTask[]} */
-  $$asyncQueue: import("./interface.ts").AsyncQueueTask[];
   filters: any[];
   /** @type {boolean} */
   $$destroyed: boolean;
@@ -141,17 +141,16 @@ export class Scope {
   $new(childInstance: any): any;
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
-  deregisterForeignKey(key: any, id: any): boolean;
   $eval(expr: any, locals: any): any;
   /**
    * @param {Object} newTarget
    */
   $merge(newTarget: any): void;
   /**
-   * @param {import('../../interface.ts').Expression} expr
+   * @param {ng.Expression} expr
    * @returns {any}
    */
-  $apply(expr: import("../../interface.ts").Expression): any;
+  $apply(expr: ng.Expression): any;
   /**
    * @param {string} name
    * @param {Function} listener

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

@@ -22,7 +22,7 @@ export class AriaProvider {
     $$watchExpr: (
       attrName: any,
       ariaAttr: any,
-      nativeAriaNodeNames: any,
+      nativeAriaNodeNamesParam: any,
       negate: any,
     ) => (scope: any, elem: any, attr: any) => void;
   };
@@ -83,10 +83,10 @@ export function ngModelAriaDirective($aria: any): {
   require: string;
   priority: number;
   compile(
-    elem: any,
+    _: any,
     attr: any,
   ): {
-    post(scope: any, elem: any, attr: any, ngModel: any): void;
+    post(_: any, elem: any, attrPost: any, ngModel: any): void;
   };
 };
 export namespace ngModelAriaDirective {

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

@@ -1,3 +1,3 @@
-export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
-export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
-export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassDirective: ng.DirectiveFactory;
+export const ngClassOddDirective: ng.DirectiveFactory;
+export const ngClassEvenDirective: ng.DirectiveFactory;

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

@@ -29,6 +29,6 @@ export function createWindowEventDirective(
   eventName: string,
 ): ng.Directive;
 /**
- * @type {Record<string, ng.DirectiveFactory>}
+ * @type {Record<string, ng.Injectable<any>>}
  */
-export const ngEventDirectives: Record<string, ng.DirectiveFactory>;
+export const ngEventDirectives: Record<string, ng.Injectable<any>>;

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

@@ -243,7 +243,12 @@ export const formDirective: (
         formElement: any,
         attr: any,
       ) => {
-        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+        pre: (
+          scope: any,
+          formElementParam: any,
+          attrParam: any,
+          ctrls: any,
+        ) => void;
       };
     })
 )[];
@@ -258,7 +263,12 @@ export const ngFormDirective: (
         formElement: any,
         attr: any,
       ) => {
-        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+        pre: (
+          scope: any,
+          formElementParam: any,
+          attrParam: any,
+          ctrls: any,
+        ) => void;
       };
     })
 )[];

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

@@ -45,12 +45,12 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {ng.FilterService} $filter
+ * @param {ng.FilterFactory} $filter
  * @param {ng.ParseService} $parse
  * @returns {ng.Directive}
  */
 export function inputDirective(
-  $filter: ng.FilterService,
+  $filter: ng.FilterFactory,
   $parse: ng.ParseService,
 ): ng.Directive;
 export namespace inputDirective {

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

@@ -37,7 +37,7 @@ declare class NgMessageCtrl {
     $animate: ng.AnimateService,
   );
   $element: Element;
-  $scope: import("../../interface.ts").Scope;
+  $scope: ng.Scope;
   $attrs: ng.Attributes;
   $animate: import("../../interface.ts").AnimateService;
   latestKey: number;

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

@@ -5,7 +5,7 @@ export function ngModelDirective(): {
   priority: number;
   compile: (element: Element) => {
     pre: (scope: any, _element: any, attr: any, ctrls: any) => void;
-    post: (scope: any, element: any, _attr: any, ctrls: any) => void;
+    post: (scope: any, elementPost: any, _attr: any, ctrls: any) => void;
   };
 };
 export const ngModelMinErr: (arg0: string, ...arg1: any[]) => Error;
@@ -72,11 +72,17 @@ export class NgModelController {
   $modelValue: any;
   /** @type {any} */
   $$rawModelValue: any;
-  $validators: {};
-  $asyncValidators: {};
-  $parsers: any[];
-  $formatters: any[];
-  $viewChangeListeners: any[];
+  /** @type {any} */
+  $validators: any;
+  /** @type {any} */
+  $asyncValidators: any;
+  /** @type {Array<any>} */
+  $parsers: Array<any>;
+  /** @type {Array<any>} */
+  $formatters: Array<any>;
+  /** @type {Array<any>} */
+  $viewChangeListeners: Array<any>;
+  /** @type {boolean} */
   $untouched: boolean;
   /** @type {boolean} */
   $touched: boolean;

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

@@ -1,5 +1,8 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngModelOptionsDirective(): ng.Directive;
 export const defaultModelOptions: ModelOptions;
-export function ngModelOptionsDirective(): import("../../interface.ts").Directive;
 export type ModelOptionsConfig = {
   /**
    * - A string specifying which events the input should be bound to. Multiple events can be set using a space-delimited list. The special event 'default' matches the default events belonging to the control.

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

@@ -8,7 +8,7 @@ export function optionDirective($interpolate: any): {
   compile(
     element: any,
     attr: any,
-  ): (scope: any, element: any, attr: any) => void;
+  ): (scope: any, elemParam: any, attrParam: any) => void;
 };
 export namespace optionDirective {
   let $inject: string[];

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

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

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

@@ -4,6 +4,8 @@ export interface WorkerConfig {
   autoRestart?: boolean;
   autoTerminate?: boolean;
   transformMessage?: (data: any) => any;
+  logger?: ng.LogService;
+  err?: ng.ExceptionHandlerService;
 }
 export interface WorkerConnection {
   post(data: any): void;

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

@@ -3,11 +3,13 @@
  *
  * @param {ng.ParseService} $parse
  * @param {ng.LogService} $log
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @returns {ng.Directive}
  */
 export function ngWorkerDirective(
   $parse: ng.ParseService,
   $log: ng.LogService,
+  $exceptionHandler: ng.ExceptionHandlerService,
 ): ng.Directive;
 export namespace ngWorkerDirective {
   let $inject: string[];

package/@types/filters/interface.d.ts

@@ -5,4 +5,10 @@ export type FilterFn = (input: any, ...args: any[]) => any;
 /**
  * A filter factory function that returns a FilterFn.
  */
-export type FilterFactory = (...args: any[]) => FilterFn;
+export type FilterFactory = (...args: any[]) => FilterFn & {
+  $$moduleName: string;
+};
+/**
+ * A filter service for retrieving filters functions
+ */
+export type FilterService = (name: string) => FilterFn;

package/@types/interface.d.ts

@@ -15,8 +15,11 @@ 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.
  *
@@ -450,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

@@ -20,8 +20,10 @@ import { HttpParamSerializer as THttpParamSerializer } from "./services/http/int
 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,
@@ -80,6 +88,7 @@ import {
 } 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;
@@ -91,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;
@@ -110,13 +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 CookieService = TCookieService;
     type ExceptionHandlerService = TExceptionHandler;
-    type FilterService = TFilterFactory;
+    type FilterFn = TFilterFn;
+    type FilterFactory = TFilterFactory & {
+      $$moduleName: string;
+    };
+    type FilterService = TFilterService;
     type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
@@ -127,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;
@@ -144,15 +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

@@ -231,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.
    *