@uploadista/server 0.0.3

package/dist/auth/cache.js

@@ -0,0 +1,121 @@
+import { Context, Effect, Layer } from "effect";
+/**
+ * Auth Cache Service
+ *
+ * Provides caching of authentication contexts for upload and flow jobs.
+ * This allows subsequent operations (chunk uploads, flow continuations)
+ * to reuse the auth context from the initial request without re-authenticating.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AuthCacheService } from "@uploadista/server";
+ *
+ * const handler = Effect.gen(function* () {
+ *   const authCache = yield* AuthCacheService;
+ *   const authContext = { userId: "user-123" };
+ *
+ *   // Cache auth for upload
+ *   yield* authCache.set("upload-abc", authContext);
+ *
+ *   // Retrieve cached auth later
+ *   const cached = yield* authCache.get("upload-abc");
+ *   console.log(cached?.userId); // "user-123"
+ *
+ *   // Clear when done
+ *   yield* authCache.delete("upload-abc");
+ * });
+ * ```
+ */
+export class AuthCacheService extends Context.Tag("AuthCacheService")() {
+}
+/**
+ * Creates an AuthCacheService Layer with in-memory storage.
+ *
+ * @param config - Optional configuration for cache behavior
+ * @returns Effect Layer providing AuthCacheService
+ */
+export const AuthCacheServiceLive = (config = {}) => {
+    const maxSize = config.maxSize ?? 10000;
+    const ttl = config.ttl ?? 3600000; // 1 hour default
+    // In-memory cache storage
+    const cache = new Map();
+    /**
+     * Evict expired entries based on TTL.
+     */
+    const evictExpired = () => {
+        const now = Date.now();
+        for (const [jobId, entry] of cache.entries()) {
+            if (now - entry.timestamp > ttl) {
+                cache.delete(jobId);
+            }
+        }
+    };
+    /**
+     * Enforce max size limit using LRU eviction.
+     * Removes oldest entry when cache exceeds max size.
+     */
+    const enforceSizeLimit = () => {
+        if (cache.size <= maxSize)
+            return;
+        // Find and remove oldest entry
+        let oldestKey = null;
+        let oldestTime = Number.POSITIVE_INFINITY;
+        for (const [jobId, entry] of cache.entries()) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = jobId;
+            }
+        }
+        if (oldestKey) {
+            cache.delete(oldestKey);
+        }
+    };
+    return Layer.succeed(AuthCacheService, {
+        set: (jobId, authContext) => Effect.sync(() => {
+            // Evict expired entries periodically
+            if (cache.size % 100 === 0) {
+                evictExpired();
+            }
+            cache.set(jobId, {
+                authContext,
+                timestamp: Date.now(),
+            });
+            // Enforce size limit after adding
+            enforceSizeLimit();
+        }),
+        get: (jobId) => Effect.sync(() => {
+            const entry = cache.get(jobId);
+            if (!entry)
+                return null;
+            // Check if expired
+            const now = Date.now();
+            if (now - entry.timestamp > ttl) {
+                cache.delete(jobId);
+                return null;
+            }
+            return entry.authContext;
+        }),
+        delete: (jobId) => Effect.sync(() => {
+            cache.delete(jobId);
+        }),
+        clear: () => Effect.sync(() => {
+            cache.clear();
+        }),
+        size: () => Effect.sync(() => {
+            return cache.size;
+        }),
+    });
+};
+/**
+ * No-op implementation of AuthCacheService.
+ * Does not cache anything - all operations are no-ops.
+ * Used when caching is disabled or not needed.
+ */
+export const NoAuthCacheServiceLive = Layer.succeed(AuthCacheService, {
+    set: () => Effect.void,
+    get: () => Effect.succeed(null),
+    delete: () => Effect.void,
+    clear: () => Effect.void,
+    size: () => Effect.succeed(0),
+});

package/dist/auth/cache.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache.test.d.ts.map

package/dist/auth/cache.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.test.d.ts","sourceRoot":"","sources":["../../src/auth/cache.test.ts"],"names":[],"mappings":""}

package/dist/auth/cache.test.js

@@ -0,0 +1,209 @@
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+import { AuthCacheService, AuthCacheServiceLive, NoAuthCacheServiceLive, } from "./cache";
+describe("AuthCacheService", () => {
+    describe("AuthCacheServiceLive", () => {
+        it("should set and get auth context", async () => {
+            const authContext = {
+                clientId: "user-123",
+                metadata: { role: "admin" },
+            };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Set auth context
+                yield* cache.set("job-1", authContext);
+                // Get auth context
+                const retrieved = yield* cache.get("job-1");
+                expect(retrieved).toEqual(authContext);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should return null for non-existent job ID", async () => {
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                const retrieved = yield* cache.get("non-existent");
+                expect(retrieved).toBeNull();
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should delete cached auth context", async () => {
+            const authContext = {
+                clientId: "user-123",
+            };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Set and verify
+                yield* cache.set("job-1", authContext);
+                const before = yield* cache.get("job-1");
+                expect(before).toEqual(authContext);
+                // Delete
+                yield* cache.delete("job-1");
+                // Verify deleted
+                const after = yield* cache.get("job-1");
+                expect(after).toBeNull();
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should clear all cached auth contexts", async () => {
+            const authContext1 = { clientId: "user-1" };
+            const authContext2 = { clientId: "user-2" };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Set multiple entries
+                yield* cache.set("job-1", authContext1);
+                yield* cache.set("job-2", authContext2);
+                const sizeBefore = yield* cache.size();
+                expect(sizeBefore).toBe(2);
+                // Clear all
+                yield* cache.clear();
+                const sizeAfter = yield* cache.size();
+                expect(sizeAfter).toBe(0);
+                // Verify both deleted
+                const job1 = yield* cache.get("job-1");
+                const job2 = yield* cache.get("job-2");
+                expect(job1).toBeNull();
+                expect(job2).toBeNull();
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should track cache size", async () => {
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                let size = yield* cache.size();
+                expect(size).toBe(0);
+                yield* cache.set("job-1", { clientId: "user-1" });
+                size = yield* cache.size();
+                expect(size).toBe(1);
+                yield* cache.set("job-2", { clientId: "user-2" });
+                size = yield* cache.size();
+                expect(size).toBe(2);
+                yield* cache.delete("job-1");
+                size = yield* cache.size();
+                expect(size).toBe(1);
+                yield* cache.clear();
+                size = yield* cache.size();
+                expect(size).toBe(0);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should evict expired entries", async () => {
+            // Set very short TTL for testing
+            const shortTtl = 50; // 50ms
+            const authContext = {
+                clientId: "user-123",
+            };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Set auth context
+                yield* cache.set("job-1", authContext);
+                // Verify it's there immediately
+                const immediate = yield* cache.get("job-1");
+                expect(immediate).toEqual(authContext);
+                // Wait for TTL to expire
+                yield* Effect.sleep(100); // Wait 100ms (longer than 50ms TTL)
+                // Should be evicted now
+                const afterExpiry = yield* cache.get("job-1");
+                expect(afterExpiry).toBeNull();
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive({ ttl: shortTtl }))));
+        });
+        it("should enforce max size limit with LRU eviction", async () => {
+            const maxSize = 3;
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Add entries up to max size
+                yield* cache.set("job-1", { clientId: "user-1" });
+                yield* Effect.sleep(10); // Small delay to ensure ordering
+                yield* cache.set("job-2", { clientId: "user-2" });
+                yield* Effect.sleep(10);
+                yield* cache.set("job-3", { clientId: "user-3" });
+                let size = yield* cache.size();
+                expect(size).toBe(3);
+                // Add one more - should evict oldest (job-1)
+                yield* Effect.sleep(10);
+                yield* cache.set("job-4", { clientId: "user-4" });
+                size = yield* cache.size();
+                expect(size).toBe(3); // Still at max size
+                // job-1 should be evicted (oldest)
+                const job1 = yield* cache.get("job-1");
+                expect(job1).toBeNull();
+                // Others should still exist
+                const job2 = yield* cache.get("job-2");
+                const job3 = yield* cache.get("job-3");
+                const job4 = yield* cache.get("job-4");
+                expect(job2).toEqual({ clientId: "user-2" });
+                expect(job3).toEqual({ clientId: "user-3" });
+                expect(job4).toEqual({ clientId: "user-4" });
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive({ maxSize }))));
+        });
+        it("should handle multiple auth contexts independently", async () => {
+            const authContext1 = {
+                clientId: "user-1",
+                metadata: { role: "admin" },
+            };
+            const authContext2 = {
+                clientId: "user-2",
+                permissions: ["read", "write"],
+            };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                yield* cache.set("upload-123", authContext1);
+                yield* cache.set("flow-456", authContext2);
+                const upload = yield* cache.get("upload-123");
+                const flow = yield* cache.get("flow-456");
+                expect(upload).toEqual(authContext1);
+                expect(flow).toEqual(authContext2);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+        it("should update existing entry when setting same job ID", async () => {
+            const authContext1 = { clientId: "user-1" };
+            const authContext2 = { clientId: "user-2" };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                yield* cache.set("job-1", authContext1);
+                const first = yield* cache.get("job-1");
+                expect(first).toEqual(authContext1);
+                // Update with new auth context
+                yield* cache.set("job-1", authContext2);
+                const second = yield* cache.get("job-1");
+                expect(second).toEqual(authContext2);
+                // Should still be only 1 entry
+                const size = yield* cache.size();
+                expect(size).toBe(1);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(AuthCacheServiceLive())));
+        });
+    });
+    describe("NoAuthCacheServiceLive", () => {
+        it("should not cache anything", async () => {
+            const authContext = {
+                clientId: "user-123",
+            };
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // Try to set
+                yield* cache.set("job-1", authContext);
+                // Should always return null
+                const retrieved = yield* cache.get("job-1");
+                expect(retrieved).toBeNull();
+                // Size should always be 0
+                const size = yield* cache.size();
+                expect(size).toBe(0);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(NoAuthCacheServiceLive)));
+        });
+        it("should handle delete and clear without errors", async () => {
+            const program = Effect.gen(function* () {
+                const cache = yield* AuthCacheService;
+                // These should not throw
+                yield* cache.delete("non-existent");
+                yield* cache.clear();
+                const size = yield* cache.size();
+                expect(size).toBe(0);
+            });
+            await Effect.runPromise(program.pipe(Effect.provide(NoAuthCacheServiceLive)));
+        });
+    });
+});

package/dist/auth/get-auth-credentials.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Response type for authentication credential requests.
+ * - `isValid: true` with token and expiration
+ * - `isValid: false` with error message
+ *
+ * @example
+ * ```typescript
+ * const response = await getAuthCredentials({
+ *   uploadistaClientId: "my-client",
+ *   uploadistaApiKey: "sk_..."
+ * });
+ * if (response.isValid) {
+ *   console.log(`Token: ${response.data.token}`);
+ * } else {
+ *   console.error(`Auth failed: ${response.error}`);
+ * }
+ * ```
+ */
+export type AuthCredentialsResponse = {
+    isValid: true;
+    data: {
+        token: string;
+        expiresIn: number;
+    };
+} | {
+    isValid: false;
+    error: string;
+};
+/**
+ * Retrieve JWT authentication credentials from the Uploadista server.
+ * This function exchanges client credentials (ID + API key) for a signed JWT token.
+ *
+ * The JWT token is then used in subsequent API requests via the Authorization header.
+ * Tokens are time-limited and should be refreshed before expiration.
+ *
+ * @param params - Credential exchange parameters
+ * @param params.uploadistaClientId - Your Uploadista client ID
+ * @param params.uploadistaApiKey - Your Uploadista API key (secret)
+ * @param params.baseUrl - Uploadista server base URL (default: https://api.uploadista.com)
+ * @returns Promise resolving to authentication response with token or error
+ *
+ * @example
+ * ```typescript
+ * import { getAuthCredentials } from "@uploadista/server";
+ *
+ * // Get JWT token for API requests
+ * const response = await getAuthCredentials({
+ *   uploadistaClientId: process.env.UPLOADISTA_CLIENT_ID,
+ *   uploadistaApiKey: process.env.UPLOADISTA_API_KEY,
+ * });
+ *
+ * if (response.isValid) {
+ *   // Use token in API requests
+ *   const headers = {
+ *     Authorization: `Bearer ${response.data.token}`,
+ *   };
+ *
+ *   // Token expires in response.data.expiresIn seconds
+ *   setTimeout(
+ *     () => {
+ *       // Refresh token before expiration
+ *     },
+ *     response.data.expiresIn * 1000,
+ *   );
+ * }
+ * ```
+ */
+export declare const getAuthCredentials: ({ uploadistaClientId, uploadistaApiKey, baseUrl, }: {
+    uploadistaClientId: string;
+    uploadistaApiKey: string;
+    baseUrl?: string;
+}) => Promise<AuthCredentialsResponse>;
+//# sourceMappingURL=get-auth-credentials.d.ts.map

package/dist/auth/get-auth-credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-auth-credentials.d.ts","sourceRoot":"","sources":["../../src/auth/get-auth-credentials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,uBAAuB,GAC/B;IACE,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5C,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,kBAAkB,GAAU,oDAItC;IACD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,KAAG,OAAO,CAAC,uBAAuB,CAqBlC,CAAC"}

package/dist/auth/get-auth-credentials.js

@@ -0,0 +1,55 @@
+/**
+ * Retrieve JWT authentication credentials from the Uploadista server.
+ * This function exchanges client credentials (ID + API key) for a signed JWT token.
+ *
+ * The JWT token is then used in subsequent API requests via the Authorization header.
+ * Tokens are time-limited and should be refreshed before expiration.
+ *
+ * @param params - Credential exchange parameters
+ * @param params.uploadistaClientId - Your Uploadista client ID
+ * @param params.uploadistaApiKey - Your Uploadista API key (secret)
+ * @param params.baseUrl - Uploadista server base URL (default: https://api.uploadista.com)
+ * @returns Promise resolving to authentication response with token or error
+ *
+ * @example
+ * ```typescript
+ * import { getAuthCredentials } from "@uploadista/server";
+ *
+ * // Get JWT token for API requests
+ * const response = await getAuthCredentials({
+ *   uploadistaClientId: process.env.UPLOADISTA_CLIENT_ID,
+ *   uploadistaApiKey: process.env.UPLOADISTA_API_KEY,
+ * });
+ *
+ * if (response.isValid) {
+ *   // Use token in API requests
+ *   const headers = {
+ *     Authorization: `Bearer ${response.data.token}`,
+ *   };
+ *
+ *   // Token expires in response.data.expiresIn seconds
+ *   setTimeout(
+ *     () => {
+ *       // Refresh token before expiration
+ *     },
+ *     response.data.expiresIn * 1000,
+ *   );
+ * }
+ * ```
+ */
+export const getAuthCredentials = async ({ uploadistaClientId, uploadistaApiKey, baseUrl = "https://api.uploadista.com", }) => {
+    const response = await fetch(`${baseUrl}/uploadista/auth/jwt?apiKey=${uploadistaApiKey}&clientId=${uploadistaClientId}`, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (response.ok !== true) {
+        return { isValid: false, error: "Failed to get auth credentials" };
+    }
+    const data = (await response.json());
+    return {
+        isValid: true,
+        data,
+    };
+};

package/dist/auth/index.d.ts

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

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

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

package/dist/auth/index.js

@@ -0,0 +1 @@
+export * from "./get-auth-credentials";

package/dist/auth/jwt/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * JWT Utilities for Uploadista Authentication
+ *
+ * This module provides JWT token validation and AuthContext extraction utilities
+ * for implementing SaaS-mode authentication in uploadista adapters.
+ *
+ * @example Basic JWT validation
+ * ```typescript
+ * import { validateJwtToken } from '@uploadista/server/auth/jwt';
+ *
+ * const result = await validateJwtToken(token, {
+ *   secret: process.env.JWT_SECRET,
+ *   issuer: 'https://auth.myapp.com',
+ *   audience: 'uploadista-api',
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Valid token for user:', result.userId);
+ * }
+ * ```
+ *
+ * @example Extract AuthContext
+ * ```typescript
+ * import { extractAuthContextFromJwt } from '@uploadista/server/auth/jwt';
+ *
+ * const authContext = await extractAuthContextFromJwt(token, {
+ *   secret: process.env.JWT_SECRET,
+ * });
+ *
+ * if (authContext) {
+ *   // Use auth context in your middleware
+ *   return authContext;
+ * }
+ * ```
+ */
+export type { JwtValidationConfig, JwtValidationError, JwtValidationResult, } from "./types";
+export { extractAuthContextFromJwt, validateJwtToken } from "./validate";
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/jwt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/auth/jwt/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/auth/jwt/index.js

@@ -0,0 +1,36 @@
+/**
+ * JWT Utilities for Uploadista Authentication
+ *
+ * This module provides JWT token validation and AuthContext extraction utilities
+ * for implementing SaaS-mode authentication in uploadista adapters.
+ *
+ * @example Basic JWT validation
+ * ```typescript
+ * import { validateJwtToken } from '@uploadista/server/auth/jwt';
+ *
+ * const result = await validateJwtToken(token, {
+ *   secret: process.env.JWT_SECRET,
+ *   issuer: 'https://auth.myapp.com',
+ *   audience: 'uploadista-api',
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Valid token for user:', result.userId);
+ * }
+ * ```
+ *
+ * @example Extract AuthContext
+ * ```typescript
+ * import { extractAuthContextFromJwt } from '@uploadista/server/auth/jwt';
+ *
+ * const authContext = await extractAuthContextFromJwt(token, {
+ *   secret: process.env.JWT_SECRET,
+ * });
+ *
+ * if (authContext) {
+ *   // Use auth context in your middleware
+ *   return authContext;
+ * }
+ * ```
+ */
+export { extractAuthContextFromJwt, validateJwtToken } from "./validate";

package/dist/auth/jwt/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * JWT validation configuration options
+ */
+export type JwtValidationConfig = {
+    /**
+     * The secret key or public key used to verify the JWT signature.
+     * - For HS256: Use a string secret
+     * - For RS256/ES256: Use a public key (string in PEM format or KeyLike)
+     */
+    secret: string | Uint8Array;
+    /**
+     * Expected issuer (iss claim) of the JWT.
+     * If provided, validation will fail if the token's issuer doesn't match.
+     */
+    issuer?: string;
+    /**
+     * Expected audience (aud claim) of the JWT.
+     * If provided, validation will fail if the token's audience doesn't match.
+     */
+    audience?: string;
+    /**
+     * Clock tolerance in seconds for expiry validation.
+     * Allows tokens to be considered valid even if they're slightly expired
+     * to account for clock skew between servers.
+     * @default 60 (1 minute)
+     */
+    clockTolerance?: number;
+    /**
+     * Allowed signing algorithms.
+     * If not specified, all standard algorithms are allowed (HS256, RS256, ES256).
+     * It's recommended to explicitly specify expected algorithms for security.
+     */
+    algorithms?: string[];
+};
+/**
+ * JWT validation result - either success with claims or failure with error
+ */
+export type JwtValidationResult = {
+    success: true;
+    claims: Record<string, unknown>;
+    userId: string;
+} | {
+    success: false;
+    error: JwtValidationError;
+};
+/**
+ * JWT validation error types
+ */
+export type JwtValidationError = {
+    type: "INVALID_TOKEN";
+    message: string;
+} | {
+    type: "EXPIRED";
+    message: string;
+} | {
+    type: "INVALID_SIGNATURE";
+    message: string;
+} | {
+    type: "INVALID_ISSUER";
+    message: string;
+    expected: string;
+    actual: string;
+} | {
+    type: "INVALID_AUDIENCE";
+    message: string;
+    expected: string;
+    actual: string;
+} | {
+    type: "MISSING_SUBJECT";
+    message: string;
+} | {
+    type: "INVALID_ALGORITHM";
+    message: string;
+    expected: string[];
+    actual: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/auth/jwt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/auth/jwt/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;OAIG;IACH,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAE5B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,kBAAkB,CAAC;CAC3B,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7E;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/auth/jwt/types.js

@@ -0,0 +1 @@
+export {};