@vunexa/lixa 0.0.1-alpha.21 → 0.0.1-alpha.22

package/README.md

@@ -18,7 +18,8 @@ A flexible, provider-agnostic OAuth 2.0 and OpenID Connect (OIDC) client library
 - Custom provider registration with extensible provider interface
 - Extensible session management via pluggable strategies
 - PKCE (Proof Key for Code Exchange) support
-- TypeScript-first with strong typing and async/await support
+- TypeScript-first with full type safety (zero `any` types)
+- OAuth 2.0 and OpenID Connect spec-compliant types
 - 100% test coverage with comprehensive error handling
 
 ---
@@ -70,9 +71,10 @@ const lixa = new Lixa({
   // Optional: custom session strategy
   sessionStrategy: {
     createSession: async (tokenData) => {
-      // Custom session creation logic
+      // tokenData is typed as OAuthTokenResponse with proper OAuth 2.0 fields
+      // { access_token, token_type, expires_in?, refresh_token?, scope?, id_token? }
       return {
-        token: "custom-session-token",
+        token: tokenData.access_token,
         raw: tokenData,
       };
     },
@@ -251,11 +253,11 @@ const lixa = new Lixa({
 By default, Lixa uses an in-memory cache for state management. For production applications or serverless environments, you should implement a custom state storage:
 
 ```typescript
-import { Lixa } from "@vunexa/lixa";
+import { Lixa, StateDao, StateData } from "@vunexa/lixa";
 
-// Example: DynamoDB state storage
-const dynamoDbStateDao = {
-  saveState: async (state: string, data: any, expiresInSeconds: number) => {
+// Example: DynamoDB state storage with proper typing
+const dynamoDbStateDao: StateDao = {
+  saveState: async (state: string, data: StateData, expiresInSeconds: number) => {
     await dynamoDB.put({
       TableName: "oauth-states",
       Item: {
@@ -266,7 +268,7 @@ const dynamoDbStateDao = {
     });
   },
   
-  getState: async (state: string) => {
+  getState: async (state: string): Promise<StateData | null> => {
     const result = await dynamoDB.get({
       TableName: "oauth-states",
       Key: { state },
@@ -278,7 +280,7 @@ const dynamoDbStateDao = {
       return null; // Expired
     }
     
-    return JSON.parse(result.Item.data);
+    return JSON.parse(result.Item.data) as StateData;
   },
   
   deleteState: async (state: string) => {
@@ -295,15 +297,22 @@ const lixa = new Lixa({
 });
 ```
 
-**Important**: The state data includes a `codeVerifier` field required for PKCE. Make sure your storage preserves all fields in the data object.
+**Important**: The `StateData` type includes required fields:
+- `provider` (string): Provider name for callback routing
+- `codeVerifier` (string): PKCE code verifier (64 hex characters)
+- `createdAt` (number): Unix timestamp in milliseconds
+
+Make sure your storage preserves all fields in the data object.
 
 ### Custom Session Storage (SessionDao)
 
-Similar to state storage, you can implement custom session storage:
+Similar to state storage, you can implement custom session storage with proper typing:
 
 ```typescript
-const customSessionDao = {
-  saveSession: async (sessionId: string, session: any, expiresInSeconds: number) => {
+import { Lixa, SessionDao, Session } from "@vunexa/lixa";
+
+const customSessionDao: SessionDao = {
+  saveSession: async <T = unknown>(sessionId: string, session: T, expiresInSeconds: number) => {
     // Store session in your database
     await db.sessions.create({
       id: sessionId,
@@ -312,12 +321,12 @@ const customSessionDao = {
     });
   },
   
-  getSession: async (sessionId: string) => {
+  getSession: async <T = unknown>(sessionId: string): Promise<T | null> => {
     const session = await db.sessions.findById(sessionId);
     if (!session || session.expiresAt < Date.now()) {
       return null;
     }
-    return session.data;
+    return session.data as T;
   },
   
   deleteSession: async (sessionId: string) => {
@@ -333,12 +342,29 @@ const lixa = new Lixa({
 
 ### Custom Session Strategy
 
-The session strategy controls how user sessions are created from OAuth tokens:
+The session strategy controls how user sessions are created from OAuth tokens. The `tokenData` parameter is typed as `OAuthTokenResponse` with proper OAuth 2.0 fields:
 
 ```typescript
-const customSessionStrategy = {
-  createSession: async (tokenData) => {
-    // tokenData contains: access_token, refresh_token, id_token, etc.
+import { Lixa, SessionStrategy, OAuthTokenResponse, Session } from "@vunexa/lixa";
+
+// Define custom session data structure
+interface CustomSessionData extends OAuthTokenResponse {
+  userId: string;
+  userInfo: {
+    email: string;
+    name: string;
+  };
+}
+
+const customSessionStrategy: SessionStrategy = {
+  createSession: async (tokenData: OAuthTokenResponse): Promise<Session<CustomSessionData>> => {
+    // tokenData is properly typed with OAuth 2.0 fields:
+    // - access_token: string (required)
+    // - token_type: string (required)
+    // - expires_in?: number
+    // - refresh_token?: string
+    // - scope?: string
+    // - id_token?: string (for OIDC providers)
     
     // Decode ID token to get user info (for OIDC providers like Google)
     let userInfo;
@@ -493,21 +519,30 @@ saveState: async (state: string, data: any, expiresInSeconds: number) => {
 **Solution**: Decode the `id_token` (for OIDC providers) or fetch user info from the provider's API:
 
 ```typescript
-createSession: async (tokenData) => {
-  // For OIDC providers (Google, etc.)
-  if (tokenData.id_token) {
-    const base64Payload = tokenData.id_token.split('.')[1];
-    const userInfo = JSON.parse(Buffer.from(base64Payload, 'base64').toString());
-  }
-  
-  // For OAuth-only providers (GitHub, etc.)
-  else if (tokenData.access_token) {
-    const response = await fetch(providerUserInfoEndpoint, {
-      headers: { Authorization: `Bearer ${tokenData.access_token}` }
-    });
-    const userInfo = await response.json();
+import { SessionStrategy, OAuthTokenResponse } from "@vunexa/lixa";
+
+const strategy: SessionStrategy = {
+  createSession: async (tokenData: OAuthTokenResponse) => {
+    // For OIDC providers (Google, etc.) - id_token is properly typed
+    if (tokenData.id_token) {
+      const base64Payload = tokenData.id_token.split('.')[1];
+      const userInfo = JSON.parse(Buffer.from(base64Payload, 'base64').toString());
+    }
+    
+    // For OAuth-only providers (GitHub, etc.) - access_token is guaranteed to exist
+    else {
+      const response = await fetch(providerUserInfoEndpoint, {
+        headers: { Authorization: `Bearer ${tokenData.access_token}` }
+      });
+      const userInfo = await response.json();
+    }
+    
+    return {
+      token: tokenData.access_token,
+      raw: tokenData
+    };
   }
-}
+};
 ```
 
 ## API Reference
@@ -533,14 +568,27 @@ createSession: async (tokenData) => {
 
 ### Types
 
+All types are fully typed with zero `any` types, following OAuth 2.0 and OpenID Connect specifications:
+
 ```typescript
+// OAuth 2.0 token response (RFC 6749 Section 5.1)
+interface OAuthTokenResponse {
+  access_token: string;           // Required: OAuth access token
+  token_type: string;             // Required: Token type (usually "Bearer")
+  expires_in?: number;            // Optional: Token expiration in seconds
+  refresh_token?: string;         // Optional: Refresh token
+  scope?: string;                 // Optional: Granted scopes (space-separated)
+  id_token?: string;              // Optional: OpenID Connect ID token (JWT)
+  [key: string]: unknown;         // Additional provider-specific fields
+}
+
 // Provider configuration with inline provider support
 type ProviderConfig = {
   clientId: string;
   clientSecret: string;
   redirectUri: string;
   scopes: string[];
-  extraConfig?: Record<string, any>;
+  extraConfig?: Record<string, string>;
 } & (
   | { provider?: never }        // Built-in provider (no provider field)
   | { provider: IProvider }     // Custom provider (provider field required)
@@ -555,12 +603,12 @@ interface LixaConfig<TProviders = Record<string, ProviderConfig>> {
 }
 
 interface SessionStrategy {
-  createSession(tokenData: any): Promise<Session>;
+  createSession(tokenData: OAuthTokenResponse): Promise<Session>;
 }
 
-interface Session {
+interface Session<TRaw = OAuthTokenResponse> {
   token: string;
-  raw: any;
+  raw: TRaw;  // Defaults to OAuthTokenResponse, can be extended
 }
 
 interface StateData {
@@ -576,8 +624,8 @@ interface StateDao {
 }
 
 interface SessionDao {
-  saveSession(sessionId: string, session: any, expiresInSeconds: number): Promise<void>;
-  getSession(sessionId: string): Promise<any | null>;
+  saveSession<T = unknown>(sessionId: string, session: T, expiresInSeconds: number): Promise<void>;
+  getSession<T = unknown>(sessionId: string): Promise<T | null>;
   deleteSession(sessionId: string): Promise<void>;
 }
 
@@ -642,16 +690,26 @@ import { GithubProvider } from "@vunexa/lixa-providers";
 
 ### SessionStrategy Interface
 
-The `SessionStrategy` interface allows you to customize how OAuth tokens are converted into application sessions:
+The `SessionStrategy` interface allows you to customize how OAuth tokens are converted into application sessions. The `tokenData` parameter is fully typed as `OAuthTokenResponse`:
 
 ```typescript
 interface SessionStrategy {
-  createSession(tokenData: any): Promise<Session>;
+  createSession(tokenData: OAuthTokenResponse): Promise<Session>;
 }
 
-interface Session {
+interface Session<TRaw = OAuthTokenResponse> {
   token: string;  // Your session identifier
-  raw: any;       // Additional session data
+  raw: TRaw;      // Session data (defaults to OAuthTokenResponse)
+}
+
+interface OAuthTokenResponse {
+  access_token: string;    // Required
+  token_type: string;      // Required
+  expires_in?: number;     // Optional
+  refresh_token?: string;  // Optional
+  scope?: string;          // Optional
+  id_token?: string;       // Optional (OIDC)
+  [key: string]: unknown;  // Provider-specific fields
 }
 ```
 
@@ -662,17 +720,28 @@ interface Session {
 - Store tokens securely
 - Add custom claims or metadata
 
-**Example with database integration:**
+**Example with database integration and proper typing:**
 ```typescript
+import { SessionStrategy, OAuthTokenResponse, Session } from "@vunexa/lixa";
+
+interface CustomSessionData extends OAuthTokenResponse {
+  userId: string;
+}
+
 const dbSessionStrategy: SessionStrategy = {
-  createSession: async (tokenData) => {
+  createSession: async (tokenData: OAuthTokenResponse): Promise<Session<CustomSessionData>> => {
+    // tokenData is properly typed with OAuth 2.0 fields
+    // TypeScript will catch errors like tokenData.id_tokn (typo)
+    
     // Decode ID token (for OIDC providers)
-    const payload = decodeJwt(tokenData.id_token);
+    const payload = tokenData.id_token 
+      ? decodeJwt(tokenData.id_token)
+      : null;
     
     // Create/update user
     const user = await db.users.upsert({
-      email: payload.email,
-      name: payload.name
+      email: payload?.email,
+      name: payload?.name
     });
     
     // Generate session
@@ -681,12 +750,18 @@ const dbSessionStrategy: SessionStrategy = {
       id: sessionId,
       userId: user.id,
       accessToken: tokenData.access_token,
-      refreshToken: tokenData.refresh_token
+      refreshToken: tokenData.refresh_token,
+      expiresAt: tokenData.expires_in 
+        ? new Date(Date.now() + tokenData.expires_in * 1000)
+        : null
     });
     
     return {
       token: sessionId,
-      raw: { userId: user.id, ...tokenData }
+      raw: { 
+        ...tokenData,
+        userId: user.id 
+      }
     };
   }
 };
@@ -739,20 +814,22 @@ const redisStateDao: StateDao = {
 
 ### SessionDao Interface
 
-The `SessionDao` interface manages persistent user session storage:
+The `SessionDao` interface manages persistent user session storage with generic typing for flexibility:
 
 ```typescript
 interface SessionDao {
-  saveSession(sessionId: string, data: any, expiresInSeconds: number): Promise<void>;
-  getSession(sessionId: string): Promise<any | null>;
+  saveSession<T = unknown>(sessionId: string, data: T, expiresInSeconds: number): Promise<void>;
+  getSession<T = unknown>(sessionId: string): Promise<T | null>;
   deleteSession(sessionId: string): Promise<void>;
 }
 ```
 
-**Example with database:**
+**Example with database and proper typing:**
 ```typescript
+import { SessionDao, Session } from "@vunexa/lixa";
+
 const dbSessionDao: SessionDao = {
-  saveSession: async (sessionId, data, expiresInSeconds) => {
+  saveSession: async <T = unknown>(sessionId: string, data: T, expiresInSeconds: number) => {
     const expiresAt = new Date(Date.now() + expiresInSeconds * 1000);
     await db.sessions.create({
       id: sessionId,
@@ -761,15 +838,15 @@ const dbSessionDao: SessionDao = {
     });
   },
   
-  getSession: async (sessionId) => {
+  getSession: async <T = unknown>(sessionId: string): Promise<T | null> => {
     const session = await db.sessions.findOne({
       id: sessionId,
       expiresAt: { $gt: new Date() }
     });
-    return session ? JSON.parse(session.data) : null;
+    return session ? JSON.parse(session.data) as T : null;
   },
   
-  deleteSession: async (sessionId) => {
+  deleteSession: async (sessionId: string) => {
     await db.sessions.delete({ id: sessionId });
   }
 };

package/dist/dao/session-cache.d.ts

@@ -2,8 +2,8 @@ import { SessionDao } from "./types";
 declare class LocalSessionCache implements SessionDao {
     private cache;
     constructor(defaultTtlSeconds?: number);
-    saveSession(state: string, data: any, expiresInSeconds: number): Promise<void>;
-    getSession(state: string): Promise<any | null>;
+    saveSession<T = unknown>(state: string, data: T, expiresInSeconds: number): Promise<void>;
+    getSession<T = unknown>(state: string): Promise<T | null>;
     deleteSession(state: string): Promise<void>;
 }
 export { LocalSessionCache };

package/dist/dao/session-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-cache.d.ts","sourceRoot":"","sources":["../../src/dao/session-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,cAAM,iBAAkB,YAAW,UAAU;IAC3C,OAAO,CAAC,KAAK,CAAY;gBAEb,iBAAiB,GAAE,MAAY;IAIrC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9E,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;IAI9C,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGlD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"session-cache.d.ts","sourceRoot":"","sources":["../../src/dao/session-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,cAAM,iBAAkB,YAAW,UAAU;IAC3C,OAAO,CAAC,KAAK,CAAY;gBAEb,iBAAiB,GAAE,MAAY;IAIrC,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzF,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAIzD,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGlD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/dao/state-cache.d.ts

@@ -1,9 +1,9 @@
-import { StateDao } from "./types";
+import { StateDao, StateData } from "./types";
 declare class LocalStateCache implements StateDao {
     private cache;
     constructor(defaultTtlSeconds?: number);
-    saveState(state: string, data: any, expiresInSeconds: number): Promise<void>;
-    getState(state: string): Promise<any | null>;
+    saveState(state: string, data: StateData, expiresInSeconds: number): Promise<void>;
+    getState(state: string): Promise<StateData | null>;
     deleteState(state: string): Promise<void>;
 }
 export { LocalStateCache };

package/dist/dao/state-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-cache.d.ts","sourceRoot":"","sources":["../../src/dao/state-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,cAAM,eAAgB,YAAW,QAAQ;IACvC,OAAO,CAAC,KAAK,CAAY;gBAEb,iBAAiB,GAAE,MAAY;IAIrC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;IAI5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"state-cache.d.ts","sourceRoot":"","sources":["../../src/dao/state-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE9C,cAAM,eAAgB,YAAW,QAAQ;IACvC,OAAO,CAAC,KAAK,CAAY;gBAEb,iBAAiB,GAAE,MAAY;IAIrC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAIlD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/dao/types.d.ts

@@ -52,11 +52,11 @@ export interface StateData {
  * class RedisStateDao implements StateDao {
  *   constructor(private redis: RedisClient) {}
  *
- *   async saveState(state: string, data: any, expiresInSeconds: number): Promise<void> {
+ *   async saveState(state: string, data: StateData, expiresInSeconds: number): Promise<void> {
  *     await this.redis.setex(`oauth:state:${state}`, expiresInSeconds, JSON.stringify(data));
  *   }
  *
- *   async getState(state: string): Promise<any | null> {
+ *   async getState(state: string): Promise<StateData | null> {
  *     const data = await this.redis.get(`oauth:state:${state}`);
  *     return data ? JSON.parse(data) : null;
  *   }
@@ -159,6 +159,8 @@ export interface StateDao {
  * @example
  * Database implementation:
  * ```typescript
+ * import { Session } from '../models/session';
+ *
  * class DatabaseSessionDao implements SessionDao {
  *   constructor(private db: Database) {}
  *
@@ -198,17 +200,21 @@ export interface SessionDao {
      *
      * @remarks
      * The session data structure is defined by your SessionStrategy implementation.
-     * The default strategy returns \{ token: string, raw: any \}.
+     * The default strategy returns a Session object with token and raw OAuth token response.
      *
      * @example
      * ```typescript
      * await sessionDao.saveSession('session-123', \{
      *   token: 'access-token',
-     *   raw: \{ userId: '456', email: 'user\@example.com' \}
+     *   raw: \{
+     *     access_token: 'token',
+     *     token_type: 'Bearer',
+     *     expires_in: 3600
+     *   \}
      * \}, 86400);
      * ```
      */
-    saveSession(sessionId: string, data: any, expiresInSeconds: number): Promise<void>;
+    saveSession<T = unknown>(sessionId: string, data: T, expiresInSeconds: number): Promise<void>;
     /**
      * Retrieves a session by ID.
      *
@@ -217,6 +223,7 @@ export interface SessionDao {
      *
      * @remarks
      * This method is called to retrieve user session data for authenticated requests.
+     * The returned data should match the structure saved by saveSession.
      *
      * @example
      * ```typescript
@@ -226,7 +233,7 @@ export interface SessionDao {
      * }
      * ```
      */
-    getSession(sessionId: string): Promise<any | null>;
+    getSession<T = unknown>(sessionId: string): Promise<T | null>;
     /**
      * Deletes a session (e.g., on logout).
      *

package/dist/dao/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dao/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnF;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dao/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9F;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAE9D;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD"}