@atlasauth/angular 0.1.0

package/dist/lib/components/organization-switcher.component.d.ts

@@ -0,0 +1,15 @@
+import { AtlasService } from '../atlas.service';
+import { type ElementKey } from '../appearance';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-organization-switcher>` — switch the active organization (or the
+ * personal account). The Angular peer of React's `<OrganizationSwitcher/>`.
+ */
+export declare class OrganizationSwitcherComponent {
+    protected readonly atlas: AtlasService;
+    protected t(key: string): string;
+    protected cls(key: ElementKey, base: string): string;
+    protected setActive(organizationId: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OrganizationSwitcherComponent, "atlas-organization-switcher", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/components/sign-in.component.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { AtlasFlowController } from './flow-controller';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-sign-in>` — the full, multi-step sign-in flow driven entirely by the
+ * server-side attempt status. The Angular peer of React's `<SignIn/>`.
+ *
+ * ```html
+ * <atlas-sign-in *atlasSignedOut afterUrl="/dashboard"></atlas-sign-in>
+ * ```
+ */
+export declare class SignInComponent implements OnInit, OnDestroy {
+    private readonly atlas;
+    /** Where to send the user once the flow completes. Reserved for host routing. */
+    afterUrl?: string;
+    protected readonly flow: AtlasFlowController;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignInComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SignInComponent, "atlas-sign-in", never, { "afterUrl": { "alias": "afterUrl"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/components/sign-up.component.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy } from '@angular/core';
+import { AtlasFlowController } from './flow-controller';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-sign-up>` — the full, server-driven sign-up flow. The Angular peer of
+ * React's `<SignUp/>`. It shares the exact flow engine with `<atlas-sign-in>`;
+ * only the title differs, because the sequence of steps is decided by the server.
+ *
+ * ```html
+ * <atlas-sign-up *atlasSignedOut></atlas-sign-up>
+ * ```
+ */
+export declare class SignUpComponent implements OnDestroy {
+    private readonly atlas;
+    /** Where to send the user once the flow completes. Reserved for host routing. */
+    afterUrl?: string;
+    protected readonly flow: AtlasFlowController;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignUpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SignUpComponent, "atlas-sign-up", never, { "afterUrl": { "alias": "afterUrl"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/components/user-button.component.d.ts

@@ -0,0 +1,19 @@
+import { AtlasService } from '../atlas.service';
+import { type ElementKey } from '../appearance';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-user-button>` — the signed-in user's avatar with a drop-down that can
+ * sign them out. The Angular peer of React's `<UserButton/>`. Renders nothing
+ * when there is no user.
+ */
+export declare class UserButtonComponent {
+    protected readonly atlas: AtlasService;
+    protected readonly open: import("@angular/core").WritableSignal<boolean>;
+    protected readonly label: import("@angular/core").Signal<string>;
+    protected t(key: string): string;
+    protected cls(key: ElementKey, base: string): string;
+    protected toggle(): void;
+    protected signOut(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserButtonComponent, "atlas-user-button", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/components/user-profile.component.d.ts

@@ -0,0 +1,15 @@
+import { AtlasService } from '../atlas.service';
+import { type ElementKey } from '../appearance';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-user-profile>` — the signed-in user's account surface (emails,
+ * security). The Angular peer of React's `<UserProfile/>`. Renders nothing when
+ * there is no user.
+ */
+export declare class UserProfileComponent {
+    protected readonly atlas: AtlasService;
+    protected t(key: string): string;
+    protected cls(key: ElementKey, base: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserProfileComponent, "atlas-user-profile", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/atlas-root.directive.d.ts

@@ -0,0 +1,26 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `atlasRoot` — apply the resolved appearance design tokens as `--atlas-*` CSS
+ * custom properties (and the `atlas-root` class) onto its host element, so the
+ * Atlas components rendered inside inherit them.
+ *
+ * React does this with the wrapping `<div className="atlas-root" style={…}>`
+ * inside `<AtlasProvider>`. Angular has no single wrapping element, so a
+ * consumer opts in by putting `atlasRoot` on whatever element encloses the
+ * Atlas UI (commonly the app root):
+ *
+ * ```html
+ * <div atlasRoot>
+ *   <router-outlet></router-outlet>
+ * </div>
+ * ```
+ */
+export declare class AtlasRootDirective implements OnInit {
+    private readonly atlas;
+    private readonly el;
+    private readonly renderer;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasRootDirective, "[atlasRoot]", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/loaded.directive.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasLoaded` — render the template only once the SDK has finished booting.
+ * The Angular peer of React's `<AtlasLoaded>`, the symmetric partner of
+ * `*atlasLoading`.
+ */
+export declare class AtlasLoadedDirective extends AtlasToggleDirective {
+    protected source(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasLoadedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasLoadedDirective, "[atlasLoaded]", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/loading.directive.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasLoading` — render the template only while the SDK is still booting. The
+ * Angular peer of React's `<AtlasLoading>`; show a spinner here.
+ */
+export declare class AtlasLoadingDirective extends AtlasToggleDirective {
+    protected source(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasLoadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasLoadingDirective, "[atlasLoading]", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/protect.directive.d.ts

@@ -0,0 +1,41 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { type ProtectCondition } from '@atlasauth/authz';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasProtect` — render the template only when the active organization role
+ * satisfies a {@link ProtectCondition}. The Angular peer of React's
+ * `<Protect permission="…">`.
+ *
+ * A RENDERING helper, never an authorization boundary: anyone can flip the
+ * condition in devtools. The server checking the same permission is what
+ * actually stops them — this directive's only job is to avoid showing a control
+ * that would fail.
+ *
+ * ```html
+ * <button *atlasProtect="{ permission: 'org:sys_memberships:manage' }">Invite</button>
+ *
+ * <!-- with a fallback (identical microsyntax to *ngIf … else) -->
+ * <div *atlasProtect="{ role: 'admin' }; else denied">Admin tools</div>
+ * <ng-template #denied>You lack access.</ng-template>
+ * ```
+ *
+ * An empty condition (`*atlasProtect`) means simply "signed in".
+ */
+export declare class AtlasProtectDirective implements OnInit, OnDestroy {
+    private readonly atlas;
+    private readonly templateRef;
+    private readonly viewContainer;
+    private readonly condition$;
+    private elseTemplate;
+    private sub?;
+    private rendered;
+    /** The condition to evaluate. An empty/omitted value means "signed in". */
+    set atlasProtect(condition: ProtectCondition | '' | null | undefined);
+    /** Template rendered when the condition is not met (the `else` branch). */
+    set atlasProtectElse(template: TemplateRef<unknown> | null);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private show;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasProtectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasProtectDirective, "[atlasProtect]", never, { "atlasProtect": { "alias": "atlasProtect"; "required": false; }; "atlasProtectElse": { "alias": "atlasProtectElse"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/directives/signed-in.directive.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasSignedIn` — render the template only when the SDK has loaded AND the
+ * user is signed in. The Angular peer of React's `<SignedIn>`. Renders nothing
+ * while loading, so no signed-in UI flashes before boot completes.
+ *
+ * ```html
+ * <div *atlasSignedIn>Welcome back</div>
+ * ```
+ */
+export declare class AtlasSignedInDirective extends AtlasToggleDirective {
+    protected source(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasSignedInDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasSignedInDirective, "[atlasSignedIn]", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/signed-out.directive.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasSignedOut` — render the template only when the SDK has loaded AND the
+ * user is signed out. The Angular peer of React's `<SignedOut>`. Renders nothing
+ * while loading, the symmetric partner of `*atlasSignedIn`.
+ *
+ * ```html
+ * <atlas-sign-in *atlasSignedOut></atlas-sign-in>
+ * ```
+ */
+export declare class AtlasSignedOutDirective extends AtlasToggleDirective {
+    protected source(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasSignedOutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasSignedOutDirective, "[atlasSignedOut]", never, {}, {}, never, never, true, never>;
+}

package/dist/lib/directives/toggle.directive.d.ts

@@ -0,0 +1,25 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AtlasService } from '../atlas.service';
+import * as i0 from "@angular/core";
+/**
+ * Shared machinery for the boolean structural directives (`*atlasSignedIn`,
+ * `*atlasSignedOut`, `*atlasLoading`, `*atlasLoaded`). A subclass names the
+ * stream to gate on; this base mounts the embedded view exactly when that stream
+ * is true and tears it down otherwise, mirroring how the React `<SignedIn>` /
+ * `<SignedOut>` components render `children` or `null`.
+ */
+export declare abstract class AtlasToggleDirective implements OnInit, OnDestroy {
+    protected readonly atlas: AtlasService;
+    private readonly templateRef;
+    private readonly viewContainer;
+    private sub?;
+    private shown;
+    /** The stream whose truthiness controls whether the template renders. */
+    protected abstract source(): Observable<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private render;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AtlasToggleDirective, never, never, {}, {}, never, never, false, never>;
+}

package/dist/lib/fapi.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The FAPI client and the server-driven sign-in flow driver live in `@atlasauth/js`
+ * — the pure, framework-agnostic browser flow. This thin re-export lets the
+ * Angular components, guards and services resolve the driver from one place, so
+ * the Angular `<atlas-sign-in>` and the React `<SignIn/>` drive the exact same
+ * endpoints and cannot diverge in what the server sees.
+ */
+export { FapiClient, advance, prepareFactor, pollAttempt, shouldKeepPolling, requestForStep, flowFromPending, initialFlow, getProviderToken, type FapiClientOptions, type FapiResponse, type FlowState, type ProviderToken, } from '@atlasauth/js';

package/dist/lib/guards/atlas.guard.d.ts

@@ -0,0 +1,43 @@
+import { CanActivateChildFn, CanActivateFn } from '@angular/router';
+import { type ProtectCondition } from '@atlasauth/authz';
+export interface AtlasGuardOptions extends ProtectCondition {
+    /**
+     * Where to send a user who fails the check. When set, the guard returns a
+     * `UrlTree` (a redirect); when omitted it simply returns `false` and the
+     * navigation is cancelled. A common value is your sign-in route.
+     */
+    redirectTo?: string;
+    /**
+     * When true, append the attempted URL as a `redirect_url` query param on the
+     * `redirectTo` target, so the sign-in page can send the user back afterwards.
+     * Ignored unless `redirectTo` is set. Defaults to true.
+     */
+    preserveReturnUrl?: boolean;
+}
+/**
+ * Route guard factory that gates a route on session — and optionally on a
+ * permission/role. The Angular peer of using `<SignedIn>` / `<Protect>` to fence
+ * a page, expressed as a `CanActivateFn`.
+ *
+ * ```ts
+ * export const routes: Routes = [
+ *   { path: 'dashboard', canActivate: [atlasGuard({ redirectTo: '/sign-in' })], ... },
+ *   {
+ *     path: 'admin',
+ *     canActivate: [atlasGuard({ permission: 'org:admin', redirectTo: '/' })],
+ *     ...
+ *   },
+ * ];
+ * ```
+ *
+ * The guard first waits for the SDK to finish booting, so a hard refresh onto a
+ * protected URL does not bounce to sign-in before the session has been read.
+ * Like the components, this is UX, not security: the server enforces the same
+ * checks on every request.
+ */
+export declare function atlasGuard(options?: AtlasGuardOptions): CanActivateFn;
+/**
+ * The `CanActivateChild` form of {@link atlasGuard}, for gating a whole child
+ * route subtree with one declaration.
+ */
+export declare function atlasChildGuard(options?: AtlasGuardOptions): CanActivateChildFn;

package/dist/lib/i18n.d.ts

@@ -0,0 +1,23 @@
+/**
+ * §10.3: "Every string passes through an i18n catalog; en-US ships, catalog
+ * format documented for community locales."
+ *
+ * A flat key-to-string map rather than nested objects, because nesting looks
+ * tidier and makes a missing key a runtime crash on `undefined.of.a.chain`
+ * rather than a visible fallback.
+ *
+ * A missing key renders the KEY, not an empty string. A blank button is a bug
+ * nobody can report; a button reading `signIn.submit` is one anyone can.
+ */
+export type Catalog = Record<string, string>;
+export declare const EN_US: Catalog;
+/**
+ * Look up a key and interpolate `{placeholders}`.
+ *
+ * An unknown placeholder is left visible for the same reason a missing key is:
+ * `Continue with {provider}` in the UI is a bug report waiting to be filed,
+ * whereas `Continue with ` is one nobody notices until a customer does.
+ */
+export declare function translate(catalog: Catalog, key: string, variables?: Record<string, string>): string;
+/** Merge a community locale over en-US so a partial translation still renders. */
+export declare function withFallback(locale: Catalog): Catalog;

package/dist/lib/protect.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Conditional-rendering authorization primitive — re-exported unchanged from
+ * `@atlasauth/authz`, the ONE evaluator every Atlas SDK shares. `*atlasProtect` in
+ * this package and `<Protect>` in `@atlasauth/react` therefore judge a condition
+ * identically, and the server checking the same permission is what actually
+ * stops a request; these helpers only decide what a user is shown.
+ */
+export { type ProtectCondition, type ProtectOutcome, type ProtectReason, evaluate, hasFromClaims, } from '@atlasauth/authz';

package/dist/lib/provide-atlas.d.ts

@@ -0,0 +1,46 @@
+import { EnvironmentProviders, ModuleWithProviders } from '@angular/core';
+import { type AtlasOptions } from './atlas.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/signed-in.directive";
+import * as i2 from "./directives/signed-out.directive";
+import * as i3 from "./directives/loading.directive";
+import * as i4 from "./directives/loaded.directive";
+import * as i5 from "./directives/protect.directive";
+import * as i6 from "./directives/atlas-root.directive";
+import * as i7 from "./components/sign-in.component";
+import * as i8 from "./components/sign-up.component";
+import * as i9 from "./components/user-button.component";
+import * as i10 from "./components/organization-switcher.component";
+import * as i11 from "./components/user-profile.component";
+import * as i12 from "./components/organization-profile.component";
+/**
+ * Standalone-provider entry point (Angular 17+). Register Atlas once at the
+ * application root — the direct analogue of wrapping the tree in React's
+ * `<AtlasProvider publishableKey>`:
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideAtlas({ publishableKey: 'pk_test_…' }),
+ *     provideRouter(routes),
+ *   ],
+ * });
+ * ```
+ *
+ * The returned providers make {@link AtlasService} injectable and eagerly
+ * construct it, so the SDK begins its first boot (redirect-completion + session
+ * read) as soon as the app starts — matching the React provider mounting on the
+ * first render.
+ */
+export declare function provideAtlas(options: AtlasOptions): EnvironmentProviders;
+/**
+ * NgModule entry point for apps not yet on the standalone bootstrap. Import
+ * `AtlasModule.forRoot({ publishableKey })` once in the root module; feature
+ * modules import `AtlasModule` (no args) to use the directives/components.
+ */
+export declare class AtlasModule {
+    static forRoot(options: AtlasOptions): ModuleWithProviders<AtlasModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtlasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AtlasModule, never, [typeof i1.AtlasSignedInDirective, typeof i2.AtlasSignedOutDirective, typeof i3.AtlasLoadingDirective, typeof i4.AtlasLoadedDirective, typeof i5.AtlasProtectDirective, typeof i6.AtlasRootDirective, typeof i7.SignInComponent, typeof i8.SignUpComponent, typeof i9.UserButtonComponent, typeof i10.OrganizationSwitcherComponent, typeof i11.UserProfileComponent, typeof i12.OrganizationProfileComponent], [typeof i1.AtlasSignedInDirective, typeof i2.AtlasSignedOutDirective, typeof i3.AtlasLoadingDirective, typeof i4.AtlasLoadedDirective, typeof i5.AtlasProtectDirective, typeof i6.AtlasRootDirective, typeof i7.SignInComponent, typeof i8.SignUpComponent, typeof i9.UserButtonComponent, typeof i10.OrganizationSwitcherComponent, typeof i11.UserProfileComponent, typeof i12.OrganizationProfileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AtlasModule>;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Public data shapes, mirrored 1:1 from `@atlasauth/react`'s `types.ts` so an app
+ * can move between the React and Angular SDKs without re-typing its models.
+ */
+export interface SessionClaims {
+    sub: string;
+    sid: string;
+    exp: number;
+    org_id?: string;
+    org_slug?: string;
+    org_role?: string;
+    org_permissions?: string[];
+    mfa?: boolean;
+    [claim: string]: unknown;
+}
+export interface AtlasUser {
+    id: string;
+    first_name: string | null;
+    last_name: string | null;
+    username: string | null;
+    image_url: string | null;
+    public_metadata: Record<string, unknown>;
+    unsafe_metadata: Record<string, unknown>;
+    mfa_enabled: boolean;
+    has_password: boolean;
+    email_addresses?: Array<{
+        id: string;
+        email_address: string;
+        verified: boolean;
+        primary: boolean;
+    }>;
+}
+export interface AtlasOrganizationMembership {
+    role: string;
+    organization: {
+        id: string;
+        name: string;
+        slug: string;
+        image_url: string | null;
+    };
+}
+export interface AtlasSession {
+    id: string;
+    status: string;
+    last_active_organization_id: string | null;
+}
+/** The three-state auth lifecycle, identical to the React provider's. */
+export type AuthStatus = 'loading' | 'signed_in' | 'signed_out';

package/dist/public-api.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `@atlasauth/angular` — the official Angular SDK for Atlas, the Angular peer of
+ * `@atlasauth/react`. Public surface.
+ */
+export { ATLAS_OPTIONS, type AtlasOptions } from './lib/atlas.config';
+export { provideAtlas, AtlasModule } from './lib/provide-atlas';
+export { AtlasService } from './lib/atlas.service';
+export { AtlasSignedInDirective } from './lib/directives/signed-in.directive';
+export { AtlasSignedOutDirective } from './lib/directives/signed-out.directive';
+export { AtlasLoadingDirective } from './lib/directives/loading.directive';
+export { AtlasLoadedDirective } from './lib/directives/loaded.directive';
+export { AtlasProtectDirective } from './lib/directives/protect.directive';
+export { AtlasRootDirective } from './lib/directives/atlas-root.directive';
+export { SignInComponent } from './lib/components/sign-in.component';
+export { SignUpComponent } from './lib/components/sign-up.component';
+export { UserButtonComponent } from './lib/components/user-button.component';
+export { OrganizationSwitcherComponent } from './lib/components/organization-switcher.component';
+export { UserProfileComponent } from './lib/components/user-profile.component';
+export { OrganizationProfileComponent } from './lib/components/organization-profile.component';
+export { AttemptFlowComponent } from './lib/components/attempt-flow.component';
+export { AtlasFlowController } from './lib/components/flow-controller';
+export { ATLAS_UI } from './lib/atlas.ui';
+export { atlasGuard, atlasChildGuard, type AtlasGuardOptions, } from './lib/guards/atlas.guard';
+export * from './lib/appearance';
+export * from './lib/i18n';
+export * from './lib/protect';
+export * from './lib/types';
+export * from './lib/fapi';

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@atlasauth/angular",
+  "version": "0.1.0",
+  "description": "Official Angular SDK for Atlas — the Angular peer of @atlasauth/react.",
+  "license": "MIT",
+  "module": "./dist/fesm2022/atlas-angular.mjs",
+  "typings": "./dist/index.d.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "esm2022": "./dist/esm2022/atlas-angular.mjs",
+      "default": "./dist/fesm2022/atlas-angular.mjs"
+    }
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.6.3",
+    "@atlasauth/js": "0.1.0",
+    "@atlasauth/authz": "0.1.0"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=17",
+    "@angular/common": ">=17",
+    "@angular/router": ">=17",
+    "rxjs": ">=7"
+  },
+  "peerDependenciesMeta": {
+    "@angular/router": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/common": "^17.3.0",
+    "@angular/compiler": "^17.3.0",
+    "@angular/compiler-cli": "^17.3.0",
+    "@angular/core": "^17.3.0",
+    "@angular/router": "^17.3.0",
+    "ng-packagr": "^17.3.0",
+    "rxjs": "^7.8.1",
+    "typescript": "~5.4.5",
+    "zone.js": "^0.14.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "ng-packagr -p ng-package.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}