@stackframe/stack-shared 2.0.0 → 2.2.0

package/dist/known-errors.d.ts

@@ -0,0 +1,202 @@
+import { StatusError } from "./utils/errors";
+import { Json } from "./utils/json";
+export type KnownErrorJson = {
+    code: string;
+    message: string;
+    details?: Json;
+};
+export type AbstractKnownErrorConstructor<Args extends any[]> = (abstract new (...args: Args) => KnownError) & {
+    constructorArgsFromJson: (json: KnownErrorJson) => Args;
+};
+export type KnownErrorConstructor<Instance extends KnownError, Args extends any[]> = {
+    new (...args: Args): Instance;
+    errorCode: string;
+    constructorArgsFromJson: (json: KnownErrorJson) => Args;
+};
+export declare abstract class KnownError extends StatusError {
+    readonly statusCode: number;
+    readonly humanReadableMessage: string;
+    readonly details?: Json | undefined;
+    constructor(statusCode: number, humanReadableMessage: string, details?: Json | undefined);
+    getBody(): Uint8Array;
+    getHeaders(): Record<string, string[]>;
+    get errorCode(): string;
+    static constructorArgsFromJson(json: KnownErrorJson): ConstructorParameters<typeof KnownError>;
+    static fromJson(json: KnownErrorJson): KnownError;
+}
+declare const knownErrorConstructorErrorCodeSentinel: unique symbol;
+/**
+ * Exists solely so that known errors are nominative types (ie. two KnownErrors with the same interface are not the same type)
+ */
+type KnownErrorBrand<ErrorCode extends string> = {
+    /**
+     * Does not exist at runtime
+     *
+     * Must be an object because it may be true for multiple error codes (it's true for all parents)
+     */
+    [knownErrorConstructorErrorCodeSentinel]: {
+        [K in ErrorCode]: true;
+    };
+};
+export type KnownErrors = {
+    [K in keyof typeof KnownErrors]: InstanceType<typeof KnownErrors[K]>;
+};
+export declare const KnownErrors: {
+    UnsupportedError: KnownErrorConstructor<KnownError & KnownErrorBrand<"UNSUPPORTED_ERROR">, [originalErrorCode: string]> & {
+        errorCode: "UNSUPPORTED_ERROR";
+    };
+    SchemaError: KnownErrorConstructor<KnownError & KnownErrorBrand<"SCHEMA_ERROR">, [string]> & {
+        errorCode: "SCHEMA_ERROR";
+    };
+    AllOverloadsFailed: KnownErrorConstructor<KnownError & KnownErrorBrand<"ALL_OVERLOADS_FAILED">, [overloadErrors: Json[]]> & {
+        errorCode: "ALL_OVERLOADS_FAILED";
+    };
+    ProjectAuthenticationError: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "PROJECT_AUTHENTICATION_ERROR";
+    };
+    InvalidProjectAuthentication: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "INVALID_PROJECT_AUTHENTICATION";
+    };
+    InvalidPublishableClientKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_PUBLISHABLE_CLIENT_KEY">, []> & {
+        errorCode: "INVALID_PUBLISHABLE_CLIENT_KEY";
+    };
+    InvalidSecretServerKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SECRET_SERVER_KEY">, []> & {
+        errorCode: "INVALID_SECRET_SERVER_KEY";
+    };
+    InvalidSuperSecretAdminKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SUPER_SECRET_ADMIN_KEY">, []> & {
+        errorCode: "INVALID_SUPER_SECRET_ADMIN_KEY";
+    };
+    InvalidAdminAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "INVALID_ADMIN_ACCESS_TOKEN";
+    };
+    UnparsableAdminAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN"> & KnownErrorBrand<"UNPARSABLE_ADMIN_ACCESS_TOKEN">, []> & {
+        errorCode: "UNPARSABLE_ADMIN_ACCESS_TOKEN";
+    };
+    AdminAccessTokenExpired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN"> & KnownErrorBrand<"ADMIN_ACCESS_TOKEN_EXPIRED">, []> & {
+        errorCode: "ADMIN_ACCESS_TOKEN_EXPIRED";
+    };
+    InvalidProjectForAdminAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN"> & KnownErrorBrand<"INVALID_PROJECT_FOR_ADMIN_ACCESS_TOKEN">, []> & {
+        errorCode: "INVALID_PROJECT_FOR_ADMIN_ACCESS_TOKEN";
+    };
+    ProjectAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "PROJECT_AUTHENTICATION_REQUIRED";
+    };
+    ClientAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"CLIENT_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "CLIENT_AUTHENTICATION_REQUIRED";
+    };
+    ServerAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"SERVER_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "SERVER_AUTHENTICATION_REQUIRED";
+    };
+    ClientOrServerAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"CLIENT_OR_SERVER_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "CLIENT_OR_SERVER_AUTHENTICATION_REQUIRED";
+    };
+    ClientOrAdminAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"CLIENT_OR_ADMIN_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "CLIENT_OR_ADMIN_AUTHENTICATION_REQUIRED";
+    };
+    ClientOrServerOrAdminAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"CLIENT_OR_SERVER_OR_ADMIN_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "CLIENT_OR_SERVER_OR_ADMIN_AUTHENTICATION_REQUIRED";
+    };
+    AdminAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED"> & KnownErrorBrand<"ADMIN_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "ADMIN_AUTHENTICATION_REQUIRED";
+    };
+    ExpectedInternalProject: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"EXPECTED_INTERNAL_PROJECT">, []> & {
+        errorCode: "EXPECTED_INTERNAL_PROJECT";
+    };
+    SessionAuthenticationError: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "SESSION_AUTHENTICATION_ERROR";
+    };
+    InvalidSessionAuthentication: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "INVALID_SESSION_AUTHENTICATION";
+    };
+    InvalidAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "INVALID_ACCESS_TOKEN";
+    };
+    UnparsableAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"UNPARSABLE_ACCESS_TOKEN">, []> & {
+        errorCode: "UNPARSABLE_ACCESS_TOKEN";
+    };
+    AccessTokenExpired: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"ACCESS_TOKEN_EXPIRED">, []> & {
+        errorCode: "ACCESS_TOKEN_EXPIRED";
+    };
+    InvalidProjectForAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"INVALID_PROJECT_FOR_ACCESS_TOKEN">, []> & {
+        errorCode: "INVALID_PROJECT_FOR_ACCESS_TOKEN";
+    };
+    SessionUserEmailNotVerified: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"SESSION_USER_EMAIL_NOT_VERIFIED">, []> & {
+        errorCode: "SESSION_USER_EMAIL_NOT_VERIFIED";
+    };
+    SessionAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & KnownErrorBrand<"SESSION_AUTHENTICATION_REQUIRED">, []> & {
+        errorCode: "SESSION_AUTHENTICATION_REQUIRED";
+    };
+    RefreshTokenError: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_REFRESH_TOKEN">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "INVALID_REFRESH_TOKEN";
+    };
+    ProviderRejected: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_REFRESH_TOKEN"> & KnownErrorBrand<"PROVIDER_REJECTED">, []> & {
+        errorCode: "PROVIDER_REJECTED";
+    };
+    InvalidRefreshToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_REFRESH_TOKEN"> & KnownErrorBrand<"REFRESH_TOKEN_EXPIRED">, []> & {
+        errorCode: "REFRESH_TOKEN_EXPIRED";
+    };
+    UserEmailAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"USER_EMAIL_ALREADY_EXISTS">, []> & {
+        errorCode: "USER_EMAIL_ALREADY_EXISTS";
+    };
+    UserNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"USER_NOT_FOUND">, []> & {
+        errorCode: "USER_NOT_FOUND";
+    };
+    ApiKeyNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"API_KEY_NOT_FOUND">, []> & {
+        errorCode: "API_KEY_NOT_FOUND";
+    };
+    ProjectNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_NOT_FOUND">, []> & {
+        errorCode: "PROJECT_NOT_FOUND";
+    };
+    EmailPasswordMismatch: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_PASSWORD_MISMATCH">, []> & {
+        errorCode: "EMAIL_PASSWORD_MISMATCH";
+    };
+    RedirectUrlNotWhitelisted: KnownErrorConstructor<KnownError & KnownErrorBrand<"REDIRECT_URL_NOT_WHITELISTED">, []> & {
+        errorCode: "REDIRECT_URL_NOT_WHITELISTED";
+    };
+    PasswordRequirementsNotMet: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_REQUIREMENTS_NOT_MET">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "PASSWORD_REQUIREMENTS_NOT_MET";
+    };
+    PasswordTooShort: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_REQUIREMENTS_NOT_MET"> & KnownErrorBrand<"PASSWORD_TOO_SHORT">, [minLength: number]> & {
+        errorCode: "PASSWORD_TOO_SHORT";
+    };
+    PasswordTooLong: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_REQUIREMENTS_NOT_MET"> & KnownErrorBrand<"PASSWORD_TOO_LONG">, [maxLength: number]> & {
+        errorCode: "PASSWORD_TOO_LONG";
+    };
+    EmailVerificationError: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_VERIFICATION_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "EMAIL_VERIFICATION_ERROR";
+    };
+    EmailVerificationCodeError: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_VERIFICATION_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "EMAIL_VERIFICATION_CODE_ERROR";
+    };
+    EmailVerificationCodeNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_VERIFICATION_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_NOT_FOUND">, []> & {
+        errorCode: "EMAIL_VERIFICATION_CODE_NOT_FOUND";
+    };
+    EmailVerificationCodeExpired: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_VERIFICATION_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_EXPIRED">, []> & {
+        errorCode: "EMAIL_VERIFICATION_CODE_EXPIRED";
+    };
+    EmailVerificationCodeAlreadyUsed: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_VERIFICATION_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_ERROR"> & KnownErrorBrand<"EMAIL_VERIFICATION_CODE_ALREADY_USED">, []> & {
+        errorCode: "EMAIL_VERIFICATION_CODE_ALREADY_USED";
+    };
+    PasswordResetError: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_RESET_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "PASSWORD_RESET_ERROR";
+    };
+    PasswordResetCodeError: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_RESET_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
+        errorCode: "PASSWORD_RESET_CODE_ERROR";
+    };
+    PasswordResetCodeNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_RESET_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_NOT_FOUND">, []> & {
+        errorCode: "PASSWORD_RESET_CODE_NOT_FOUND";
+    };
+    PasswordResetCodeExpired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_RESET_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_EXPIRED">, []> & {
+        errorCode: "PASSWORD_RESET_CODE_EXPIRED";
+    };
+    PasswordResetCodeAlreadyUsed: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_RESET_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_ERROR"> & KnownErrorBrand<"PASSWORD_RESET_CODE_ALREADY_USED">, []> & {
+        errorCode: "PASSWORD_RESET_CODE_ALREADY_USED";
+    };
+    PasswordMismatch: KnownErrorConstructor<KnownError & KnownErrorBrand<"PASSWORD_MISMATCH">, []> & {
+        errorCode: "PASSWORD_MISMATCH";
+    };
+    EmailAlreadyVerified: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_ALREADY_VERIFIED">, []> & {
+        errorCode: "EMAIL_ALREADY_VERIFIED";
+    };
+};
+export {};

package/dist/known-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-errors.d.ts","sourceRoot":"","sources":["../src/known-errors.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA2B,MAAM,gBAAgB,CAAC;AAEtE,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEpC,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,6BAA6B,CAAC,IAAI,SAAS,GAAG,EAAE,IACxD,CAAC,QAAQ,MAAM,GAAG,IAAI,EAAE,IAAI,KAAK,UAAU,CAAC,GAC5C;IACA,uBAAuB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;CACzD,CAAC;AAEJ,MAAM,MAAM,qBAAqB,CAAC,QAAQ,SAAS,UAAU,EAAE,IAAI,SAAS,GAAG,EAAE,IAAI;IACnF,KAAK,GAAG,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;CACzD,CAAC;AAEF,8BAAsB,UAAW,SAAQ,WAAW;aAEhC,UAAU,EAAE,MAAM;aAClB,oBAAoB,EAAE,MAAM;aAC5B,OAAO,CAAC;gBAFR,UAAU,EAAE,MAAM,EAClB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,CAAC,kBAAM;IAQhB,OAAO,IAAI,UAAU;IAQrB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAOtD,IAAI,SAAS,IAAI,MAAM,CAEtB;WAEa,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,qBAAqB,CAAC,OAAO,UAAU,CAAC;WAQvF,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU;CAYzD;AAED,QAAA,MAAM,sCAAsC,eAAmD,CAAC;AAChG;;GAEG;AACH,KAAK,eAAe,CAAC,SAAS,SAAS,MAAM,IAAI;IAC/C;;;;OAIG;IACH,CAAC,sCAAsC,CAAC,EAAE;SACvC,CAAC,IAAI,SAAS,GAAG,IAAI;KACvB,CAAC;CACH,CAAC;AA8hBF,MAAM,MAAM,WAAW,GAAG;KACvB,CAAC,IAAI,MAAM,OAAO,WAAW,GAAG,YAAY,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC;CACrE,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDmC,CAAC"}

package/dist/known-errors.js

@@ -0,0 +1,316 @@
+import { StatusError, throwErr, throwStackErr } from "./utils/errors";
+import { identityArgs } from "./utils/functions";
+export class KnownError extends StatusError {
+    statusCode;
+    humanReadableMessage;
+    details;
+    constructor(statusCode, humanReadableMessage, details) {
+        super(statusCode, humanReadableMessage);
+        this.statusCode = statusCode;
+        this.humanReadableMessage = humanReadableMessage;
+        this.details = details;
+    }
+    getBody() {
+        return new TextEncoder().encode(JSON.stringify({
+            code: this.errorCode,
+            message: this.humanReadableMessage,
+            details: this.details,
+        }, undefined, 2));
+    }
+    getHeaders() {
+        return {
+            "Content-Type": ["application/json; charset=utf-8"],
+            "X-Stack-Known-Error": [this.errorCode],
+        };
+    }
+    get errorCode() {
+        return this.constructor.errorCode ?? throwStackErr(`Can't find error code for this KnownError. Is its constructor a KnownErrorConstructor? ${this}`);
+    }
+    static constructorArgsFromJson(json) {
+        return [
+            400,
+            json.message,
+            json.details,
+        ];
+    }
+    static fromJson(json) {
+        for (const [_, KnownErrorType] of Object.entries(KnownErrors)) {
+            if (json.code === KnownErrorType.prototype.errorCode) {
+                return new KnownErrorType(
+                // @ts-expect-error
+                ...KnownErrorType.constructorArgsFromJson(json));
+            }
+        }
+        throw new Error(`Unknown KnownError code: ${json.code}`);
+    }
+}
+const knownErrorConstructorErrorCodeSentinel = Symbol("knownErrorConstructorErrorCodeSentinel");
+function createKnownErrorConstructor(SuperClass, errorCode, create, constructorArgsFromJson) {
+    const createFn = create === "inherit" ? identityArgs : create;
+    const constructorArgsFromJsonFn = constructorArgsFromJson === "inherit" ? SuperClass.constructorArgsFromJson : constructorArgsFromJson;
+    // @ts-expect-error this is not a mixin, but TS detects it as one
+    class KnownErrorImpl extends SuperClass {
+        static errorCode = errorCode;
+        constructor(...args) {
+            // @ts-expect-error
+            super(...createFn(...args));
+        }
+        static constructorArgsFromJson(json) {
+            return constructorArgsFromJsonFn(json);
+        }
+    }
+    ;
+    // @ts-expect-error
+    return KnownErrorImpl;
+}
+const UnsupportedError = createKnownErrorConstructor(KnownError, "UNSUPPORTED_ERROR", (originalErrorCode) => [
+    500,
+    `An error occured that is not currently supported (possibly because it was added in a version of Stack that is newer than this client). The original unsupported error code was: ${originalErrorCode}`,
+    {
+        originalErrorCode,
+    },
+], (json) => [
+    json.details?.originalErrorCode ?? throwErr("originalErrorCode not found in UnsupportedError details"),
+]);
+const SchemaError = createKnownErrorConstructor(KnownError, "SCHEMA_ERROR", (message) => [
+    400,
+    message,
+], (json) => [json.message]);
+const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOADS_FAILED", (overloadErrors) => [
+    400,
+    "This endpoint has multiple overloads, but they all failed to process the request.",
+    {
+        overloads: overloadErrors,
+    },
+], (json) => [
+    json.details?.overloadErrors ?? throwErr("overloadErrors not found in AllOverloadsFailed details"),
+]);
+const ProjectAuthenticationError = createKnownErrorConstructor(KnownError, "PROJECT_AUTHENTICATION_ERROR", "inherit", "inherit");
+const InvalidProjectAuthentication = createKnownErrorConstructor(ProjectAuthenticationError, "INVALID_PROJECT_AUTHENTICATION", "inherit", "inherit");
+const InvalidPublishableClientKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_PUBLISHABLE_CLIENT_KEY", () => [
+    401,
+    "The publishable key is not valid for the given project. Does the project and/or the key exist?",
+], () => []);
+const InvalidSecretServerKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SECRET_SERVER_KEY", () => [
+    401,
+    "The secret server key is not valid for the given project. Does the project and/or the key exist?",
+], () => []);
+const InvalidSuperSecretAdminKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SUPER_SECRET_ADMIN_KEY", () => [
+    401,
+    "The super secret admin key is not valid for the given project. Does the project and/or the key exist?",
+], () => []);
+const InvalidAdminAccessToken = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_ADMIN_ACCESS_TOKEN", "inherit", "inherit");
+const UnparsableAdminAccessToken = createKnownErrorConstructor(InvalidAdminAccessToken, "UNPARSABLE_ADMIN_ACCESS_TOKEN", () => [
+    401,
+    "Admin access token is not parsable.",
+], () => []);
+const AdminAccessTokenExpired = createKnownErrorConstructor(InvalidAdminAccessToken, "ADMIN_ACCESS_TOKEN_EXPIRED", () => [
+    401,
+    "Admin access token has expired. Please refresh it and try again.",
+], () => []);
+const InvalidProjectForAdminAccessToken = createKnownErrorConstructor(InvalidAdminAccessToken, "INVALID_PROJECT_FOR_ADMIN_ACCESS_TOKEN", () => [
+    401,
+    "Admin access token not valid for this project.",
+], () => []);
+const ProjectAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationError, "PROJECT_AUTHENTICATION_REQUIRED", "inherit", "inherit");
+const ClientAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "CLIENT_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "The publishable client key must be provided.",
+], () => []);
+const ServerAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "SERVER_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "The secret server key must be provided.",
+], () => []);
+const ClientOrServerAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "CLIENT_OR_SERVER_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "Either the publishable client key or the secret server key must be provided.",
+], () => []);
+const ClientOrAdminAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "CLIENT_OR_ADMIN_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "Either the publishable client key or the super secret admin key must be provided.",
+], () => []);
+const ClientOrServerOrAdminAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "CLIENT_OR_SERVER_OR_ADMIN_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "Either the publishable client key, the secret server key, or the super secret admin key must be provided.",
+], () => []);
+const AdminAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "ADMIN_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "The super secret admin key must be provided.",
+], () => []);
+const ExpectedInternalProject = createKnownErrorConstructor(ProjectAuthenticationError, "EXPECTED_INTERNAL_PROJECT", () => [
+    401,
+    "The project ID is expected to be internal.",
+], () => []);
+const SessionAuthenticationError = createKnownErrorConstructor(KnownError, "SESSION_AUTHENTICATION_ERROR", "inherit", "inherit");
+const InvalidSessionAuthentication = createKnownErrorConstructor(SessionAuthenticationError, "INVALID_SESSION_AUTHENTICATION", "inherit", "inherit");
+const InvalidAccessToken = createKnownErrorConstructor(InvalidSessionAuthentication, "INVALID_ACCESS_TOKEN", "inherit", "inherit");
+const UnparsableAccessToken = createKnownErrorConstructor(InvalidAccessToken, "UNPARSABLE_ACCESS_TOKEN", () => [
+    401,
+    "Access token is not parsable.",
+], () => []);
+const AccessTokenExpired = createKnownErrorConstructor(InvalidAccessToken, "ACCESS_TOKEN_EXPIRED", () => [
+    401,
+    "Access token has expired. Please refresh it and try again.",
+], () => []);
+const InvalidProjectForAccessToken = createKnownErrorConstructor(InvalidAccessToken, "INVALID_PROJECT_FOR_ACCESS_TOKEN", () => [
+    401,
+    "Access token not valid for this project.",
+], () => []);
+const SessionUserEmailNotVerified = createKnownErrorConstructor(InvalidSessionAuthentication, "SESSION_USER_EMAIL_NOT_VERIFIED", () => [
+    401,
+    "User e-mail not verified, but is required by the project.",
+], () => []);
+const SessionAuthenticationRequired = createKnownErrorConstructor(SessionAuthenticationError, "SESSION_AUTHENTICATION_REQUIRED", () => [
+    401,
+    "Session required for this request.",
+], () => []);
+const RefreshTokenError = createKnownErrorConstructor(KnownError, "INVALID_REFRESH_TOKEN", "inherit", "inherit");
+const ProviderRejected = createKnownErrorConstructor(RefreshTokenError, "PROVIDER_REJECTED", () => [
+    401,
+    "The provider refused to refresh their token.",
+], () => []);
+const InvalidRefreshToken = createKnownErrorConstructor(RefreshTokenError, "REFRESH_TOKEN_EXPIRED", () => [
+    401,
+    "Refresh token has expired. A new refresh token requires reauthentication.",
+], () => []);
+const UserEmailAlreadyExists = createKnownErrorConstructor(KnownError, "USER_EMAIL_ALREADY_EXISTS", () => [
+    400,
+    "User already exists.",
+], () => []);
+const UserNotFound = createKnownErrorConstructor(KnownError, "USER_NOT_FOUND", () => [
+    404,
+    "User not found.",
+], () => []);
+const ApiKeyNotFound = createKnownErrorConstructor(KnownError, "API_KEY_NOT_FOUND", () => [
+    404,
+    "API key not found.",
+], () => []);
+const ProjectNotFound = createKnownErrorConstructor(KnownError, "PROJECT_NOT_FOUND", () => [
+    404,
+    "Project not found or is not accessible with the current user.",
+], () => []);
+const EmailPasswordMismatch = createKnownErrorConstructor(KnownError, "EMAIL_PASSWORD_MISMATCH", () => [
+    400,
+    "Wrong e-mail or password.",
+], () => []);
+const RedirectUrlNotWhitelisted = createKnownErrorConstructor(KnownError, "REDIRECT_URL_NOT_WHITELISTED", () => [
+    400,
+    "Redirect URL not whitelisted.",
+], () => []);
+const PasswordRequirementsNotMet = createKnownErrorConstructor(KnownError, "PASSWORD_REQUIREMENTS_NOT_MET", "inherit", "inherit");
+const PasswordTooShort = createKnownErrorConstructor(PasswordRequirementsNotMet, "PASSWORD_TOO_SHORT", (minLength) => [
+    400,
+    `Password too short. Minimum length is ${minLength}.`,
+    {
+        minLength,
+    },
+], (json) => [
+    json.details?.minLength ?? throwErr("minLength not found in PasswordTooShort details"),
+]);
+const PasswordTooLong = createKnownErrorConstructor(PasswordRequirementsNotMet, "PASSWORD_TOO_LONG", (maxLength) => [
+    400,
+    `Password too long. Maximum length is ${maxLength}.`,
+    {
+        maxLength,
+    },
+], (json) => [
+    json.details?.maxLength ?? throwErr("maxLength not found in PasswordTooLong details"),
+]);
+const EmailVerificationError = createKnownErrorConstructor(KnownError, "EMAIL_VERIFICATION_ERROR", "inherit", "inherit");
+const EmailVerificationCodeError = createKnownErrorConstructor(EmailVerificationError, "EMAIL_VERIFICATION_CODE_ERROR", "inherit", "inherit");
+const EmailVerificationCodeNotFound = createKnownErrorConstructor(EmailVerificationCodeError, "EMAIL_VERIFICATION_CODE_NOT_FOUND", () => [
+    404,
+    "The e-mail verification code does not exist for this project.",
+], () => []);
+const EmailVerificationCodeExpired = createKnownErrorConstructor(EmailVerificationCodeError, "EMAIL_VERIFICATION_CODE_EXPIRED", () => [
+    400,
+    "The e-mail verification code has expired.",
+], () => []);
+const EmailVerificationCodeAlreadyUsed = createKnownErrorConstructor(EmailVerificationCodeError, "EMAIL_VERIFICATION_CODE_ALREADY_USED", () => [
+    400,
+    "The e-mail verification link has already been used.",
+], () => []);
+const PasswordMismatch = createKnownErrorConstructor(KnownError, "PASSWORD_MISMATCH", () => [
+    400,
+    "Passwords do not match.",
+], () => []);
+const PasswordResetError = createKnownErrorConstructor(KnownError, "PASSWORD_RESET_ERROR", "inherit", "inherit");
+const PasswordResetCodeError = createKnownErrorConstructor(PasswordResetError, "PASSWORD_RESET_CODE_ERROR", "inherit", "inherit");
+const PasswordResetCodeNotFound = createKnownErrorConstructor(PasswordResetCodeError, "PASSWORD_RESET_CODE_NOT_FOUND", () => [
+    404,
+    "The password reset code does not exist for this project.",
+], () => []);
+const PasswordResetCodeExpired = createKnownErrorConstructor(PasswordResetCodeError, "PASSWORD_RESET_CODE_EXPIRED", () => [
+    400,
+    "The password reset code has expired.",
+], () => []);
+const PasswordResetCodeAlreadyUsed = createKnownErrorConstructor(PasswordResetCodeError, "PASSWORD_RESET_CODE_ALREADY_USED", () => [
+    400,
+    "The password reset code has already been used.",
+], () => []);
+const EmailAlreadyVerified = createKnownErrorConstructor(KnownError, "EMAIL_ALREADY_VERIFIED", () => [
+    400,
+    "The e-mail is already verified.",
+], () => []);
+export const KnownErrors = {
+    UnsupportedError,
+    SchemaError,
+    AllOverloadsFailed,
+    ProjectAuthenticationError,
+    InvalidProjectAuthentication,
+    InvalidPublishableClientKey,
+    InvalidSecretServerKey,
+    InvalidSuperSecretAdminKey,
+    InvalidAdminAccessToken,
+    UnparsableAdminAccessToken,
+    AdminAccessTokenExpired,
+    InvalidProjectForAdminAccessToken,
+    ProjectAuthenticationRequired,
+    ClientAuthenticationRequired,
+    ServerAuthenticationRequired,
+    ClientOrServerAuthenticationRequired,
+    ClientOrAdminAuthenticationRequired,
+    ClientOrServerOrAdminAuthenticationRequired,
+    AdminAuthenticationRequired,
+    ExpectedInternalProject,
+    SessionAuthenticationError,
+    InvalidSessionAuthentication,
+    InvalidAccessToken,
+    UnparsableAccessToken,
+    AccessTokenExpired,
+    InvalidProjectForAccessToken,
+    SessionUserEmailNotVerified,
+    SessionAuthenticationRequired,
+    RefreshTokenError,
+    ProviderRejected,
+    InvalidRefreshToken,
+    UserEmailAlreadyExists,
+    UserNotFound,
+    ApiKeyNotFound,
+    ProjectNotFound,
+    EmailPasswordMismatch,
+    RedirectUrlNotWhitelisted,
+    PasswordRequirementsNotMet,
+    PasswordTooShort,
+    PasswordTooLong,
+    EmailVerificationError,
+    EmailVerificationCodeError,
+    EmailVerificationCodeNotFound,
+    EmailVerificationCodeExpired,
+    EmailVerificationCodeAlreadyUsed,
+    PasswordResetError,
+    PasswordResetCodeError,
+    PasswordResetCodeNotFound,
+    PasswordResetCodeExpired,
+    PasswordResetCodeAlreadyUsed,
+    PasswordMismatch,
+    EmailAlreadyVerified,
+};
+// ensure that all known error codes are unique
+const knownErrorCodes = new Set();
+for (const [_, KnownError] of Object.entries(KnownErrors)) {
+    if (knownErrorCodes.has(KnownError.errorCode)) {
+        throw new Error(`Duplicate known error code: ${KnownError.errorCode}`);
+    }
+    knownErrorCodes.add(KnownError.errorCode);
+}

package/dist/utils/arrays.d.ts

@@ -1,7 +1,7 @@
 export declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
 export declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
 export declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
-export declare function groupBy<T extends readonly any[], K>(arr: T, key: (item: T[number]) => K): Map<K, T[number][]>;
+export declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
 export declare function range(endExclusive: number): number[];
 export declare function range(startInclusive: number, endExclusive: number): number[];
 export declare function range(startInclusive: number, endExclusive: number, step: number): number[];

package/dist/utils/arrays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../../src/utils/arrays.tsx"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAEhG;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAEjF;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,EAAE,GAAG,OAAO,CAM5E;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,CAAC,EACjD,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAC1B,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAQrB;AAGD,wBAAgB,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AACtD,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAgB5F,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAGhE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAEjE;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAOjD"}
+{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../../src/utils/arrays.tsx"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAEhG;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAEjF;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,EAAE,GAAG,OAAO,CAM5E;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,EACtC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,EAChB,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAClB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAQb;AAGD,wBAAgB,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AACtD,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAgB5F,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAGhE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAEjE;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAOjD"}

package/dist/utils/caches.d.ts

@@ -33,6 +33,7 @@ export declare class AsyncCache<D extends any[], T> {
         status: "ok";
     });
     readonly getOrWait: (key: D, cacheStrategy: CacheStrategy) => ReactPromise<T>;
+    readonly forceSetCachedValue: (key: D, value: T) => void;
     readonly refresh: (key: D) => Promise<T>;
     readonly invalidate: (key: D) => Promise<T>;
     readonly onChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
@@ -42,6 +43,7 @@ export declare class AsyncCache<D extends any[], T> {
 declare class AsyncValueCache<T> {
     private readonly _options;
     private _store;
+    private _pendingPromise;
     private _fetcher;
     private readonly _rateLimitOptions;
     private _subscriptionsCount;
@@ -72,6 +74,7 @@ declare class AsyncValueCache<T> {
     private _set;
     private _setAsync;
     private _refetch;
+    forceSetCachedValue(value: T): void;
     refresh(): Promise<T>;
     invalidate(): Promise<T>;
     onChange(callback: (value: T, oldValue: T | undefined) => void): {

package/dist/utils/caches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"caches.d.ts","sourceRoot":"","sources":["../../src/utils/caches.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAqD,MAAM,YAAY,CAAC;AAG/G;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAYzD;AAGD,KAAK,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,OAAO,CAAC;AAE3D,qBAAa,UAAU,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC;IAItC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgD;gBAGlD,QAAQ,EAAE,CAAC,YAAY,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACzC,QAAQ,GAAE;QACzB,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QAC5D,WAAW,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;KAC/C;IAKR,OAAO,CAAC,YAAY;IASpB,aAAa,CAAC,YAAY,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAelD,QAAQ,CAAC,gBAAgB,QAtBhB,CAAC,aAsBwD;IAClE,QAAQ,CAAC,WAAW,QAvBX,CAAC;;;;;;;;;;;;;;;;OAuB8C;IACxD,QAAQ,CAAC,SAAS,QAxBT,CAAC,mDAwB0C;IACpD,QAAQ,CAAC,OAAO,QAzBP,CAAC,gBAyBsC;IAChD,QAAQ,CAAC,UAAU,QA1BV,CAAC,gBA0B4C;IACtD,QAAQ,CAAC,QAAQ,QA3BR,CAAC;;MA2BwC;CACnD;AAED,cAAM,eAAe,CAAC,CAAC;IASnB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IACzE,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,cAAc,CAAsB;gBAG1C,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACR,QAAQ,GAAE;QACzB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QACpD,WAAW,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;KAC/C;IAgBR,gBAAgB,IAAI,OAAO;IAI3B,WAAW;;;;;;;;;;;;;;;;;IAIX,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,YAAY,CAAC,CAAC,CAAC;IASxD,OAAO,CAAC,IAAI;YAIE,SAAS;YAIT,QAAQ;IAahB,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;IAIrB,UAAU,IAAI,OAAO,CAAC,CAAC,CAAC;IAK9B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;CA0B7F"}
+{"version":3,"file":"caches.d.ts","sourceRoot":"","sources":["../../src/utils/caches.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAqD,MAAM,YAAY,CAAC;AAG/G;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAYzD;AAGD,KAAK,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,OAAO,CAAC;AAE3D,qBAAa,UAAU,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC;IAItC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgD;gBAGlD,QAAQ,EAAE,CAAC,YAAY,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACzC,QAAQ,GAAE;QACzB,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QAC5D,WAAW,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;KAC/C;IAKR,OAAO,CAAC,YAAY;IASpB,aAAa,CAAC,YAAY,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAelD,QAAQ,CAAC,gBAAgB,QAtBhB,CAAC,aAsBwD;IAClE,QAAQ,CAAC,WAAW,QAvBX,CAAC;;;;;;;;;;;;;;;;OAuB8C;IACxD,QAAQ,CAAC,SAAS,QAxBT,CAAC,mDAwB0C;IACpD,QAAQ,CAAC,mBAAmB,QAzBnB,CAAC,oBAyB8D;IACxE,QAAQ,CAAC,OAAO,QA1BP,CAAC,gBA0BsC;IAChD,QAAQ,CAAC,UAAU,QA3BV,CAAC,gBA2B4C;IACtD,QAAQ,CAAC,QAAQ,QA5BR,CAAC;;MA4BwC;CACnD;AAED,cAAM,eAAe,CAAC,CAAC;IAUnB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAT3B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IACzE,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,cAAc,CAAsB;gBAG1C,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACR,QAAQ,GAAE;QACzB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QACpD,WAAW,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;KAC/C;IAgBR,gBAAgB,IAAI,OAAO;IAI3B,WAAW;;;;;;;;;;;;;;;;;IAIX,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,YAAY,CAAC,CAAC,CAAC;IASxD,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,QAAQ;IAYhB,mBAAmB,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAI7B,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;IAIrB,UAAU,IAAI,OAAO,CAAC,CAAC,CAAC;IAM9B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;CA0B7F"}