@hamak/auth 0.5.1

package/README.md

@@ -0,0 +1,366 @@
+# @hamak/auth
+
+A complete authentication system for the Hamak App Framework, supporting password-based login, OAuth2, and Keycloak authentication.
+
+## Features
+
+- 🔐 **Multiple Authentication Strategies** - Password, OAuth2, Keycloak
+- 🔄 **Automatic Token Refresh** - Proactive refresh before expiry
+- 💾 **Flexible Token Storage** - localStorage, sessionStorage, or memory
+- 🛡️ **PKCE Support** - Secure OAuth2 for public clients
+- ⚛️ **React Integration** - Providers, hooks, and guard components
+- 🏪 **Redux Integration** - Auth state in your store
+- 🔌 **Plugin Architecture** - Integrates with microkernel plugin system
+
+## Packages
+
+| Package | Description |
+|---------|-------------|
+| `@hamak/auth-api` | Interfaces, types, and DI tokens |
+| `@hamak/auth-spi` | Extension points for custom strategies |
+| `@hamak/auth-impl` | Core implementations and plugin factory |
+| `@hamak/auth-templates` | React providers, hooks, and components |
+
+## Installation
+
+```bash
+npm install @hamak/auth-api @hamak/auth-spi @hamak/auth-impl @hamak/auth-templates
+```
+
+## Quick Start
+
+### 1. Configure the Auth Plugin
+
+```typescript
+import { createAuthPlugin } from '@hamak/auth-impl';
+
+// Password-based authentication
+const authPlugin = createAuthPlugin({
+  strategy: 'password',
+  password: {
+    loginEndpoint: '/api/auth/login',
+    refreshEndpoint: '/api/auth/refresh',
+    logoutEndpoint: '/api/auth/logout',
+    userInfoEndpoint: '/api/auth/me'
+  },
+  tokenStorage: 'localStorage',
+  autoRefresh: {
+    enabled: true,
+    threshold: 60000 // Refresh 1 min before expiry
+  }
+});
+
+// Or OAuth2
+const oauthPlugin = createAuthPlugin({
+  strategy: 'oauth2',
+  oauth2: {
+    clientId: 'my-app',
+    authorizationUrl: 'https://auth.example.com/authorize',
+    tokenUrl: 'https://auth.example.com/token',
+    userInfoUrl: 'https://auth.example.com/userinfo',
+    redirectUri: 'http://localhost:3000/callback',
+    scope: ['openid', 'profile', 'email']
+  }
+});
+
+// Or Keycloak
+const keycloakPlugin = createAuthPlugin({
+  strategy: 'keycloak',
+  keycloak: {
+    realm: 'my-realm',
+    serverUrl: 'https://keycloak.example.com',
+    clientId: 'my-app',
+    redirectUri: 'http://localhost:3000/callback',
+    enableDirectGrant: true // Allow password login
+  }
+});
+```
+
+### 2. Register the Plugin
+
+```typescript
+import { Host } from '@hamak/microkernel-impl';
+
+const host = new Host();
+host.registerPlugin('auth', manifest, authPlugin);
+await host.bootstrapAllAtRoot();
+```
+
+### 3. Setup React Provider
+
+```tsx
+import { AuthProvider } from '@hamak/auth-templates';
+import { AUTH_SERVICE_TOKEN } from '@hamak/auth-api';
+
+function App() {
+  const [authService, setAuthService] = useState(null);
+
+  useEffect(() => {
+    host.bootstrapAllAtRoot().then(() => {
+      const ctx = host.rootActivationCtx;
+      setAuthService(ctx.resolve(AUTH_SERVICE_TOKEN));
+    });
+  }, []);
+
+  if (!authService) return <Loading />;
+
+  return (
+    <AuthProvider authService={authService}>
+      <YourApp />
+    </AuthProvider>
+  );
+}
+```
+
+### 4. Use Auth in Components
+
+```tsx
+import { useAuth, useLogin, useLogout, RequireAuth, RequireRole } from '@hamak/auth-templates';
+
+// Login form
+function LoginPage() {
+  const { loginWithPassword, loading, error } = useLogin();
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    const result = await loginWithPassword(username, password);
+    if (result.success) {
+      navigate('/dashboard');
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      {error && <Alert>{error.message}</Alert>}
+      <input name="username" />
+      <input name="password" type="password" />
+      <button disabled={loading}>Login</button>
+    </form>
+  );
+}
+
+// Protected content
+function Dashboard() {
+  const { user } = useAuth();
+  const { logout } = useLogout();
+
+  return (
+    <RequireAuth fallback={<Loading />}>
+      <h1>Welcome, {user?.name}</h1>
+
+      <RequireRole role="admin">
+        <AdminPanel />
+      </RequireRole>
+
+      <button onClick={logout}>Logout</button>
+    </RequireAuth>
+  );
+}
+```
+
+## Available Hooks
+
+| Hook | Description |
+|------|-------------|
+| `useAuth()` | Full auth context with state and operations |
+| `useAuthState()` | Auth state only (isAuthenticated, user, loading) |
+| `useUser()` | Current user or null |
+| `useLogin()` | Login operations with loading/error state |
+| `useLogout()` | Logout operation with loading state |
+| `useRoles()` | Role checking utilities |
+| `usePermissions()` | Permission checking utilities |
+| `useOAuthCallback()` | Handle OAuth redirect callbacks |
+
+## Guard Components
+
+```tsx
+// Require authentication
+<RequireAuth fallback={<Loading />}>
+  <ProtectedContent />
+</RequireAuth>
+
+// Require specific role
+<RequireRole role="admin" unauthorizedContent={<AccessDenied />}>
+  <AdminPanel />
+</RequireRole>
+
+// Require any of multiple roles
+<RequireRole roles={['admin', 'moderator']}>
+  <ModeratorTools />
+</RequireRole>
+
+// Require permission
+<RequirePermission permission="document:write">
+  <EditButton />
+</RequirePermission>
+```
+
+## Higher-Order Components
+
+```tsx
+import { withAuth, withRole, withPermission } from '@hamak/auth-templates';
+
+// Protect a component
+const ProtectedDashboard = withAuth(Dashboard, {
+  fallback: <Loading />,
+  onUnauthenticated: () => navigate('/login')
+});
+
+// Require role
+const AdminPanel = withRole(Panel, {
+  role: 'admin',
+  unauthorizedComponent: AccessDenied
+});
+```
+
+## Plugin Commands
+
+The auth plugin registers these commands:
+
+```typescript
+ctx.commands.run('auth.login', credentials);
+ctx.commands.run('auth.logout');
+ctx.commands.run('auth.refresh');
+ctx.commands.run('auth.isAuthenticated');
+ctx.commands.run('auth.getCurrentUser');
+ctx.commands.run('auth.hasRole', 'admin');
+ctx.commands.run('auth.hasPermission', 'document:write');
+ctx.commands.run('auth.initiateOAuth', 'keycloak');
+```
+
+## Plugin Events
+
+Subscribe to auth events via hooks:
+
+```typescript
+ctx.hooks.on('auth:login-success', ({ user }) => {
+  console.log('User logged in:', user);
+});
+
+ctx.hooks.on('auth:logout', () => {
+  console.log('User logged out');
+});
+
+ctx.hooks.on('auth:session-expired', () => {
+  console.log('Session expired');
+});
+
+ctx.hooks.on('auth:token-refresh', ({ user }) => {
+  console.log('Token refreshed');
+});
+```
+
+## Configuration Options
+
+```typescript
+interface AuthPluginConfig {
+  // Primary strategy
+  strategy: 'password' | 'oauth2' | 'keycloak';
+
+  // Password strategy config
+  password?: {
+    loginEndpoint: string;
+    refreshEndpoint: string;
+    logoutEndpoint: string;
+    userInfoEndpoint?: string;
+  };
+
+  // OAuth2 config
+  oauth2?: {
+    clientId: string;
+    authorizationUrl: string;
+    tokenUrl: string;
+    userInfoUrl?: string;
+    redirectUri: string;
+    scope: string[];
+    usePkce?: boolean; // default: true
+  };
+
+  // Keycloak config
+  keycloak?: {
+    realm: string;
+    serverUrl: string;
+    clientId: string;
+    redirectUri: string;
+    scope?: string[];
+    enableDirectGrant?: boolean;
+  };
+
+  // Storage
+  tokenStorage?: 'localStorage' | 'sessionStorage' | 'memory';
+  storageKeyPrefix?: string;
+
+  // Auto refresh
+  autoRefresh?: {
+    enabled: boolean;
+    threshold?: number; // ms before expiry
+    checkInterval?: number; // ms between checks
+  };
+
+  // Routes
+  routes?: {
+    afterLogin?: string;
+    afterLogout?: string;
+    login?: string;
+    unauthorized?: string;
+  };
+
+  debug?: boolean;
+}
+```
+
+## Custom Strategy
+
+Implement your own authentication strategy:
+
+```typescript
+import type { IAuthStrategy } from '@hamak/auth-spi';
+
+class CustomStrategy implements IAuthStrategy {
+  readonly type = 'custom';
+  readonly name = 'my-custom-auth';
+
+  async authenticate(credentials) {
+    // Your authentication logic
+    return { success: true, user, accessToken, refreshToken };
+  }
+
+  async refreshToken(refreshToken) {
+    // Your refresh logic
+    return { success: true, accessToken };
+  }
+
+  async logout(accessToken) {
+    // Your logout logic
+  }
+}
+```
+
+## Security Considerations
+
+- **PKCE**: Enabled by default for OAuth2 flows
+- **State Parameter**: CSRF protection for OAuth callbacks
+- **Token Storage**: Use `memory` for highest security (tokens lost on refresh)
+- **Auto Refresh**: Prevents session expiry during active use
+- **JWT Validation**: Server-side validation required; client-side is for UX only
+
+## Demo
+
+Run the demo app to see auth in action:
+
+```bash
+npm run demo:dev
+```
+
+Navigate to the **Auth Demo** tab to test:
+- Login with `demo`/`demo123` (user + editor roles)
+- Login with `admin`/`admin123` (all roles)
+- Login with `guest`/`guest123` (guest role only)
+
+## API Reference
+
+See [DESIGN.md](./DESIGN.md) for detailed architecture documentation.
+
+## License
+
+MIT

package/dist/api/api/auth-service.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Auth Service Interface
+ * Core authentication service contract
+ */
+import type { User } from '../types/user';
+import type { LoginCredentials, OAuthCallbackParams } from '../types/credentials';
+import type { AuthResult, AuthStateCallback } from '../types/auth-result';
+/**
+ * Main authentication service interface
+ *
+ * Provides a unified API for all authentication operations regardless
+ * of the underlying strategy (password, OAuth2, Keycloak, etc.)
+ */
+export interface IAuthService {
+    /**
+     * Check if the user is currently authenticated
+     * @returns true if authenticated with a valid token
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get the currently authenticated user
+     * @returns The user object or null if not authenticated
+     */
+    getCurrentUser(): User | null;
+    /**
+     * Get the current access token
+     * @returns The access token or null if not authenticated
+     */
+    getAccessToken(): string | null;
+    /**
+     * Get the user's permissions
+     * @returns Array of permission strings
+     */
+    getPermissions(): string[];
+    /**
+     * Get the user's roles
+     * @returns Array of role strings
+     */
+    getRoles(): string[];
+    /**
+     * Check if the user has a specific permission
+     * @param permission The permission to check
+     */
+    hasPermission(permission: string): boolean;
+    /**
+     * Check if the user has a specific role
+     * @param role The role to check
+     */
+    hasRole(role: string): boolean;
+    /**
+     * Check if the user has any of the specified roles
+     * @param roles The roles to check
+     */
+    hasAnyRole(roles: string[]): boolean;
+    /**
+     * Check if the user has all of the specified roles
+     * @param roles The roles to check
+     */
+    hasAllRoles(roles: string[]): boolean;
+    /**
+     * Authenticate with credentials
+     * @param credentials The login credentials
+     * @returns Authentication result
+     */
+    login(credentials: LoginCredentials): Promise<AuthResult>;
+    /**
+     * Log out the current user
+     * Clears tokens and session data
+     */
+    logout(): Promise<void>;
+    /**
+     * Refresh the current access token
+     * @returns New authentication result with fresh tokens
+     */
+    refreshToken(): Promise<AuthResult>;
+    /**
+     * Initiate OAuth login flow
+     * Redirects the user to the OAuth provider's authorization page
+     * @param provider Optional provider name for multi-provider setups
+     */
+    initiateOAuth(provider?: string): void;
+    /**
+     * Handle OAuth callback after authorization
+     * @param params The callback parameters from the OAuth provider
+     * @returns Authentication result
+     */
+    handleOAuthCallback(params: OAuthCallbackParams): Promise<AuthResult>;
+    /**
+     * Get the OAuth authorization URL without redirecting
+     * @param provider Optional provider name
+     * @returns The authorization URL
+     */
+    getAuthorizationUrl(provider?: string): string | null;
+    /**
+     * Subscribe to authentication state changes
+     * @param callback Function called when auth state changes
+     * @returns Unsubscribe function
+     */
+    onAuthStateChange(callback: AuthStateCallback): () => void;
+    /**
+     * Initialize the auth service
+     * Restores session from storage if available
+     */
+    initialize(): Promise<void>;
+    /**
+     * Destroy the auth service
+     * Cleans up resources and event listeners
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=auth-service.d.ts.map

package/dist/api/api/auth-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-service.d.ts","sourceRoot":"","sources":["../../../src/api/api/auth-service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAK3B;;;OAGG;IACH,eAAe,IAAI,OAAO,CAAC;IAE3B;;;OAGG;IACH,cAAc,IAAI,IAAI,GAAG,IAAI,CAAC;IAE9B;;;OAGG;IACH,cAAc,IAAI,MAAM,GAAG,IAAI,CAAC;IAEhC;;;OAGG;IACH,cAAc,IAAI,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,QAAQ,IAAI,MAAM,EAAE,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3C;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE/B;;;OAGG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAErC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAMtC;;;;OAIG;IACH,KAAK,CAAC,WAAW,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAE1D;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;OAGG;IACH,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAMpC;;;;OAIG;IACH,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEtE;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAMtD;;;;OAIG;IACH,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAAC;IAM3D;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/api/api/auth-service.js

@@ -0,0 +1,5 @@
+/**
+ * Auth Service Interface
+ * Core authentication service contract
+ */
+export {};

package/dist/api/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth-service';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/api/api/index.js

@@ -0,0 +1 @@
+export * from './auth-service';

package/dist/api/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @hamak/auth/api
+ *
+ * Pure interfaces and types for the pluggable authentication system.
+ * This layer contains no implementation - only contracts.
+ */
+export * from './tokens';
+export * from './types';
+export * from './api';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,UAAU,CAAC;AAGzB,cAAc,SAAS,CAAC;AAGxB,cAAc,OAAO,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,12 @@
+/**
+ * @hamak/auth/api
+ *
+ * Pure interfaces and types for the pluggable authentication system.
+ * This layer contains no implementation - only contracts.
+ */
+// Service tokens
+export * from './tokens';
+// Type definitions
+export * from './types';
+// API interfaces
+export * from './api';

package/dist/api/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from './service-tokens';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/api/tokens/index.js

@@ -0,0 +1 @@
+export * from './service-tokens';

package/dist/api/tokens/service-tokens.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Auth Service Tokens
+ * Symbol-based tokens for dependency injection
+ * Using Symbol.for() for global registry to ensure consistency across packages
+ */
+/**
+ * Token for the main authentication service
+ */
+export declare const AUTH_SERVICE_TOKEN: unique symbol;
+/**
+ * Token for the authentication strategy registry
+ */
+export declare const AUTH_STRATEGY_REGISTRY_TOKEN: unique symbol;
+/**
+ * Token for the token storage service
+ */
+export declare const TOKEN_STORAGE_TOKEN: unique symbol;
+/**
+ * Token for the auth configuration
+ */
+export declare const AUTH_CONFIG_TOKEN: unique symbol;
+/**
+ * Token for the auth state selector
+ */
+export declare const AUTH_STATE_TOKEN: unique symbol;
+//# sourceMappingURL=service-tokens.d.ts.map

package/dist/api/tokens/service-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/service-tokens.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,eAAwC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,4BAA4B,eAA6C,CAAC;AAEvF;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAAyC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAmC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,eAAkC,CAAC"}

package/dist/api/tokens/service-tokens.js

@@ -0,0 +1,25 @@
+/**
+ * Auth Service Tokens
+ * Symbol-based tokens for dependency injection
+ * Using Symbol.for() for global registry to ensure consistency across packages
+ */
+/**
+ * Token for the main authentication service
+ */
+export const AUTH_SERVICE_TOKEN = Symbol.for('@hamak/auth:AuthService');
+/**
+ * Token for the authentication strategy registry
+ */
+export const AUTH_STRATEGY_REGISTRY_TOKEN = Symbol.for('@hamak/auth:StrategyRegistry');
+/**
+ * Token for the token storage service
+ */
+export const TOKEN_STORAGE_TOKEN = Symbol.for('@hamak/auth:TokenStorage');
+/**
+ * Token for the auth configuration
+ */
+export const AUTH_CONFIG_TOKEN = Symbol.for('@hamak/auth:Config');
+/**
+ * Token for the auth state selector
+ */
+export const AUTH_STATE_TOKEN = Symbol.for('@hamak/auth:State');

package/dist/api/types/auth-result.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Auth Result Types
+ * Types for authentication operation results
+ */
+import type { User } from './user';
+/**
+ * Error codes for authentication failures
+ */
+export type AuthErrorCode = 'invalid_credentials' | 'invalid_token' | 'token_expired' | 'refresh_failed' | 'no_refresh_token' | 'invalid_state' | 'network_error' | 'server_error' | 'unauthorized' | 'forbidden' | 'user_not_found' | 'account_locked' | 'account_disabled' | 'mfa_required' | 'unknown_error';
+/**
+ * Authentication error details
+ */
+export interface AuthError {
+    /** Error code for programmatic handling */
+    code: AuthErrorCode;
+    /** Human-readable error message */
+    message?: string;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Token information
+ */
+export interface TokenInfo {
+    /** The access token */
+    accessToken: string;
+    /** The refresh token (if provided) */
+    refreshToken?: string;
+    /** Token type (usually 'Bearer') */
+    tokenType?: string;
+    /** When the access token expires (timestamp in ms) */
+    expiresAt?: number;
+    /** Token scopes */
+    scope?: string[];
+}
+/**
+ * Result of an authentication operation
+ */
+export interface AuthResult {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** The authenticated user (on success) */
+    user?: User;
+    /** Access token (on success) */
+    accessToken?: string;
+    /** Refresh token (on success) */
+    refreshToken?: string;
+    /** Token type */
+    tokenType?: string;
+    /** When the access token expires (timestamp in ms) */
+    expiresAt?: number;
+    /** Token scopes */
+    scope?: string[];
+    /** Error details (on failure) */
+    error?: AuthError;
+    /** Whether MFA is required to complete login */
+    mfaRequired?: boolean;
+    /** MFA challenge token if MFA is required */
+    mfaToken?: string;
+}
+/**
+ * Auth state change event types
+ */
+export type AuthStateChangeType = 'login' | 'logout' | 'token_refresh' | 'session_expired' | 'user_updated';
+/**
+ * Callback for auth state changes
+ */
+export type AuthStateCallback = (isAuthenticated: boolean, user: User | null, changeType?: AuthStateChangeType) => void;
+//# sourceMappingURL=auth-result.d.ts.map

package/dist/api/types/auth-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-result.d.ts","sourceRoot":"","sources":["../../../src/api/types/auth-result.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,qBAAqB,GACrB,eAAe,GACf,eAAe,GACf,gBAAgB,GAChB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,cAAc,GACd,cAAc,GACd,WAAW,GACX,gBAAgB,GAChB,gBAAgB,GAChB,kBAAkB,GAClB,cAAc,GACd,eAAe,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,IAAI,EAAE,aAAa,CAAC;IACpB,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,uBAAuB;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,sCAAsC;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,gCAAgC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iCAAiC;IACjC,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B,OAAO,GACP,QAAQ,GACR,eAAe,GACf,iBAAiB,GACjB,cAAc,CAAC;AAEnB;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,eAAe,EAAE,OAAO,EACxB,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,UAAU,CAAC,EAAE,mBAAmB,KAC7B,IAAI,CAAC"}

package/dist/api/types/auth-result.js

@@ -0,0 +1,5 @@
+/**
+ * Auth Result Types
+ * Types for authentication operation results
+ */
+export {};