@v-ibe/core 0.1.0

package/dist/router/decorators/base-policy.js

@@ -0,0 +1,63 @@
+const POLICY_RULES = Symbol("policyRules");
+function getPolicyRules(policyClass) {
+  return policyClass[POLICY_RULES] || [];
+}
+function addPolicyRule(target, propertyKey, descriptor, type) {
+  const constructor = target.constructor;
+  if (!constructor[POLICY_RULES]) {
+    constructor[POLICY_RULES] = [];
+  }
+  const rule = {
+    methodName: propertyKey,
+    handler: descriptor.value,
+    type
+  };
+  constructor[POLICY_RULES].push(rule);
+}
+function Allow() {
+  return function(target, context) {
+    context.addInitializer(function() {
+      const descriptor = Object.getOwnPropertyDescriptor(this, context.name) || {
+        value: target
+      };
+      addPolicyRule(Object.getPrototypeOf(this), context.name, descriptor, "allow");
+    });
+  };
+}
+function Block() {
+  return function(target, context) {
+    context.addInitializer(function() {
+      const descriptor = Object.getOwnPropertyDescriptor(this, context.name) || {
+        value: target
+      };
+      addPolicyRule(Object.getPrototypeOf(this), context.name, descriptor, "block");
+    });
+  };
+}
+function Redirect() {
+  return function(target, context) {
+    context.addInitializer(function() {
+      const descriptor = Object.getOwnPropertyDescriptor(this, context.name) || {
+        value: target
+      };
+      addPolicyRule(Object.getPrototypeOf(this), context.name, descriptor, "redirect");
+    });
+  };
+}
+function Skip() {
+  return function(target, context) {
+    context.addInitializer(function() {
+      const descriptor = Object.getOwnPropertyDescriptor(this, context.name) || {
+        value: target
+      };
+      addPolicyRule(Object.getPrototypeOf(this), context.name, descriptor, "skip");
+    });
+  };
+}
+export {
+  Allow,
+  Block,
+  Redirect,
+  Skip,
+  getPolicyRules
+};

package/dist/router/decorators/index.d.ts

@@ -0,0 +1,6 @@
+export { Route } from './route';
+export type { RouteConfig } from './route';
+export { Param, Params, Query, QueryParams, getParamMetadata, getQueryParamMetadata } from './params';
+export type { ParamMetadata, QueryParamMetadata } from './params';
+export { Allow, Block, Redirect, Skip, getPolicyRules } from './base-policy';
+export type { PolicyDecisionType, PolicyRule, PolicyDecision } from './base-policy';

package/dist/router/decorators/params.d.ts

@@ -0,0 +1,31 @@
+import { Constructor } from '../../DI/types';
+export interface ParamMetadata {
+    paramName: string;
+    propertyKey: string;
+    target: Constructor;
+}
+export interface QueryParamMetadata {
+    queryName: string;
+    propertyKey: string;
+    target: Constructor;
+}
+/**
+ * Decorator for individual route parameters
+ * @param paramName The name of the route parameter (e.g., 'id' for '/users/:id')
+ */
+export declare function Param(paramName: string): (_: undefined, context: ClassFieldDecoratorContext) => void;
+/**
+ * Decorator for all route parameters as an object
+ */
+export declare function Params(): (_: undefined, context: ClassFieldDecoratorContext) => void;
+/**
+ * Decorator for individual query parameters
+ * @param queryName The name of the query parameter (e.g., 'page' for '?page=1')
+ */
+export declare function Query<This extends object>(queryName: string): (_: undefined, context: ClassFieldDecoratorContext) => void;
+/**
+ * Decorator for all query parameters as an object
+ */
+export declare function QueryParams(): (_: undefined, context: ClassFieldDecoratorContext) => void;
+export declare function getParamMetadata(target: Constructor): ParamMetadata[];
+export declare function getQueryParamMetadata(target: Constructor): QueryParamMetadata[];

package/dist/router/decorators/params.js

@@ -0,0 +1,97 @@
+import { Router } from "../router.js";
+const PARAM_METADATA_KEY = Symbol("paramMetadata");
+const QUERY_PARAM_METADATA_KEY = Symbol("queryParamMetadata");
+function Param(paramName) {
+  return function(_, context) {
+    if (context.kind !== "field") {
+      throw new Error("@Param can only be used on fields");
+    }
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const metadata = {
+        paramName,
+        propertyKey: context.name,
+        target: ctor
+      };
+      if (!ctor[PARAM_METADATA_KEY]) {
+        ctor[PARAM_METADATA_KEY] = [];
+      }
+      ctor[PARAM_METADATA_KEY].push(metadata);
+      Object.defineProperty(this, context.name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          const router = this.__container.get(Router);
+          return router.$params[paramName] || null;
+        }
+      });
+    });
+  };
+}
+function Params() {
+  return function(_, context) {
+    if (context.kind !== "field") {
+      throw new Error("@Params can only be used on fields");
+    }
+    context.addInitializer(function() {
+      Object.defineProperty(this, context.name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          const router = this.__container.get(Router);
+          return router.$params;
+        }
+      });
+    });
+  };
+}
+function Query(queryName) {
+  return function(_, context) {
+    if (context.kind !== "field") {
+      throw new Error("@Query can only be used on fields");
+    }
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const metadata = {
+        queryName,
+        propertyKey: context.name,
+        target: ctor
+      };
+      if (!ctor[QUERY_PARAM_METADATA_KEY]) {
+        ctor[QUERY_PARAM_METADATA_KEY] = [];
+      }
+      ctor[QUERY_PARAM_METADATA_KEY].push(metadata);
+      Object.defineProperty(this, context.name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          const router = this.__container.get(Router);
+          return router.$queryParams[queryName] || null;
+        }
+      });
+    });
+  };
+}
+function QueryParams() {
+  return function(_, context) {
+    if (context.kind !== "field") {
+      throw new Error("@QueryParams can only be used on fields");
+    }
+    context.addInitializer(function() {
+      Object.defineProperty(this, context.name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          const router = this.__container.get(Router);
+          return router.$queryParams;
+        }
+      });
+    });
+  };
+}
+export {
+  Param,
+  Params,
+  Query,
+  QueryParams
+};

package/dist/router/decorators/route-metadata.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Decorador sobrecargado para inyectar metadata de la ruta.
+ *
+ * Uso sin parámetros: @RouteMetadata metadata!: Record<string, any>;
+ * Inyecta toda la metadata de la ruta.
+ *
+ * Uso con key: @RouteMetadata('role') role!: string;
+ * Inyecta solo el valor específico de la metadata.
+ */
+export declare function RouteMetadata(): (value: undefined, context: ClassFieldDecoratorContext) => void;
+export declare function RouteMetadata(key: string): (value: undefined, context: ClassFieldDecoratorContext) => void;

package/dist/router/decorators/route-metadata.js

@@ -0,0 +1,23 @@
+function RouteMetadata(key) {
+  return function(value, context) {
+    if (context.kind !== "field") {
+      throw new Error("@RouteMetadata can only be used on fields");
+    }
+    context.addInitializer(function() {
+      Object.defineProperty(this, context.name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          const metadata = this.__routeMetadata || {};
+          if (key !== void 0) {
+            return metadata[key];
+          }
+          return metadata;
+        }
+      });
+    });
+  };
+}
+export {
+  RouteMetadata
+};

package/dist/router/decorators/route.d.ts

@@ -0,0 +1,39 @@
+import { Constructor } from '../../DI/types';
+/**
+ * Configuración para el decorador @Route
+ */
+export interface RouteConfig {
+    /**
+     * Metadata arbitraria que se puede acceder desde políticas
+     * a través del decorador @RouteMetadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Array de clases de políticas que deben estar decoradas con @Service.
+     * Las políticas se evalúan en orden antes de cargar el componente.
+     * Si alguna política redirige, la navegación actual se cancela.
+     *
+     * @example
+     * ```typescript
+     * @Route('/admin', {
+     *   metadata: { requiresAuth: true },
+     *   policies: [AuthPolicy, AdminRolePolicy]
+     * })
+     * ```
+     */
+    policies?: Constructor<any>[];
+    /**
+     * Nombre del slot donde se renderizará este componente.
+     * Permite renderizar múltiples componentes en paralelo para la misma ruta.
+     *
+     * @example
+     * ```typescript
+     * @Route('/dashboard', {
+     *   slot: '@main',
+     *   policies: [AuthPolicy]
+     * })
+     * ```
+     */
+    slot?: string;
+}
+export declare function Route(path: string, config?: RouteConfig): (target: any, context: ClassDecoratorContext) => void;

package/dist/router/decorators/route.js

@@ -0,0 +1,7 @@
+function Route(path, config) {
+  return function(target, context) {
+  };
+}
+export {
+  Route
+};

package/dist/router/link.behavior.d.ts

@@ -0,0 +1,87 @@
+import { BaseComponent } from '../components/base-component';
+/**
+ * Link Behavior
+ *
+ * Convierte un <a> en un link de navegación SPA que usa el Router interno.
+ * También maneja la clase CSS activa basada en la ruta actual.
+ *
+ * @example
+ * ```tsx
+ * // Navegación simple
+ * <a link href="/home">Home</a>
+ *
+ * // Con clase activa
+ * <a link href="/about" activeClass="active">About</a>
+ *
+ * // Con múltiples clases activas
+ * <a link href="/contact" activeClass="active font-bold">Contact</a>
+ *
+ * // Replace en lugar de push (no agrega al historial)
+ * <a link href="/login" replace>Login</a>
+ *
+ * // Manejo de links externos
+ * <a link href="https://docs.com" external="native">External Docs</a>
+ * <a link href="https://api.com" external="block">Blocked API</a>
+ * ```
+ */
+export declare class Link {
+    el: HTMLAnchorElement;
+    hostComponent?: BaseComponent;
+    link: boolean;
+    href: string;
+    activeClass?: string;
+    replace?: boolean;
+    external?: 'allow' | 'block' | 'native';
+    private router;
+    private clickHandler?;
+    onInit(): void;
+    /**
+     * Computed que determina si el link está activo.
+     *
+     * Un link está activo si su href resuelto hace match con alguno de los patrones activos del router.
+     * Los patrones pueden contener variables como `:id`, por lo que necesitamos pattern matching real.
+     *
+     * Ejemplos:
+     * - href="/articles" hace match con pattern "/articles"
+     * - href="/articles/123" hace match con pattern "/articles/:id"
+     * - href="/dashboard/nested" hace match con patterns "/dashboard" y "/dashboard/nested"
+     */
+    get isActive(): boolean;
+    /**
+     * Verifica si un href hace match con un patrón de ruta.
+     *
+     * @param href - El href del link (ej: "/articles/123")
+     * @param pattern - El patrón de ruta (ej: "/articles/:id")
+     * @returns true si el href hace match con el patrón
+     */
+    private matchPattern;
+    /**
+     * Effect que actualiza las clases CSS cuando cambia el estado activo del link.
+     */
+    private updateActiveClass;
+    /**
+     * Resuelve un href siguiendo el estándar de frameworks modernos (React Router, Next.js, etc.)
+     *
+     * Comportamiento:
+     * - Rutas absolutas (empiezan con /): se usan tal cual → "/products" = "/products"
+     * - Rutas externas (con protocolo): se devuelven tal cual
+     * - Rutas relativas (no empiezan con /): se resuelven desde routeBasePath del componente host
+     *   - routeBasePath="/store/:storeId" + params={storeId:"123"} + href="sales" = "/store/123/sales"
+     *
+     * @param href - El href original del prop
+     * @returns El href resuelto que se debe usar para navegación
+     */
+    private resolveHref;
+    /**
+     * Reemplaza parámetros (:paramName) en un path con valores del router.$params
+     *
+     * @param path - Path con parámetros (ej: "/store/:storeId/products")
+     * @returns Path con parámetros resueltos (ej: "/store/123/products")
+     */
+    private resolvePathParams;
+    /**
+     * Determina si un href es un link externo
+     */
+    private isExternalLink;
+    onDestroy(): void;
+}

package/dist/router/link.behavior.js

@@ -0,0 +1,227 @@
+import { Behavior, Host, ComponentHost } from "../behaviors/decorators.js";
+import { Prop } from "../components/decorators/prop.js";
+import { Inject } from "../DI/decorators/inject.js";
+import { Router } from "./router.js";
+import { Effect } from "../reactivity/decorators/effect.js";
+import { Computed } from "../reactivity/decorators/computed.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _updateActiveClass_dec, _isActive_dec, _router_dec, _external_dec, _replace_dec, _activeClass_dec, _href_dec, _link_dec, _hostComponent_dec, _el_dec, _Link_decorators, _init;
+_Link_decorators = [Behavior], _el_dec = [Host], _hostComponent_dec = [ComponentHost], _link_dec = [Prop], _href_dec = [Prop], _activeClass_dec = [Prop], _replace_dec = [Prop], _external_dec = [Prop], _router_dec = [Inject(Router)], _isActive_dec = [Computed], _updateActiveClass_dec = [Effect];
+class Link {
+  constructor() {
+    __runInitializers(_init, 5, this);
+    this.el = __runInitializers(_init, 8, this), __runInitializers(_init, 11, this);
+    this.hostComponent = __runInitializers(_init, 12, this), __runInitializers(_init, 15, this);
+    this.link = __runInitializers(_init, 16, this, true), __runInitializers(_init, 19, this);
+    this.href = __runInitializers(_init, 20, this, ""), __runInitializers(_init, 23, this);
+    this.activeClass = __runInitializers(_init, 24, this), __runInitializers(_init, 27, this);
+    this.replace = __runInitializers(_init, 28, this), __runInitializers(_init, 31, this);
+    this.external = __runInitializers(_init, 32, this), __runInitializers(_init, 35, this);
+    this.router = __runInitializers(_init, 36, this), __runInitializers(_init, 39, this);
+    this.clickHandler = void 0;
+  }
+  onInit() {
+    const resolvedHref = this.resolveHref(this.href);
+    this.el.href = resolvedHref;
+    this.clickHandler = (e) => {
+      if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.defaultPrevented) {
+        return;
+      }
+      if (this.el.target === "_blank") {
+        return;
+      }
+      if (this.isExternalLink(this.href)) {
+        if (this.external) {
+          e.preventDefault();
+          this.router.navigate(this.href, { external: this.external });
+          return;
+        }
+        return;
+      }
+      e.preventDefault();
+      this.router.navigate(resolvedHref, {
+        replace: this.replace
+      });
+    };
+    this.el.addEventListener("click", this.clickHandler);
+    if (this.activeClass) {
+      this.updateActiveClass();
+    }
+  }
+  get isActive() {
+    const resolvedHref = this.resolveHref(this.href);
+    const normalizedHref = resolvedHref.replace(/\/$/, "") || "/";
+    return this.router.activePatterns.some((pattern) => {
+      const normalizedPattern = pattern.replace(/\/$/, "") || "/";
+      return this.matchPattern(normalizedHref, normalizedPattern);
+    });
+  }
+  /**
+   * Verifica si un href hace match con un patrón de ruta.
+   * 
+   * @param href - El href del link (ej: "/articles/123")
+   * @param pattern - El patrón de ruta (ej: "/articles/:id")
+   * @returns true si el href hace match con el patrón
+   */
+  matchPattern(href, pattern) {
+    if (href === pattern) {
+      return true;
+    }
+    if (!pattern.includes(":")) {
+      return false;
+    }
+    const regexPattern = pattern.split("/").map((segment) => {
+      if (segment.startsWith(":")) {
+        return "([^/]+)";
+      }
+      return segment;
+    }).join("/");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(href);
+  }
+  updateActiveClass() {
+    if (!this.activeClass) return;
+    const isActive = this.isActive;
+    const classes = this.activeClass.split(" ").filter((cls) => cls.trim());
+    if (isActive) {
+      this.el.classList.add(...classes);
+    } else {
+      this.el.classList.remove(...classes);
+    }
+  }
+  /**
+   * Resuelve un href siguiendo el estándar de frameworks modernos (React Router, Next.js, etc.)
+   *
+   * Comportamiento:
+   * - Rutas absolutas (empiezan con /): se usan tal cual → "/products" = "/products"
+   * - Rutas externas (con protocolo): se devuelven tal cual
+   * - Rutas relativas (no empiezan con /): se resuelven desde routeBasePath del componente host
+   *   - routeBasePath="/store/:storeId" + params={storeId:"123"} + href="sales" = "/store/123/sales"
+   *
+   * @param href - El href original del prop
+   * @returns El href resuelto que se debe usar para navegación
+   */
+  resolveHref(href) {
+    if (this.isExternalLink(href)) {
+      return href;
+    }
+    if (href.startsWith("/")) {
+      return href;
+    }
+    const normalizedHref = href.startsWith("./") ? href.slice(2) : href;
+    let basePath = "/";
+    if (this.hostComponent && "routeBasePath" in this.hostComponent) {
+      basePath = this.hostComponent.routeBasePath;
+    }
+    if (!basePath || basePath === "/") {
+      const currentPathname = this.router.pathname;
+      const basePathname = currentPathname.endsWith("/") ? currentPathname : currentPathname + "/";
+      return basePathname + normalizedHref;
+    }
+    const resolvedBasePath = this.resolvePathParams(basePath);
+    const finalBasePath = resolvedBasePath.endsWith("/") ? resolvedBasePath : resolvedBasePath + "/";
+    return finalBasePath + normalizedHref;
+  }
+  /**
+   * Reemplaza parámetros (:paramName) en un path con valores del router.$params
+   *
+   * @param path - Path con parámetros (ej: "/store/:storeId/products")
+   * @returns Path con parámetros resueltos (ej: "/store/123/products")
+   */
+  resolvePathParams(path) {
+    const segments = path.split("/");
+    const resolved = segments.map((segment) => {
+      if (segment.startsWith(":")) {
+        const paramName = segment.slice(1);
+        const paramValue = this.router.$params[paramName];
+        return paramValue || segment;
+      }
+      return segment;
+    });
+    return resolved.join("/");
+  }
+  /**
+   * Determina si un href es un link externo
+   */
+  isExternalLink(href) {
+    if (/^(https?:)?\/\//.test(href)) {
+      try {
+        const url = new URL(href, window.location.origin);
+        return url.origin !== window.location.origin;
+      } catch {
+        return true;
+      }
+    }
+    if (/^[a-z]+:/i.test(href)) {
+      return true;
+    }
+    return false;
+  }
+  onDestroy() {
+    if (this.clickHandler) {
+      this.el.removeEventListener("click", this.clickHandler);
+    }
+  }
+}
+_init = __decoratorStart();
+__decorateElement(_init, 2, "isActive", _isActive_dec, Link);
+__decorateElement(_init, 1, "updateActiveClass", _updateActiveClass_dec, Link);
+__decorateElement(_init, 5, "el", _el_dec, Link);
+__decorateElement(_init, 5, "hostComponent", _hostComponent_dec, Link);
+__decorateElement(_init, 5, "link", _link_dec, Link);
+__decorateElement(_init, 5, "href", _href_dec, Link);
+__decorateElement(_init, 5, "activeClass", _activeClass_dec, Link);
+__decorateElement(_init, 5, "replace", _replace_dec, Link);
+__decorateElement(_init, 5, "external", _external_dec, Link);
+__decorateElement(_init, 5, "router", _router_dec, Link);
+Link = __decorateElement(_init, 0, "Link", _Link_decorators, Link);
+__runInitializers(_init, 1, Link);
+export {
+  Link
+};

package/dist/router/policy-evaluator.d.ts

@@ -0,0 +1,81 @@
+import { PolicyDecision, PolicyDecisionType } from './decorators/base-policy';
+import { RouteCandidate } from './trie.types';
+/**
+ * Servicio que evalúa políticas ejecutando sus reglas decoradas en orden.
+ *
+ * El evaluador implementa la siguiente semántica:
+ *
+ * - Para @Allow, @Block, @Redirect:
+ *   - Si el método retorna false/undefined: continuar al siguiente método
+ *   - Si el método retorna true: ejecutar la acción y detener evaluación
+ *
+ * - Para @Skip:
+ *   - Si el método retorna false: continuar al siguiente método
+ *   - Si el método retorna true: esta política completa no opina,
+ *     señalar al router que pase a la siguiente política en la cadena
+ *
+ * Esta semántica permite composición limpia de políticas donde cada una
+ * puede explícitamente declinar opinar sobre ciertas navegaciones.
+ */
+export declare class PolicyEvaluator {
+    /**
+     * Evalúa una instancia de política ejecutando sus reglas decoradas en orden.
+     *
+     * @param policyInstance La instancia de la política a evaluar
+     * @param signal Optional AbortSignal para cancelar la evaluación
+     * @returns Una decisión sobre qué hacer con la navegación
+     *
+     * @example
+     * ```typescript
+     * const decision = await evaluator.evaluate(authPolicyInstance);
+     *
+     * if (decision.type === 'skip') {
+     *   // Esta política no opina, intentar la siguiente
+     * } else if (decision.type === 'allow') {
+     *   // Permitir la navegación
+     * } else if (decision.type === 'block') {
+     *   // Bloquear la navegación
+     * }
+     * ```
+     */
+    evaluate(policyInstance: any, signal?: AbortSignal): Promise<PolicyDecision>;
+    /**
+     * Evalúa una cadena de políticas en orden hasta que una tome una decisión.
+     *
+     * Este método implementa la composición de políticas:
+     * - Si una política retorna 'skip' (o ninguna regla coincide), pasa a la siguiente
+     * - Si una política retorna 'allow', 'block', o 'redirect', se detiene y retorna esa decisión
+     * - Si todas las políticas hacen skip, retorna la decisión por defecto
+     *
+     * @param policyInstances Array de instancias de políticas a evaluar en orden
+     * @param defaultDecision La decisión a tomar si todas las políticas hacen skip (default: allow)
+     * @param signal Optional AbortSignal para cancelar la evaluación
+     * @returns La decisión tomada por la primera política que no hizo skip
+     *
+     * @example
+     * ```typescript
+     * const decision = await evaluator.evaluateChain([
+     *   authPolicyInstance,
+     *   featureFlagPolicyInstance,
+     *   rolePolicyInstance
+     * ]);
+     * ```
+     */
+    evaluateChain(policyInstances: any[], defaultDecision?: PolicyDecisionType, signal?: AbortSignal): Promise<PolicyDecision>;
+    /**
+     * Evalúa una lista de candidatos y retorna el primero que pase las policies.
+     *
+     * Este método maneja:
+     * - Candidatos sin policies (permitir por defecto)
+     * - Instanciación de policies desde el DI container
+     * - Inyección de metadata
+     * - Evaluación secuencial hasta encontrar un allow
+     *
+     * @param candidates Lista de candidatos a evaluar
+     * @param signal Optional AbortSignal para cancelar
+     * @returns Decisión con el candidato ganador o block/redirect
+     */
+    evaluateCandidates(candidates: readonly RouteCandidate[], signal?: AbortSignal): Promise<PolicyDecision & {
+        candidate?: RouteCandidate;
+    }>;
+}