@learncard/lca-api-service 1.3.2 → 1.5.0

package/config/config.production.json

@@ -0,0 +1,12 @@
+{
+    "DOMAIN_NAME": "api.learncard.app",
+    "POSTMARK_BRAND_NAME": "LearnCard",
+    "POSTMARK_ENDORSEMENT_REQUEST_TEMPLATE_ALIAS": "universal-inbox-claim-1",
+    "POSTMARK_FROM_EMAIL": "learncard.com",
+    "POSTMARK_LOGIN_CODE_TEMPLATE_ALIAS": "contact-method-verification-1",
+    "POSTMARK_RECOVERY_EMAIL_CODE_TEMPLATE_ALIAS": "recovery-email-verification",
+    "POSTMARK_RECOVERY_KEY_TEMPLATE_ALIAS": "recovery-key-backup",
+    "SA_SEED_ALLOW_LEGACY_READ": "false",
+    "SA_SEED_ENCRYPT_WRITES": "true",
+    "SENTRY_ENV": "lca-api-production"
+}

package/config/config.scouts.dev.json

@@ -0,0 +1,11 @@
+{
+    "DOMAIN_NAME": "staging.api.scoutnetwork.org",
+    "POSTMARK_BRAND_NAME": "ScoutPass",
+    "POSTMARK_FROM_EMAIL": "staging.scoutnetwork.org",
+    "POSTMARK_LOGIN_CODE_TEMPLATE_ALIAS": "sp-login-verification",
+    "POSTMARK_RECOVERY_EMAIL_CODE_TEMPLATE_ALIAS": "sp-recovery-email-verification",
+    "POSTMARK_RECOVERY_KEY_TEMPLATE_ALIAS": "recovery-key-backup",
+    "SA_SEED_ALLOW_LEGACY_READ": "false",
+    "SA_SEED_ENCRYPT_WRITES": "true",
+    "SENTRY_ENV": "scouts-api-staging"
+}

package/config/config.scouts.production.json

@@ -0,0 +1,11 @@
+{
+    "DOMAIN_NAME": "api.scoutnetwork.org",
+    "POSTMARK_BRAND_NAME": "ScoutPass",
+    "POSTMARK_FROM_EMAIL": "scoutnetwork.org",
+    "POSTMARK_LOGIN_CODE_TEMPLATE_ALIAS": "sp-login-verification",
+    "POSTMARK_RECOVERY_EMAIL_CODE_TEMPLATE_ALIAS": "sp-recovery-email-verification",
+    "POSTMARK_RECOVERY_KEY_TEMPLATE_ALIAS": "recovery-key-backup",
+    "SA_SEED_ALLOW_LEGACY_READ": "true",
+    "SA_SEED_ENCRYPT_WRITES": "false",
+    "SENTRY_ENV": "lca-api-production"
+}

package/dist/accesslayer/signing-authority/index.d.ts

@@ -1,16 +1,22 @@
 export declare const getSigningAuthoritiesCollection: () => import("mongodb").Collection<{
     ownerDid: string;
     name: string;
-    seed: string;
     _id?: string | undefined;
+    seed?: string | undefined;
+    encryptedSeed?: string | undefined;
+    encryptedDek?: string | undefined;
+    keyVersion?: "kms-v1" | "local-v1" | undefined;
     did?: string | undefined;
     endpoint?: string | undefined;
 }>;
 export declare const SigningAuthorities: import("mongodb").Collection<{
     ownerDid: string;
     name: string;
-    seed: string;
     _id?: string | undefined;
+    seed?: string | undefined;
+    encryptedSeed?: string | undefined;
+    encryptedDek?: string | undefined;
+    keyVersion?: "kms-v1" | "local-v1" | undefined;
     did?: string | undefined;
     endpoint?: string | undefined;
 }>;

package/dist/app.d.ts

@@ -214,6 +214,11 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                             approvedAt: string;
                             contractUpdatedAt: string;
                         } | undefined;
+                        referral?: {
+                            requestId: string;
+                            requestedBy: string;
+                            externalReferenceId?: string | undefined;
+                        } | undefined;
                         uris?: string[] | undefined;
                     } | undefined;
                     inbox?: {
@@ -305,6 +310,20 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             };
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
+        ensureManagedSigningAuthority: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                ownerDid: string;
+            };
+            output: {
+                ownerDid: string;
+                name: string;
+                did: string;
+                endpoint: string;
+                _id?: string | undefined;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
         signingAuthorities: import("@trpc/server").TRPCQueryProcedure<{
             input: void;
             output: {
@@ -994,6 +1013,88 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
         errorShape: import("@trpc/server").TRPCDefaultErrorShape;
         transformer: false;
     }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        startRecoverySession: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+            };
+            output: {
+                success: true;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        verifyRecoverySession: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+                code: string;
+            };
+            output: {
+                recoverySessionToken: string;
+                recoveryMethods: {
+                    type: "email" | "passkey" | "backup" | "phrase" | "escrow";
+                    createdAt: string;
+                    credentialId?: string | undefined;
+                    shareVersion?: number | undefined;
+                }[];
+                escrowPin: {
+                    state: "enabled" | "none" | "locked" | "stale";
+                    enabled: boolean;
+                    attemptsRemaining: number;
+                    salt?: string | undefined;
+                };
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        useRecoverySession: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                recoverySessionToken: string;
+                type: "email" | "passkey" | "backup" | "phrase" | "escrow";
+                credentialId?: string | undefined;
+            };
+            output: {
+                authShare: {
+                    encryptedData: string;
+                    encryptedDek: string;
+                    iv: string;
+                };
+                primaryDid: string;
+                shareVersion: number;
+                rebindSessionToken: string;
+                encryptedShare?: {
+                    encryptedData: string;
+                    iv: string;
+                    salt?: string | undefined;
+                } | undefined;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        completeRecoveryRebind: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                recoverySessionToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                primaryDid: string;
+                authShare: {
+                    encryptedData: string;
+                    encryptedDek: string;
+                    iv: string;
+                };
+                newAuthToken?: string | undefined;
+            };
+            output: {
+                success: true;
+                shareVersion: number;
+                recoveryMethodsRequireConfirmation: ("email" | "passkey" | "backup" | "phrase" | "escrow")[];
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        issueDidChallenge: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                did: string;
+            };
+            output: {
+                challenge: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
         getAuthShare: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 authToken: string;
@@ -1009,14 +1110,24 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                 primaryDid: string | null;
                 securityLevel: "basic" | "enhanced" | "advanced";
                 recoveryMethods: {
-                    type: "email" | "passkey" | "backup" | "phrase";
+                    type: "email" | "passkey" | "backup" | "phrase" | "escrow";
                     createdAt: string;
                     credentialId?: string | undefined;
                     shareVersion?: number | undefined;
+                    confirmedAt?: string | undefined;
                 }[];
                 keyProvider: "web3auth" | "sss";
                 shareVersion: number;
                 maskedRecoveryEmail: string | null;
+                escrowOptedOut: boolean;
+                escrowPin: {
+                    state: "enabled" | "none" | "locked" | "stale";
+                    enabled: boolean;
+                    attemptsRemaining: number;
+                    salt?: string | undefined;
+                };
+                sssActivationState: "provisional" | "active";
+                escrowStale?: "mode-mismatch" | "key-rotated" | undefined;
             } | null;
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
@@ -1032,10 +1143,13 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                 primaryDid: string;
                 securityLevel?: "basic" | "enhanced" | "advanced" | undefined;
                 keyProvider?: "web3auth" | "sss" | undefined;
+                sssActivationState?: "provisional" | undefined;
+                expectedShareVersion?: number | undefined;
             };
             output: {
                 success: boolean;
                 shareVersion: number;
+                expectedShareVersionChecked: boolean;
             };
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
@@ -1043,7 +1157,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             input: {
                 authToken: string;
                 providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
-                type: "email" | "passkey" | "backup" | "phrase";
+                type: "email" | "passkey" | "backup" | "phrase" | "escrow";
                 encryptedShare?: {
                     encryptedData: string;
                     iv: string;
@@ -1057,11 +1171,36 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             };
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
-        getRecoveryShare: import("@trpc/server").TRPCQueryProcedure<{
+        confirmRecoveryMethod: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 authToken: string;
                 providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
-                type: "email" | "passkey" | "backup" | "phrase";
+                type: "email" | "passkey" | "backup" | "phrase" | "escrow";
+                credentialId?: string | undefined;
+                code?: string | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        deleteRecoveryMethod: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                type: "email" | "passkey" | "backup" | "phrase" | "escrow";
+                credentialId?: string | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getRecoveryShare: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                type: "email" | "passkey" | "backup" | "phrase" | "escrow";
+                authToken?: string | undefined;
                 credentialId?: string | undefined;
             };
             output: {
@@ -1084,6 +1223,16 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             };
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
+        activate: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+            };
+            output: {
+                success: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
         addRecoveryEmail: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 authToken: string;
@@ -1121,9 +1270,18 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             input: {
                 authToken: string;
                 providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
-                emailShare: string;
-                email?: string | undefined;
-                useRecoveryEmail?: boolean | undefined;
+                relayPayload: {
+                    version: 1;
+                    algorithm: "P-256-HKDF-SHA256-AES-256-GCM";
+                    keyId: string;
+                    ephemeralPublicKey: string;
+                    salt: string;
+                    iv: string;
+                    ciphertext: string;
+                };
+                confirmationCode: string;
+                email: string;
+                shareVersion?: number | undefined;
             };
             output: {
                 success: boolean;
@@ -1149,6 +1307,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             input: {
                 authToken: string;
                 providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                challenge: string;
             };
             output: {
                 success: boolean;
@@ -1156,6 +1315,169 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
     }>>;
+    escrow: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: import("@routes").Context;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        getAttestation: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                nonce?: string | undefined;
+            };
+            output: {
+                attestation: {
+                    mode: "software" | "nitro";
+                    keyId: string;
+                    publicKey: string;
+                    measurements: {
+                        imageSha384?: string | undefined;
+                        pcr0?: string | undefined;
+                        pcr1?: string | undefined;
+                        pcr2?: string | undefined;
+                    };
+                    document: string;
+                    issuedAt: string;
+                    previousKeyIds?: string[] | undefined;
+                };
+                holdDurationMs: number;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        enroll: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                envelope: {
+                    version: 1;
+                    algorithm: "P-256-HKDF-SHA256-AES-256-GCM";
+                    keyId: string;
+                    ephemeralPublicKey: string;
+                    salt: string;
+                    iv: string;
+                    ciphertext: string;
+                };
+                shareVersion: number;
+                enclaveKeyId: string;
+                pinSalt?: string | undefined;
+                clearPin?: boolean | undefined;
+            };
+            output: {
+                success: true;
+                shareVersion: number;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        remove: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+                optOut: boolean;
+            };
+            output: {
+                success: true;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        optIn: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+            };
+            output: {
+                success: true;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        startRecovery: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                clientEphemeralPublicKey: string;
+                releasePolicy?: "pin" | "hold" | undefined;
+                restart?: boolean | undefined;
+                authToken?: string | undefined;
+                providerType?: "firebase" | "supertokens" | "keycloak" | "oidc" | undefined;
+                recoverySessionToken?: string | undefined;
+            };
+            output: {
+                holdId: string;
+                releasePolicy: "pin" | "hold";
+                requestedAt: string;
+                releaseAfter: string;
+                status: "pending";
+                resumeToken: string | null;
+                pinSalt?: string | undefined;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getStatus: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                holdId?: string | undefined;
+                resumeToken?: string | undefined;
+                authToken?: string | undefined;
+                providerType?: "firebase" | "supertokens" | "keycloak" | "oidc" | undefined;
+            };
+            output: {
+                hold: {
+                    holdId: string;
+                    status: "pending" | "cancelled" | "completed" | "expired";
+                    requestedAt: string;
+                    releaseAfter: string;
+                    releasePolicy: "pin" | "hold";
+                    cancelledAt?: string | undefined;
+                    completedAt?: string | undefined;
+                } | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        cancelRecovery: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                authToken: string;
+                providerType: "firebase" | "supertokens" | "keycloak" | "oidc";
+            };
+            output: {
+                success: true;
+                cancelled: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        cancelRecoveryByLink: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                holdId: string;
+                token: string;
+            };
+            output: {
+                cancelled: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        completeRecovery: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                holdId: string;
+                resumeToken: string;
+                pinProof?: string | undefined;
+            };
+            output: {
+                sealedShare: {
+                    version: 1;
+                    algorithm: "P-256-HKDF-SHA256-AES-256-GCM";
+                    keyId: string;
+                    ephemeralPublicKey: string;
+                    salt: string;
+                    iv: string;
+                    ciphertext: string;
+                };
+                authShare: {
+                    encryptedData: string;
+                    encryptedDek: string;
+                    iv: string;
+                };
+                primaryDid: string;
+                shareVersion: number;
+                rebindSessionToken: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
     qrLogin: import("@trpc/server").TRPCBuiltRouter<{
         ctx: import("@routes").Context;
         meta: import("trpc-to-openapi").OpenApiMeta;
@@ -1180,7 +1502,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: {
                 sessionId: string;
                 publicKey: string;
-                status: "approved" | "pending";
+                status: "pending" | "approved";
                 encryptedPayload?: string | undefined;
                 approverDid?: string | undefined;
             };
@@ -1211,6 +1533,37 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             meta: import("trpc-to-openapi").OpenApiMeta;
         }>;
     }>>;
+    auth: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: import("@routes").Context;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        requestLoginTicket: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+                code: string;
+            };
+            output: {
+                success: boolean;
+                ticket?: string | undefined;
+                error?: string | undefined;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        requestSocialLoginTicket: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                provider: "google" | "apple";
+                idToken: string;
+            };
+            output: {
+                success: boolean;
+                ticket?: string | undefined;
+                error?: string | undefined;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
 } & {
     test?: TestRouter;
 }>>;

package/dist/cache/challenges.d.ts

@@ -1,6 +1,8 @@
 export declare const getChallengeCacheKey: (did: string, challenge: string) => string;
 export declare const VALID = "valid";
+export declare const DID_CHALLENGE_TTL_SECS: number;
 export declare const isChallengeValidForDid: (did: string, challenge: string) => Promise<typeof VALID | null | undefined>;
+export declare const consumeChallengeForDid: (did: string, challenge: string) => Promise<boolean>;
 export declare const setValidChallengeForDid: (did: string, challenge: string) => Promise<"OK" | undefined>;
 export declare const setValidChallengesForDid: (did: string, challenges: string[]) => Promise<"OK" | undefined>;
 export declare const invalidateChallengeForDid: (did: string, challenge: string) => Promise<number | undefined>;

package/dist/cache/getDel.d.ts

@@ -0,0 +1,2 @@
+export declare const getDel: (key: string) => Promise<string | null>;
+export declare const consumeMatchingCode: (key: string, code: string) => Promise<boolean>;

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

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

package/dist/cache/login-tickets.d.ts

@@ -0,0 +1,12 @@
+export interface LoginTicketPayload {
+    subject: string;
+    email?: string;
+    emailVerified?: boolean;
+    phoneNumber?: string;
+    phoneNumberVerified?: boolean;
+    name?: string;
+    picture?: string;
+    identityKey: string;
+}
+export declare const issueLoginTicket: (payload: LoginTicketPayload) => Promise<string>;
+export declare const redeemLoginTicket: (ticket: string) => Promise<LoginTicketPayload | null>;

package/dist/cache/recoverySessions.d.ts

@@ -0,0 +1,42 @@
+import type { AuthProviderType } from '@helpers/auth.helpers';
+export declare const RECOVERY_SESSION_TTL_SECS: number;
+export declare const RECOVERY_OTP_TTL_SECS: number;
+export declare const RECOVERY_OTP_SEND_COOLDOWN_SECS = 60;
+export declare const MAX_RECOVERY_OTP_ATTEMPTS = 5;
+export type RecoverySessionScope = 'recover' | 'rebind';
+export interface RecoverySessionRecord {
+    scope: RecoverySessionScope;
+    authProvider: {
+        type: AuthProviderType;
+        id: string;
+    };
+}
+export interface RecoveryOtpRecord {
+    codeHash: string;
+    authProvider: {
+        type: AuthProviderType;
+        id: string;
+    };
+}
+export type RecoveryOtpVerificationResult = {
+    status: 'ok';
+    record: RecoveryOtpRecord;
+} | {
+    status: 'mismatch';
+    attempts: number;
+} | {
+    status: 'locked';
+} | {
+    status: 'none';
+};
+export declare const getRecoveryEmailDigest: (email: string) => string;
+export declare const getRecoveryOtpCacheKey: (email: string) => string;
+export declare const getRecoveryOtpAttemptsCacheKey: (email: string) => string;
+export declare const getRecoveryOtpLockCacheKey: (email: string) => string;
+export declare const getRecoveryOtpSendCacheKey: (email: string) => string;
+export declare const getRecoverySessionCacheKey: (token: string) => string;
+export declare const createRecoverySession: (record: RecoverySessionRecord, ttl?: number) => Promise<string>;
+export declare const consumeRecoverySession: (token: string, expectedScope: RecoverySessionScope) => Promise<RecoverySessionRecord | null>;
+export declare const storeRecoveryOtp: (email: string, record: RecoveryOtpRecord) => Promise<void>;
+export declare const verifyRecoveryOtp: (email: string, submittedCodeHash: string) => Promise<RecoveryOtpVerificationResult>;
+export declare const claimRecoveryOtpSendWindow: (email: string) => Promise<boolean>;

package/dist/config/applyDockerStageConfig.d.ts

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

package/dist/config/cacheEnvironment.d.ts

@@ -0,0 +1,16 @@
+import 'dotenv/config';
+import { z } from 'zod';
+export declare const cacheEnvironmentShape: {
+    REDIS_HOST: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    REDIS_PORT: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+};
+export declare const cacheEnvironmentSchema: z.ZodObject<{
+    REDIS_HOST: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    REDIS_PORT: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export type CacheEnvironment = z.output<typeof cacheEnvironmentSchema>;
+export declare const parseCacheEnvironment: (raw: Record<string, unknown>, source?: string) => CacheEnvironment;
+export declare const environment: {
+    REDIS_HOST?: string | undefined;
+    REDIS_PORT?: number | undefined;
+};