@securitydept/client-angular 0.3.0-beta.2 → 0.3.0-beta.5

package/types/securitydept-client-angular.d.ts

@@ -1,336 +1,193 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, EnvironmentProviders, WritableSignal } from '@angular/core';
-import { PlannerHost, AuthGuardClientOption, CandidateSelector, ScopedRequirementsClientSet, AuthRequirement, RequirementsClientSetComposition, RouteMatchNode } from '@securitydept/client/auth-coordination';
-export { resolveEffectiveClientSet } from '@securitydept/client/auth-coordination';
-import { ActivatedRouteSnapshot } from '@angular/router';
-import { ReadableSignalTrait } from '@securitydept/client';
+import { CanActivateFn, CanActivateChildFn, ActivatedRouteSnapshot, Route } from '@angular/router';
+import { AuthRequirement, RequirementBehaviourWithRouteContext, RequirementPlannerHost, RequirementPlannerHostBehaviour, RouteBehaviourContextExtra, RouteTreeSegment, RequirementsComposition, SecuritydeptProvider, SecuritydeptInjector, WithTraitInputValidator, EnvironmentValidators, RouterTrait, TraitInputValidator, BaseTransportTrait, FoundationEnvironment, InteropObservableTrait } from '@securitydept/client';
+import { InjectionToken, EnvironmentProviders, Injector, Provider, Signal } from '@angular/core';
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import { HttpResponse } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { rxResource, ToSignalOptions } from '@angular/core/rxjs-interop';
 
-/**
- * DI token for the shared {@link PlannerHost}.
- *
- * Provide at the app level via {@link provideAuthPlannerHost}.
- * Guards use {@link injectPlannerHost} to look up the nearest instance.
- */
-declare const AUTH_PLANNER_HOST: InjectionToken<PlannerHost>;
-/**
- * Options for {@link provideAuthPlannerHost}.
- */
-interface ProvideAuthPlannerHostOptions {
+interface CreateAngularGuardWithPlannerHostOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
     /**
-     * Custom candidate selection strategy.
-     * @see {@link CandidateSelector}
+     * Explicit planner host. When omitted, the guard uses the nearest
+     * {@link REQUIREMENT_PLANNER_HOST} from the Securitydept injector, falling
+     * back to an empty host only when no provider exists.
      */
-    selectCandidate?: CandidateSelector;
+    readonly plannerHost: RequirementPlannerHost<TBehaviour>;
+    readonly behaviour?: never;
 }
+interface CreateAngularGuardWithBehaviourOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
+    readonly plannerHost?: never;
+    readonly behaviour?: RequirementPlannerHostBehaviour<TAuthRequirement, RouteBehaviourContextExtra, TBehaviour>;
+}
+/** Options shared by {@link createAngularCanActivate} and its child variant. */
+type CreateAngularGuardOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> = CreateAngularGuardWithPlannerHostOptions<TAuthRequirement, TBehaviour> | CreateAngularGuardWithBehaviourOptions<TAuthRequirement, TBehaviour>;
 /**
- * Provide an {@link AUTH_PLANNER_HOST} at the current injector level.
- *
- * Use in app config, route providers, or NgModule providers to establish
- * a planner-host scope. Child routes inherit the nearest parent's planner.
- *
- * @example
- * ```ts
- * // app.config.ts — app-level planner (default sequential strategy)
- * export const appConfig: ApplicationConfig = {
- *   providers: [provideAuthPlannerHost()],
- * };
- *
- * // Feature route — override with custom async chooser strategy
- * {
- *   path: "admin",
- *   providers: [provideAuthPlannerHost({
- *     selectCandidate: async (candidates) => showAdminChooser(candidates),
- *   })],
- *   children: [...]
- * }
- * ```
+ * Create a `CanActivateFn` bridging the route chain to the requirement
+ * planner pipeline.
  */
-declare function provideAuthPlannerHost(options?: ProvideAuthPlannerHostOptions): EnvironmentProviders;
+declare function createAngularCanActivate<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(options?: CreateAngularGuardOptions<TAuthRequirement, TBehaviour>): CanActivateFn;
 /**
- * Inject the nearest {@link PlannerHost} from the DI hierarchy.
- *
- * Throws an explicit error if no planner-host is provided, preventing
- * silent fallback behavior.
- *
- * @example
- * ```ts
- * const plannerHost = injectPlannerHost();
- * const result = await plannerHost.evaluate(candidates);
- * ```
+ * Create a `CanActivateChildFn` bridging the child route chain to the
+ * requirement planner pipeline.
  */
-declare function injectPlannerHost(): PlannerHost;
+declare function createAngularCanActivateChild<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(options?: CreateAngularGuardOptions<TAuthRequirement, TBehaviour>): CanActivateChildFn;
+
 /**
- * DI token for the effective requirements client set at the current scope.
- *
- * The value is always the **resolved** options after composing all ancestor
- * scopes — it is NOT the raw `ScopedRequirementsClientSet` declaration.
- *
- * Provide via {@link provideRouteScopedRequirements}.
- * Guards inject this token to get the effective scope requirements and then
- * merge their own declared candidates on top.
+ * Resolved route `data` for a segment: static `routeConfig.data` merged with
+ * snapshot `data` (snapshot wins on key collision).
  */
-declare const AUTH_REQUIREMENTS_CLIENT_SET: InjectionToken<readonly AuthGuardClientOption[]>;
+declare function routeDataFromSegment(segment: ActivatedRouteSnapshot): Record<string, unknown>;
 /**
- * Provide a {@link ScopedRequirementsClientSet} at the current route/module scope.
- *
- * Internally, the provider resolves the effective client set by composing the
- * declared `scopedSet` with the parent scope's already-resolved options
- * (injected via `skipSelf: true`). The token value stored in DI is the
- * resolved `readonly AuthGuardClientOption[]`, not the raw declaration.
- *
- * This mirrors the React `AuthRequirementsClientSetProvider` semantics:
- * each level stores its resolved effective options, so children inherit
- * the composed result without re-resolving the full ancestor chain.
- *
- * The `scopedSet` argument may also be a **factory function** — it will be
- * called inside Angular's `useFactory` context, so `inject()` is valid.
- * Use this when the requirement options need DI-resolved services (e.g. a
- * token-set registry or a redirect service).
- *
- * @example
- * ```ts
- * // routes.ts — static declaration (no DI needed)
- * {
- *   path: "",
- *   providers: [
- *     provideRouteScopedRequirements({
- *       composition: RequirementsClientSetComposition.Replace,
- *       options: [sessionClientOption],
- *     }),
- *   ],
- * }
+ * Project the `pathFromRoot` of an `ActivatedRouteSnapshot` into the SDK's
+ * `RouteTreeSegment[]` chain (root -> leaf).
  *
- * // Feature route merges OIDC on top of the parent's session requirement
- * {
- *   path: "confluence",
- *   providers: [
- *     provideRouteScopedRequirements({
- *       composition: RequirementsClientSetComposition.Merge,
- *       options: [confluenceOidcClientOption],
- *     }),
- *   ],
- *   // Route-level DI scope only. Angular Router adopters should prefer
- *   // secureRouteRoot()/secureRoute() over direct guard wiring.
- * }
+ * Each segment carries its declared requirements and composition strategy;
+ * inherit/merge/replace folding is applied later by the
+ * `RouteCompositionRequirementPlanner`.
  *
- * // Factory form — use when options depend on injected services
- * {
- *   path: "protected",
- *   providers: [
- *     provideRouteScopedRequirements(() => {
- *       const registry = inject(TokenSetAuthRegistry);
- *       const authService = inject(AuthService);
- *       return {
- *         composition: RequirementsClientSetComposition.Replace,
- *         options: [{
- *           requirementId: "oidc",
- *           requirementKind: "frontend_oidc",
- *           checkAuthenticated: () => registry.require(clientKey).isAuthenticated(),
- *           onUnauthenticated: () => { authService.redirectToLogin(clientKey).subscribe(); return false; },
- *         }],
- *       };
- *     }),
- *   ],
- * }
- * ```
+ * Segments without a `routeConfig` (e.g. the root) get routeId `"__root__"`;
+ * empty-path segments get `"__index__"`.
  */
-declare function provideRouteScopedRequirements(scopedSet: ScopedRequirementsClientSet | (() => ScopedRequirementsClientSet)): EnvironmentProviders;
+declare function projectAngularRouteSegments<TAuthRequirement extends AuthRequirement = AuthRequirement>(leafRoute: ActivatedRouteSnapshot): RouteTreeSegment<TAuthRequirement>[];
 
-/**
- * Default key for auth requirements in Angular route `data`.
- *
- * Semantic alias for {@link DEFAULT_ROUTE_REQUIREMENTS_KEY} (defined in
- * `router.ts`). Both hold the same value (`"authRequirements"`).
- * Use either name — they are interchangeable.
- *
- * Set this key in `Route.data` to declare auth requirements for a route segment:
- * ```ts
- * { path: "dashboard", data: withRouteRequirements([{ id: "session", kind: "session" }]) }
- * ```
- *
- * The key is also read by {@link AuthRouteAdapter} when projecting snapshots.
- *
- * @see {@link withRouteRequirements}
- * @see {@link extractFullRouteRequirements}
- */
-declare const ROUTE_REQUIREMENTS_DATA_KEY = "authRequirements";
-/**
- * Default key for the route-level composition strategy in Angular route `data`.
- *
- * Used together with {@link ROUTE_REQUIREMENTS_DATA_KEY}. The default
- * composition is `merge` when the key is omitted.
- */
-declare const ROUTE_REQUIREMENTS_COMPOSITION_DATA_KEY = "authRequirementsComposition";
-/**
- * Route-level auth requirement declaration stored in Angular route `data`.
- */
-interface RouteRequirementsDeclaration {
-    requirements: readonly AuthRequirement[];
-    composition: RequirementsClientSetComposition;
-}
-/**
- * Options for {@link withRouteRequirements}.
- */
-interface WithRouteRequirementsOptions {
+interface SecureRouteSecurityOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
+    /** Auth requirements declared on this route segment. */
+    requirements?: readonly TAuthRequirement[];
+    /** Composition strategy against the inherited chain (default: `merge`). */
+    composition?: RequirementsComposition;
     /**
-     * How this route segment composes with its parent route chain.
-     * @default RequirementsClientSetComposition.Merge
+     * Explicit planner host for the guards on a root route. When omitted, the
+     * guard resolves the nearest host from DI (or a self-managed default).
      */
-    composition?: RequirementsClientSetComposition;
+    plannerHost?: RequirementPlannerHost<TBehaviour>;
     /**
-     * Additional route data properties to merge into the returned object.
+     * Behaviour to provide as a scoped {@link RequirementPlannerHost} at the
+     * root route. Mounted via `provideSecuritydept({ providers: [...] })`.
      */
-    extra?: Record<string, unknown>;
+    behaviour?: RequirementPlannerHostBehaviour<TAuthRequirement, RouteBehaviourContextExtra, TBehaviour>;
 }
+/** Additional route config merged into the produced {@link Route}. */
+type SecureRouteConfig = Omit<Route, "path">;
 /**
- * Build an Angular route `data` object declaring auth requirements for a
- * single route segment.
- *
- * Use this as the `data` field in an Angular `Route` config. Nested routes
- * can declare their own requirements; a full-route aggregation guard will
- * walk the entire `pathFromRoot` chain to collect all requirements in one pass.
- *
- * @example
- * ```ts
- * // Parent route declares base requirement
- * {
- *   path: "app",
- *   data: withRouteRequirements([{ id: "session", kind: "session" }]),
- *   children: [
- *     // Child route adds an additional requirement
- *     {
- *       path: "admin",
- *       data: withRouteRequirements([{ id: "admin-oidc", kind: "backend_oidc" }]),
- *       canActivate: [createTokenSetRouteAggregationGuard(...)],
- *     },
- *   ],
- * }
- * ```
- *
- * @param requirements - One or more auth requirements for this route segment.
- * @param extra - Optional additional data properties to merge.
+ * Declare a secure route segment: writes requirement metadata into route
+ * `data` only. No guard is attached — a guarded ancestor (see
+ * {@link secureRouteRoot}) enforces the folded chain.
  */
-declare function withRouteRequirements(requirements: AuthRequirement[], optionsOrExtra?: WithRouteRequirementsOptions | Record<string, unknown>, maybeExtra?: Record<string, unknown>): Record<string, unknown>;
+declare function secureRoute<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(path: string, security: SecureRouteSecurityOptions<TAuthRequirement, TBehaviour>, routeOptions?: SecureRouteConfig): Route;
 /**
- * Extract and flatten auth requirements from a complete Angular route chain.
- *
- * Walks all segments from root to leaf (from `leafRoute.pathFromRoot`)
- * and concatenates the declared {@link AuthRequirement} arrays in order.
- * Requirements from ancestor routes appear before requirements from
- * descendant routes. Duplicate `id` values are NOT de-duplicated here —
- * the caller (guard / enforcement layer) is responsible for deduplication
- * or merge logic.
- *
- * This is the extraction counter-part to {@link withRouteRequirements}.
- * A full-route aggregation guard calls this once and hands the complete
- * flat array to the planner / enforcement layer.
+ * Declare a guarded root route: writes requirement metadata AND attaches
+ * `canActivate` + `canActivateChild` guards bound to the requirement planner.
  *
- * @param leafRoute - The leaf `ActivatedRouteSnapshot` from the guard call.
- * @param requirementsKey - Override the route data key (default: `"authRequirements"`).
+ * When `security.behaviour` is set, a scoped {@link RequirementPlannerHost}
+ * provider is mounted so descendant guards inherit it through DI.
  */
-declare function extractFullRouteRequirements(leafRoute: ActivatedRouteSnapshot, requirementsKey?: string, compositionKey?: string): AuthRequirement[];
+declare function secureRouteRoot<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(path: string, security: SecureRouteSecurityOptions<TAuthRequirement, TBehaviour>, routeOptions?: SecureRouteConfig): Route;
+
+declare const SECURITYDEPT_INJECTOR: InjectionToken<SecuritydeptInjector>;
+interface ProvideSecuritydeptOptions {
+    readonly providers?: readonly SecuritydeptProvider[];
+    readonly autoCreateDestroyRef?: boolean;
+}
+declare function provideSecuritydept(options?: ProvideSecuritydeptOptions): EnvironmentProviders;
+
 /**
- * Resolve the effective auth requirements by composing the parent chain with a
- * child route declaration.
+ * Minimal navigation surface required from an Angular `Router`.
  *
- * Composition semantics mirror `resolveEffectiveClientSet()`:
- * - `inherit` keeps the parent requirements unchanged
- * - `merge` appends child requirements and replaces same-id parent entries
- * - `replace` discards the parent chain and uses only the child's requirements
+ * The real `@angular/router` `Router` satisfies this shape, so adopters pass
+ * their injected `Router` directly.
  */
-declare function resolveEffectiveRequirements(parentRequirements: readonly AuthRequirement[], child: RouteRequirementsDeclaration): AuthRequirement[];
-
-/** Options for {@link AuthRouteAdapter} projection methods. */
-interface AuthRouteAdapterOptions {
-    /**
-     * Key used to read auth requirements from route `data`.
-     *
-     * @default "authRequirements"
-     */
-    requirementsKey?: string;
+interface AngularRouterNavigationLike {
+    url?: string;
+    navigateByUrl(url: string, options?: {
+        replaceUrl?: boolean;
+        state?: unknown;
+    }): Promise<boolean> | boolean;
 }
-/** Default key for auth requirements in Angular route `data`. */
-declare const DEFAULT_ROUTE_REQUIREMENTS_KEY = "authRequirements";
-/** Result from {@link AuthRouteAdapter.check}. */
-interface RouteGuardResult {
-    /** Whether all requirements are settled (route can activate). */
-    canActivate: boolean;
-    /** The pending requirement still awaiting resolution, if any. */
-    pendingRequirement: AuthRequirement | null;
+/** Options for {@link createRouterForAngular}. */
+interface CreateRouterForAngularOptions {
+    /** The Angular `Router` (or a compatible navigation object). */
+    router: AngularRouterNavigationLike;
+    /** Override the current URL. Defaults to `router.url`. */
+    currentUrl?: string | null;
 }
+interface ResolvedRouterForAngularCreateOptions {
+    router: AngularRouterNavigationLike;
+    currentUrl: string | null;
+}
+declare const AngularRouterNavigationLikeSchema: arktype_internal_variants_object_ts.ObjectType<{
+    navigateByUrl: Function;
+    url?: string | undefined;
+}, {}>;
 /**
- * Angular service that bridges Angular Router's `ActivatedRouteSnapshot` to
- * the SDK's framework-agnostic `RouteMatchNode[]` contract.
- *
- * Inject this into `CanActivateFn` guards or class-based guards.
+ * Create a {@link RouterTrait} backed by an Angular `Router`.
  *
  * @example
  * ```ts
- * export const authGuard: CanActivateFn = (route) => {
- *   const adapter = inject(AuthRouteAdapter);
- *   const result = adapter.check(route, orchestrator);
- *   if (!result.canActivate && result.pendingRequirement) {
- *     // Trigger auth flow for the pending requirement
- *   }
- *   return result.canActivate;
- * };
+ * const routerTrait = createRouterForAngular({ router: inject(Router) });
  * ```
  */
-declare class AuthRouteAdapter {
-    /**
-     * Project the `pathFromRoot` of an `ActivatedRouteSnapshot` into the SDK's
-     * `RouteMatchNode[]` chain.
-     *
-     * Route segments without a `routeConfig` (e.g. the root segment) are
-     * assigned routeId `"__root__"`. Segments with a config use the `path`
-     * as their routeId (or `"__index__"` for empty-path segments).
-     */
-    projectRouteMatch(leafRoute: ActivatedRouteSnapshot, options?: AuthRouteAdapterOptions): RouteMatchNode[];
-    /**
-     * Project an explicit array of `ActivatedRouteSnapshot` segments into the
-     * SDK's `RouteMatchNode[]` chain.
-     *
-     * Use when you already have a flattened chain (e.g. from
-     * `ActivatedRoute.pathFromRoot`).
-     */
-    projectRouteSegments(segments: readonly ActivatedRouteSnapshot[], options?: AuthRouteAdapterOptions): RouteMatchNode[];
-    /**
-     * Project the route snapshot and check whether all requirements are settled.
-     *
-     * @param leafRoute - The leaf `ActivatedRouteSnapshot` from the guard call.
-     * @param orchestrator - The SDK orchestrator managing the requirement plan.
-     * @param options - Optional projection options.
-     */
-    check(leafRoute: ActivatedRouteSnapshot, orchestrator: {
-        activateMatchedRoutes(chain: readonly RouteMatchNode[]): void;
-        snapshot(): {
-            settled: boolean;
-            pendingRequirement: AuthRequirement | null;
-        };
-    }, options?: AuthRouteAdapterOptions): RouteGuardResult;
-    private segmentToNode;
-    private resolveRouteId;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthRouteAdapter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthRouteAdapter>;
+declare function createRouterForAngular(options: CreateRouterForAngularOptions & WithTraitInputValidator<Pick<EnvironmentValidators, "router">>): RouterTrait;
+
+interface AngularHttpClientLike {
+    request(method: string, url: string, options: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        observe: "response";
+        responseType: "text";
+    }): Observable<HttpResponse<string>>;
 }
+interface BaseTransportForAngularCreateOptions {
+    httpClient: AngularHttpClientLike;
+    baseUrl?: string | URL;
+}
+declare const BaseTransportForAngularCreateOptionsSchema: arktype_internal_variants_object_ts.ObjectType<{
+    httpClient: {
+        request: Function;
+    };
+    baseUrl: unknown;
+}, {}>;
+declare function createBaseTransportForAngular(options: BaseTransportForAngularCreateOptions & WithTraitInputValidator<TraitInputValidator>): BaseTransportTrait;
 
-/**
- * Bridge an SDK `ReadableSignalTrait` to an Angular writable signal.
- *
- * Immediately syncs the current value, then subscribes to future changes.
- *
- * @returns Cleanup function that unsubscribes from the SDK signal.
- */
-declare function bridgeToAngularSignal<T>(source: ReadableSignalTrait<T>, target: WritableSignal<T>): () => void;
-/**
- * Bridge an SDK `ReadableSignalTrait` to an RxJS Observable.
- *
- * The observable emits the current value immediately on subscribe, then
- * emits whenever the SDK signal value changes. Completes on unsubscribe.
- */
-declare function signalToObservable<T>(source: ReadableSignalTrait<T>): Observable<T>;
+declare const ENVIRONMENT: InjectionToken<FoundationEnvironment>;
+declare const ENVIRONMENT_PROVIDER: InjectionToken<SecuritydeptProvider>;
+type EnvironmentCreatorOptions = {
+    providers?: readonly SecuritydeptProvider[];
+};
+type EnvironmentCreator<TOptions extends EnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment> = (options: TOptions) => TEnvironment;
+type CreateEnvironmentForAngularOptions<TBaseOptions extends EnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment> = Omit<TBaseOptions, "providers" | "routerForAngularCreateOptions" | "transportForAngularCreateOptions" | "injectorForAngularProvider" | "createBaseEnvironment"> & {
+    createBaseEnvironment: EnvironmentCreator<TBaseOptions, TEnvironment>;
+    routerForAngularCreateOptions: CreateRouterForAngularOptions;
+    transportForAngularCreateOptions: BaseTransportForAngularCreateOptions;
+    injectorForAngularProvider?: Injector;
+    providers?: readonly SecuritydeptProvider[];
+};
+type ProvideEnvironmentOptions<TBaseOptions extends EnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment> = Omit<CreateEnvironmentForAngularOptions<TBaseOptions, TEnvironment>, "routerForAngularCreateOptions" | "transportForAngularCreateOptions" | "injectorForAngularProvider" | "providers"> & ProvideSecuritydeptOptions & {
+    routerForAngularCreateOptions?: Partial<CreateRouterForAngularOptions>;
+    transportForAngularCreateOptions?: Partial<BaseTransportForAngularCreateOptions>;
+};
+declare function createEnvironmentForAngular<TBaseOptions extends EnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment>(options: CreateEnvironmentForAngularOptions<TBaseOptions, TEnvironment>): TEnvironment;
+declare function provideEnvironment<TBaseOptions extends EnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment>(options: ProvideEnvironmentOptions<TBaseOptions, TEnvironment>): Provider[];
+declare function provideEnvironmentProvider(provider: SecuritydeptProvider): Provider;
+
+declare function toNgSignal<T>(source: InteropObservableTrait<T>): Signal<T | undefined>;
+declare function toNgSignal<T>(source: InteropObservableTrait<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
+    initialValue?: undefined;
+    requireSync?: false;
+}): Signal<T | undefined>;
+declare function toNgSignal<T>(source: InteropObservableTrait<T>, options: NoInfer<ToSignalOptions<T | null>> & {
+    initialValue?: null;
+    requireSync?: false;
+}): Signal<T | null>;
+declare function toNgSignal<T>(source: InteropObservableTrait<T>, options: NoInfer<ToSignalOptions<T>> & {
+    initialValue?: undefined;
+    requireSync: true;
+}): Signal<T>;
+declare function toNgSignal<T, const U extends T>(source: InteropObservableTrait<T>, options: NoInfer<ToSignalOptions<T | U>> & {
+    initialValue: U;
+    requireSync?: false;
+}): Signal<T | U>;
+declare const toNgResource: typeof rxResource;
 
-export { AUTH_PLANNER_HOST, AUTH_REQUIREMENTS_CLIENT_SET, AuthRouteAdapter, DEFAULT_ROUTE_REQUIREMENTS_KEY, ROUTE_REQUIREMENTS_COMPOSITION_DATA_KEY, ROUTE_REQUIREMENTS_DATA_KEY, bridgeToAngularSignal, extractFullRouteRequirements, injectPlannerHost, provideAuthPlannerHost, provideRouteScopedRequirements, resolveEffectiveRequirements, signalToObservable, withRouteRequirements };
-export type { AuthRouteAdapterOptions, ProvideAuthPlannerHostOptions, RouteGuardResult, RouteRequirementsDeclaration, WithRouteRequirementsOptions };
+export { AngularRouterNavigationLikeSchema, BaseTransportForAngularCreateOptionsSchema, ENVIRONMENT, ENVIRONMENT_PROVIDER, SECURITYDEPT_INJECTOR, createAngularCanActivate, createAngularCanActivateChild, createBaseTransportForAngular, createEnvironmentForAngular, createRouterForAngular, projectAngularRouteSegments, provideEnvironment, provideEnvironmentProvider, provideSecuritydept, routeDataFromSegment, secureRoute, secureRouteRoot, toNgResource, toNgSignal };
+export type { AngularHttpClientLike, AngularRouterNavigationLike, BaseTransportForAngularCreateOptions, CreateAngularGuardOptions, CreateAngularGuardWithBehaviourOptions, CreateAngularGuardWithPlannerHostOptions, CreateEnvironmentForAngularOptions, CreateRouterForAngularOptions, EnvironmentCreator, EnvironmentCreatorOptions, ProvideEnvironmentOptions, ProvideSecuritydeptOptions, ResolvedRouterForAngularCreateOptions, SecureRouteConfig, SecureRouteSecurityOptions };
 //# sourceMappingURL=securitydept-client-angular.d.ts.map

package/types/securitydept-client-angular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"securitydept-client-angular.d.ts","sources":["../../src/lib/planner-host.ts","../../src/lib/route-requirements.ts","../../src/lib/router.ts","../../src/lib/signal-bridge.ts"],"mappings":";;;;;;;;AAwCA;;;;;AAKG;AACH,cAAa,iBAAiB,EAAA,cAAA,CAAA,WAAA;AAI9B;;AAEG;UACc,6BAA6B;AAC7C;;;AAGG;sBACe,iBAAiB;AACnC;AAED;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,iBAAgB,sBAAsB,WAC3B,6BAA6B,GACrC,oBAAoB;AAUvB;;;;;;;;;;;AAWG;AACH,iBAAgB,iBAAiB,IAAI,WAAW;AAgBhD;;;;;;;;;AASG;AACH,cAAa,4BAA4B,EAAA,cAAA,UAAA,qBAAA;AAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DG;AACH,iBAAgB,8BAA8B,YAClC,2BAA2B,UAAU,2BAA2B,IACzE,oBAAoB;;ACpKvB;;;;;;;;;;;;;;;;AAgBG;AACH,cAAa,2BAA2B;AAExC;;;;;AAKG;AACH,cAAa,uCAAuC;AAGpD;;AAEG;UACc,4BAA4B;AAC5C,2BAAuB,eAAe;iBACzB,gCAAgC;AAC7C;AAED;;AAEG;UACc,4BAA4B;AAC5C;;;AAGG;kBACW,gCAAgC;AAE9C;;AAEG;YACK,MAAM;AACd;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACH,iBAAgB,qBAAqB,eACtB,eAAe,qBACZ,4BAA4B,GAAG,MAAM,gCACzC,MAAM,oBACjB,MAAM;AAgBT;;;;;;;;;;;;;;;;AAgBG;AACH,iBAAgB,4BAA4B,YAChC,sBAAsB,sDAG/B,eAAe;AAmBlB;;;;;;;;AAQG;AACH,iBAAgB,4BAA4B,8BACd,eAAe,WACrC,4BAA4B,GACjC,eAAe;;ACvKlB;UACiB,uBAAuB;AACvC;;;;AAIG;;AAEH;AAED;AACA,cAAa,8BAA8B;AAM3C;UACiB,gBAAgB;;;;AAIhC,wBAAoB,eAAe;AACnC;AAMD;;;;;;;;;;;;;;;;;AAiBG;AACH,cACa,gBAAgB;AAC5B;;;;;;;AAOG;iCAES,sBAAsB,YACvB,uBAAuB,GAC/B,cAAc;AAMjB;;;;;;AAMG;AACH,4CACoB,sBAAsB,cAC/B,uBAAuB,GAC/B,cAAc;AAKjB;;;;;;AAMG;AACH,qBACY,sBAAsB;8CAEM,cAAc;AACpD;;AAEC,gCAAoB,eAAe;;AAEpC,iBACS,uBAAuB,GAC/B,gBAAgB;AAUnB;AAaA;yCAzEY,gBAAgB;6CAAhB,gBAAgB;AA+E5B;;ACzID;;;;;;AAMG;AACH,iBAAgB,qBAAqB,YAC5B,mBAAmB,aACnB,cAAc;AAQvB;;;;;AAKG;AACH,iBAAgB,kBAAkB,YACzB,mBAAmB,MACzB,UAAU;;;;","names":[]}
+{"version":3,"file":"securitydept-client-angular.d.ts","sources":["../../src/lib/auth-coordination/route-guard.ts","../../src/lib/auth-coordination/route-metadata.ts","../../src/lib/auth-coordination/secure-routes.ts","../../src/lib/injection.ts","../../src/lib/router.ts","../../src/lib/transport.ts","../../src/lib/environment.ts","../../src/lib/interop.ts"],"mappings":"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","names":["AngularHttpResponse"]}