@angular-wave/angular.ts 0.17.0 → 0.19.0

package/@types/router/url/interface.d.ts

@@ -0,0 +1,140 @@
+import { StateDeclaration, TargetStateDef } from "../state/interface.ts";
+import { TargetState } from "../state/target-state.js";
+import { Param, StateObject } from "../state/state-object.js";
+import { UrlMatcher } from "./url-matcher.js";
+import { ParamType } from "../params/param-type.js";
+export interface UrlMatcherCompileConfig {
+  state?: StateDeclaration;
+  strict?: boolean;
+  caseInsensitive?: boolean;
+  decodeParams?: boolean;
+}
+/**
+ * An object containing the three parts of a URL
+ */
+export interface UrlParts {
+  path: string;
+  search?: {
+    [key: string]: any;
+  };
+  hash?: string;
+}
+/**
+ * A UrlRule match result
+ *
+ * The result of UrlRouter.match()
+ */
+export interface MatchResult {
+  /** The matched value from a [[UrlRule]] */
+  match: any;
+  /** The rule that matched */
+  rule: UrlRule;
+  /** The match result weight */
+  weight: number;
+}
+/**
+ * A function that matches the URL for a [[UrlRule]]
+ *
+ * Implementations should match against the provided [[UrlParts]] and return the matched value (truthy) if the rule matches.
+ * If this rule is selected, the matched value is passed to the [[UrlRuleHandlerFn]].
+ *
+ * @return the matched value, either truthy or falsey
+ */
+export interface UrlRuleMatchFn {
+  (url: UrlParts, router?: ng.RouterService): any;
+}
+/**
+ * Handler invoked when a rule is matched
+ *
+ * The matched value from the rule's [[UrlRuleMatchFn]] is passed as the first argument
+ * The handler should return a string (to redirect), a [[TargetState]]/[[TargetStateDef]], or void
+ *
+ * If the handler returns a string, the url is replaced with the string.
+ * If the handler returns a [[TargetState]], the target state is activated.
+ */
+export interface UrlRuleHandlerFn {
+  (
+    matchValue?: any,
+    url?: UrlParts,
+    router?: ng.RouterService,
+  ): string | TargetState | TargetStateDef | void;
+}
+/**
+ * The interface for a URL Rule
+ *
+ * If you are creating a rule for use with [[UrlRules.rule]], it should implement this interface.
+ */
+export interface UrlRule {
+  /**
+   * The rule's ID.
+   *
+   * IDs are auto-assigned when the rule is registered, in increasing order.
+   */
+  $id: number;
+  /**
+   * The rule's priority (defaults to 0).
+   *
+   * This can be used to explicitly modify the rule's priority.
+   * Higher numbers are higher priority.
+   */
+  priority: number;
+  /** The type of the rule */
+  type: UrlRuleType;
+  /**
+   * This function should match the url and return the match details
+   *
+   * See [[UrlRuleMatchFn]] for details
+   */
+  match: UrlRuleMatchFn;
+  /**
+   * This function is called if the rule matched, and was selected as the "best match".
+   * This function handles the rule match event.
+   *
+   * See [[UrlRuleHandlerFn]] for details
+   */
+  handler: UrlRuleHandlerFn;
+  /**
+   * The priority of a given match.
+   *
+   * Sometimes more than one UrlRule might have matched.
+   * This method is used to choose the best match.
+   *
+   * If multiple rules matched, each rule's `matchPriority` is called with the value from [[match]].
+   * The rule with the highest `matchPriority` has its [[handler]] called.
+   */
+  matchPriority(match: any): number;
+}
+export interface MatcherUrlRule extends UrlRule {
+  type: "URLMATCHER" | "STATE";
+  urlMatcher: UrlMatcher;
+}
+export interface StateRule extends MatcherUrlRule {
+  type: "STATE";
+  state: StateObject;
+}
+export interface RegExpRule extends UrlRule {
+  type: "REGEXP";
+  regexp: RegExp;
+}
+export interface UrlMatcherCache {
+  segments?: any[];
+  weights?: number[] | (2 | 3 | 1 | undefined)[];
+  path?: UrlMatcher[];
+  parent?: UrlMatcher;
+  pattern?: RegExp | null;
+}
+export interface MatchDetails {
+  id: string;
+  regexp: string;
+  segment: string;
+  type: ParamType;
+}
+export declare const defaultConfig: UrlMatcherCompileConfig;
+export interface ParamDetails {
+  param: Param;
+  value: any;
+  isValid: boolean;
+  isDefaultValue: boolean;
+  squash: boolean | string;
+  encoded: string | string[];
+}

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

@@ -18,8 +18,8 @@ export class UrlConfigProvider {
   _isCaseInsensitive: boolean;
   /** @type {boolean} */
   _isStrictMode: boolean;
-  /** @type {boolean} */
-  _defaultSquashPolicy: boolean;
+  /** @type {boolean | string} */
+  _defaultSquashPolicy: boolean | string;
   $get: () => this;
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
@@ -29,11 +29,10 @@ export class UrlConfigProvider {
    * // Allow case insensitive url matches
    * urlService.config.caseInsensitive(true);
    * ```
-   *
-   * @param value `false` to match URL in a case sensitive manner; otherwise `true`;
-   * @returns the current value of caseInsensitive
+   * @param {boolean} [value] `false` to match URL in a case sensitive manner; otherwise `true`;
+   * @returns {boolean} the current value of caseInsensitive
    */
-  caseInsensitive(value: any): any;
+  caseInsensitive(value?: boolean): boolean;
   /**
    * Sets the default behavior when generating or matching URLs with default parameter values.
    *
@@ -43,15 +42,15 @@ export class UrlConfigProvider {
    * urlService.config.defaultSquashPolicy(true);
    * ```
    *
-   * @param value A string that defines the default parameter URL squashing behavior.
+   * @param {boolean | string} [value] A string that defines the default parameter URL squashing behavior.
    *    - `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL
    *    - `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the
    *      parameter is surrounded by slashes, squash (remove) one slash from the URL
    *    - any other string, e.g. "~": When generating an href with a default parameter value, squash (remove)
    *      the parameter value from the URL and replace it with this string.
-   * @returns the current value of defaultSquashPolicy
+   * @returns {boolean | string} the current value of defaultSquashPolicy
    */
-  defaultSquashPolicy(value: any): any;
+  defaultSquashPolicy(value?: boolean | string): boolean | string;
   /**
    * Defines whether URLs should match trailing slashes, or not (the default behavior).
    *
@@ -61,10 +60,10 @@ export class UrlConfigProvider {
    * urlService.config.strictMode(false);
    * ```
    *
-   * @param value `false` to match trailing slashes in URLs, otherwise `true`.
-   * @returns the current value of strictMode
+   * @param {boolean} value `false` to match trailing slashes in URLs, otherwise `true`.
+   * @returns {boolean} the current value of strictMode
    */
-  strictMode(value: any): any;
+  strictMode(value: boolean): boolean;
   /**
    * Creates and registers a custom [[ParamType]] object
    *
@@ -86,14 +85,18 @@ export class UrlConfigProvider {
    *
    * See [[ParamTypeDefinition]] for more examples
    *
-   * @param name The type name.
-   * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
-   * @param definitionFn A function that is injected before the app runtime starts.
+   * @param {string} name The type name.
+   * @param {import("../params/interface.ts").ParamTypeDefinition} [definition] The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
+   * @param {() => import("../params/interface.ts").ParamTypeDefinition} [definitionFn] A function that is injected before the app runtime starts.
    *        The result of this function should be a [[ParamTypeDefinition]].
    *        The result is merged into the existing `definition`.
    *        See [[ParamType]] for information on the values accepted.
    *
    * @returns if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined
    */
-  type(name: any, definition: any, definitionFn: any): any;
+  type(
+    name: string,
+    definition?: import("../params/interface.ts").ParamTypeDefinition,
+    definitionFn?: () => import("../params/interface.ts").ParamTypeDefinition,
+  ): any;
 }

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

@@ -50,10 +50,17 @@
  *
  */
 export class UrlMatcher {
-  /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
-  static pathSegmentsAndParams(matcher: any): any[];
-  /** @internal Given a matcher, return an array with the matcher's query params */
-  static queryParams(matcher: any): any;
+  /**
+   * @internal Given a matcher, return an array with the matcher's path segments and path params, in order
+   * @param {UrlMatcher} matcher
+   */
+  static pathSegmentsAndParams(matcher: UrlMatcher): any;
+  /**
+   * @internal Given a matcher, return an array with the matcher's query params
+   * @param {UrlMatcher} matcher
+   * @returns {Param[]}
+   */
+  static queryParams(matcher: UrlMatcher): Param[];
   /**
    * Compare two UrlMatchers
    *
@@ -62,36 +69,53 @@ export class UrlMatcher {
    * Each dynamic segment is a path parameter.
    *
    * The comparison function sorts static segments before dynamic ones.
+   * @param {UrlMatcher} a
+   * @param {UrlMatcher} b
    */
-  static compare(a: any, b: any): number;
+  static compare(a: UrlMatcher, b: UrlMatcher): number;
   /**
-   * @param pattern The pattern to compile into a matcher.
-   * @param paramTypes The [[ParamTypes]] registry
-   * @param paramFactory A [[ParamFactory]] object
-   * @param config  A [[UrlMatcherCompileConfig]] configuration object
+   * @param {string} pattern The pattern to compile into a matcher.
+   * @param {import("../params/param-types.js").ParamTypes} paramTypes The [[ParamTypes]] registry
+   * @param {import("../params/param-factory.js").ParamFactory} paramFactory A [[ParamFactory]] object
+   * @param {import("./interface.js").UrlMatcherCompileConfig} config A [[UrlMatcherCompileConfig]] configuration object
+   */
+  constructor(
+    pattern: string,
+    paramTypes: import("../params/param-types.js").ParamTypes,
+    paramFactory: import("../params/param-factory.js").ParamFactory,
+    config: import("./interface.js").UrlMatcherCompileConfig,
+  );
+  _cache: import("./interface.js").UrlMatcherCache;
+  /**
+   * @type {any[]}
    */
-  constructor(pattern: any, paramTypes: any, paramFactory: any, config: any);
-  _cache: {
-    path: UrlMatcher[];
-  };
   _children: any[];
-  _params: any[];
-  _segments: any[];
+  _params: Param[];
+  _segments: string[];
+  /**
+   * @type {any[]}
+   */
   _compiled: any[];
   config: any;
-  pattern: any;
+  pattern: string;
   /**
    * Creates a new concatenated UrlMatcher
    *
    * Builds a new UrlMatcher by appending another UrlMatcher to this one.
    *
-   * @param url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.
+   * @param {UrlMatcher} url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.
+   * @returns {UrlMatcher} A new `UrlMatcher` instance representing the concatenation of this `UrlMatcher` and the provided `url` matcher.
    */
-  append(url: any): any;
+  append(url: UrlMatcher): UrlMatcher;
   isRoot(): boolean;
   /** Returns the input pattern string */
-  toString(): any;
-  _getDecodedParamValue(value: any, param: any): any;
+  toString(): string;
+  /**
+   * @param {any} value
+   * @param {Param} param
+   * @returns {any}
+   */
+  _getDecodedParamValue(value: any, param: Param): any;
   /**
    * Tests the specified url/path against this matcher.
    *
@@ -110,47 +134,41 @@ export class UrlMatcher {
    * });
    * // returns { id: 'bob', q: 'hello', r: null }
    * ```
-   *
-   * @param path    The URL path to match, e.g. `$location.getPath()`.
-   * @param search  URL search parameters, e.g. `$location.getSearch()`.
-   * @param hash    URL hash e.g. `$location.getHash()`.
-   *
-   * @returns The captured parameter values.
+   * @param {string} path The URL path to match, e.g. `$location.getPath()`.
+   * @param {any} search URL search parameters, e.g. `$location.getSearch()`.
+   * @param {string} hash URL hash e.g. `$location.getHash()`.
+   * @returns {import("../params/interface.js").RawParams | null} The captured parameter values.
    */
   exec(
-    path: any,
-    search: {},
-    hash: any,
-  ): {
-    "#": any;
-  };
+    path: string,
+    search: any,
+    hash: string,
+  ): import("../params/interface.js").RawParams | null;
   /**
    * @internal
    * Returns all the [[Param]] objects of all path and search parameters of this pattern in order of appearance.
    *
+   * @param {any} [opts]
    * @returns {Array.<Param>}  An array of [[Param]] objects. Must be treated as read-only. If the
    *    pattern has no parameters, an empty array is returned.
    */
-  parameters(opts?: {}): Array<Param>;
+  parameters(opts?: any): Array<Param>;
   /**
-   * @internal
-   * Returns a single parameter from this UrlMatcher by id
-   *
-   * @param id
-   * @param opts
-   * @returns {Param|any|boolean|UrlMatcher|null}
+   * @internal Returns a single parameter from this UrlMatcher by id
+   * @param {string} id
+   * @param {any} opts
+   * @returns {Param | any | boolean | UrlMatcher | null}
    */
-  parameter(id: any, opts?: {}): Param | any | boolean | UrlMatcher | null;
+  parameter(id: string, opts?: any): Param | any | boolean | UrlMatcher | null;
   /**
    * Validates the input parameter values against this UrlMatcher
    *
    * Checks an object hash of parameters to validate their correctness according to the parameter
    * types of this `UrlMatcher`.
-   *
-   * @param params The object hash of parameters to validate.
-   * @returns Returns `true` if `params` validates, otherwise `false`.
+   * @param {import("../params/interface.js").RawParams} params The object hash of parameters to validate.
+   * @returns {boolean} Returns `true` if `params` validates, otherwise `false`.
    */
-  validates(params: any): any;
+  validates(params: import("../params/interface.js").RawParams): boolean;
   /**
    * Given a set of parameter values, creates a URL from this UrlMatcher.
    *
@@ -163,12 +181,14 @@ export class UrlMatcher {
    * // returns '/user/bob?q=yes'
    * ```
    *
-   * @param values  the values to substitute for the parameters in this pattern.
+   * @param {import("../params/interface.js").RawParams} values  the values to substitute for the parameters in this pattern.
    * @returns the formatted URL (path and optionally search part).
    */
-  format(values?: {}): string;
+  format(values?: import("../params/interface.js").RawParams): string;
 }
 export namespace UrlMatcher {
   let nameValidator: RegExp;
 }
+export type UrlMatcherCache = import("./interface.js").UrlMatcherCache;
+export type ParamDetails = import("./interface.ts").ParamDetails;
 import { Param } from "../params/param.js";

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

@@ -17,11 +17,11 @@ export class UrlRuleFactory {
   routerGlobals: ng.RouterService;
   /**
    *
-   * @param {*} what
-   * @param {*} handler
-   * @returns {BaseUrlRule}
+   * @param {StateObject} what
+   * @param {*} [handler]
+   * @returns {import("./url-rules.js").UrlRule}
    */
-  create(what: any, handler: any): BaseUrlRule;
+  create(what: StateObject, handler?: any): import("./url-rules.js").UrlRule;
   /**
    * A UrlRule which matches based on a UrlMatcher
    *
@@ -57,15 +57,14 @@ export class UrlRuleFactory {
    * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
    * var result = rule.handler(match); // '/home/123/456'
    * ```
+   * @param {UrlMatcher} urlMatcher
+   * @param {string | UrlMatcher | import("./interface.js").UrlRuleHandlerFn} handler
+   * @returns {import("./interface.js").MatcherUrlRule}
    */
   fromUrlMatcher(
-    urlMatcher: any,
-    handler: any,
-  ): BaseUrlRule & {
-    urlMatcher: any;
-    matchPriority: (params: any) => number;
-    type: string;
-  };
+    urlMatcher: UrlMatcher,
+    handler: string | UrlMatcher | import("./interface.js").UrlRuleHandlerFn,
+  ): import("./interface.js").MatcherUrlRule;
   /**
    * A UrlRule which matches a state by its url
    *
@@ -76,19 +75,16 @@ export class UrlRuleFactory {
    * var result = rule.handler(match);
    * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
    * ```
+   * @param {StateObject | import("../state/interface.js").StateDeclaration} stateOrDecl
+   * @param {import("../state/state-service.js").StateProvider} stateService
+   * @param {import("../router.js").RouterProvider} globals
+   * @returns {import("./interface.js").StateRule}
    */
   fromState(
-    stateOrDecl: any,
-    stateService: any,
-    globals: any,
-  ): BaseUrlRule & {
-    urlMatcher: any;
-    matchPriority: (params: any) => number;
-    type: string;
-  } & {
-    state: any;
-    type: string;
-  };
+    stateOrDecl: StateObject | import("../state/interface.js").StateDeclaration,
+    stateService: import("../state/state-service.js").StateProvider,
+    globals: import("../router.js").RouterProvider,
+  ): import("./interface.js").StateRule;
   /**
    * A UrlRule which matches based on a regular expression
    *
@@ -120,17 +116,17 @@ export class UrlRuleFactory {
    * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]
    * var result = rule.handler(match); // '/home/bar'
    * ```
+   * @param {RegExp} regexp
+   * @param {string | import("./interface.js").UrlRuleHandlerFn} handler
+   * @returns {import("./interface.js").RegExpRule}
    */
   fromRegExp(
-    regexp: any,
-    handler: any,
-  ): BaseUrlRule & {
-    regexp: any;
-    type: string;
-  };
+    regexp: RegExp,
+    handler: string | import("./interface.js").UrlRuleHandlerFn,
+  ): import("./interface.js").RegExpRule;
 }
 export namespace UrlRuleFactory {
-  function isUrlRule(obj: any): boolean;
+  function isUrlRule(obj: { [x: string]: any }): boolean;
 }
 /**
  * A base rule which calls `match`
@@ -138,13 +134,38 @@ export namespace UrlRuleFactory {
  * The value from the `match` function is passed through to the `handler`.
  */
 export class BaseUrlRule {
-  constructor(match: any, handler: any);
-  match: any;
-  type: string;
+  /**
+   * @param {import("./interface.js").UrlRuleMatchFn} match
+   * @param {import("./interface.js").UrlRuleHandlerFn} handler
+   */
+  constructor(
+    match: import("./interface.js").UrlRuleMatchFn,
+    handler: import("./interface.js").UrlRuleHandlerFn,
+  );
+  /**
+   * @type {import("./interface.js").UrlRuleMatchFn}
+   */
+  match: import("./interface.js").UrlRuleMatchFn;
+  /**
+   * @type {import("./interface.js").UrlRuleType}
+   */
+  type: import("./interface.js").UrlRuleType;
+  /**
+   * @type {number}
+   */
   $id: number;
-  _group: any;
-  handler: any;
-  priority: any;
+  /**
+   * @type {number | undefined}
+   */
+  _group: number | undefined;
+  /**
+   * @type {import("./interface.js").UrlRuleHandlerFn}
+   */
+  handler: import("./interface.js").UrlRuleHandlerFn;
+  /**
+   * @type {number | undefined}
+   */
+  priority: number | undefined;
   /**
    * This function should be overridden
    * @param {*} [params]
@@ -152,3 +173,5 @@ export class BaseUrlRule {
    */
   matchPriority(params?: any): number;
 }
+import { StateObject } from "../state/state-object.js";
+import { UrlMatcher } from "./url-matcher.js";

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

@@ -12,15 +12,17 @@ export class UrlRules {
   /** @param {UrlRuleFactory} urlRuleFactory */
   constructor(urlRuleFactory: UrlRuleFactory);
   _sortFn: typeof defaultRuleSortFn;
-  _rules: any[];
+  /**
+   * @type {UrlRule[]}
+   */
+  _rules: UrlRule[];
   _id: number;
   _urlRuleFactory: UrlRuleFactory;
   /**
    * Remove a rule previously registered
-   *
-   * @param rule the matcher rule that was previously registered using [[rule]]
+   * @param {UrlRule} rule the matcher rule that was previously registered using [[rule]]
    */
-  removeRule(rule: any): void;
+  removeRule(rule: UrlRule): void;
   /**
    * Manually adds a URL Rule.
    *
@@ -31,16 +33,17 @@ export class UrlRules {
    * A rule should have a `match` function which returns truthy if the rule matched.
    * It should also have a `handler` function which is invoked if the rule is the best match.
    *
+   * @param {UrlRule} rule the rule to register
    * @returns {() => void } a function that deregisters the rule
    */
-  rule(rule: any): () => void;
+  rule(rule: UrlRule): () => void;
   _sorted: boolean;
   /**
    * Gets all registered rules
    *
-   * @returns an array of all the registered rules
+   * @returns {import("./interface.ts").UrlRule[]} an array of all the registered rules
    */
-  rules(): any[];
+  rules(): import("./interface.ts").UrlRule[];
   /**
    * Defines URL Rule priorities
    *
@@ -73,19 +76,21 @@ export class UrlRules {
    *   return a.$id - b.$id;
    * }
    * ```
-   *
-   * @param compareFn a function that compares to [[UrlRule]] objects.
-   *    The `compareFn` should abide by the `Array.sort` compare function rules.
-   *    Given two rules, `a` and `b`, return a negative number if `a` should be higher priority.
-   *    Return a positive number if `b` should be higher priority.
-   *    Return `0` if the rules are identical.
-   *
-   *    See the [mozilla reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description)
-   *    for details.
+   * @param {((a: UrlRule, b: UrlRule) => number) | undefined} [compareFn] a function that compares to [[UrlRule]] objects.
+   * The `compareFn` should abide by the `Array.sort` compare function rules.
+   * Given two rules, `a` and `b`, return a negative number if `a` should be higher priority.
+   * Return a positive number if `b` should be higher priority.
+   * Return `0` if the rules are identical.
+   * See the [mozilla reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description)
+   * for details.
    */
-  sort(compareFn: any): void;
+  sort(compareFn?: ((a: UrlRule, b: UrlRule) => number) | undefined): void;
   ensureSorted(): void;
-  stableSort(arr: any, compareFn: any): any;
+  /**
+   * @param {any[]} arr
+   * @param {(arg0: any, arg1: any) => any} compareFn
+   */
+  stableSort(arr: any[], compareFn: (arg0: any, arg1: any) => any): any[];
   /**
    * Registers a `matcher` and `handler` for custom URLs handling.
    *
@@ -138,19 +143,22 @@ export class UrlRules {
    * ```
    *
    * Note: the `handler` may also invoke arbitrary code, such as `$state.go()`
-   *
-   * @param matcher A pattern `string` to match, compiled as a [[UrlMatcher]], or a `RegExp`.
-   * @param handler The path to redirect to, or a function that returns the path.
-   * @param options `{ priority: number }`
-   *
-   * @return the registered [[UrlRule]]
+   * @param {import("../state/state-object.js").StateObject} matcher A pattern `string` to match, compiled as a [[UrlMatcher]], or a `RegExp`.
+   * @param {any} handler The path to redirect to, or a function that returns the path.
+   * @param {{ priority: any; }} options `{ priority: number }`
+   * @return {UrlRule} the registered [[UrlRule]]
    */
   when(
-    matcher: any,
+    matcher: import("../state/state-object.js").StateObject,
     handler: any,
-    options: any,
-  ): import("./url-rule.js").BaseUrlRule;
+    options: {
+      priority: any;
+    },
+  ): UrlRule;
 }
+export type UrlRule = import("./interface.ts").UrlRule;
+export type MatcherUrlRule = import("./interface.ts").MatcherUrlRule;
+export type BaseUrlRule = import("./url-rule.js").BaseUrlRule;
 /**
  * Default rule priority sorting function.
  *
@@ -162,7 +170,9 @@ export class UrlRules {
  * - Rule registration order (for rule types other than STATE and URLMATCHER)
  *   - Equally sorted State and UrlMatcher rules will each match the URL.
  *     Then, the *best* match is chosen based on how many parameter values were matched.
+ * @param {UrlRule} a
+ * @param {UrlRule} b
  */
-declare function defaultRuleSortFn(a: any, b: any): number;
+declare function defaultRuleSortFn(a: UrlRule, b: UrlRule): number;
 import { UrlRuleFactory } from "./url-rule.js";
 export {};