@indietabletop/appkit 6.1.6 → 7.0.0-0

package/dist/async-op.d.ts

@@ -0,0 +1,101 @@
+type Falsy = null | undefined | false | 0 | 0n | "";
+type Truthy<T> = Exclude<T, Falsy>;
+interface Operation<SuccessValue, FailureValue> {
+    readonly type: "SUCCESS" | "FAILURE" | "PENDING";
+    readonly isPending: boolean;
+    readonly isSuccess: boolean;
+    readonly isFailure: boolean;
+    val: SuccessValue | FailureValue | null;
+    valueOrNull(): SuccessValue | null;
+    valueOrThrow(): SuccessValue;
+    hasTruthyValue(): boolean;
+    failureValueOrNull(): FailureValue | null;
+    failureValueOrThrow(): FailureValue;
+    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T | Failure<FailureValue> | Pending;
+    mapSuccess<MappedSuccess>(mappingFn: (value: SuccessValue) => MappedSuccess): Operation<MappedSuccess, FailureValue>;
+    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Operation<SuccessValue, MappedFailure>;
+    unpack<S, F, P>(mapS: (value: SuccessValue) => S, mapF: (failure: FailureValue) => F, mapP: () => P): S | F | P;
+    toJSON(): object;
+}
+export declare class Pending implements Operation<never, never> {
+    readonly type: "PENDING";
+    readonly isPending: true;
+    readonly isSuccess: false;
+    readonly isFailure: false;
+    val: null;
+    valueOrNull(): null;
+    valueOrThrow(): never;
+    hasTruthyValue(): false;
+    failureValueOrNull(): null;
+    failureValueOrThrow(): never;
+    flatMap(): Pending;
+    mapSuccess(): Pending;
+    mapFailure(): Pending;
+    unpack<S, F, P>(_mapS: (value: never) => S, _mapF: (failure: never) => F, mapP: () => P): S | F | P;
+    toJSON(): {
+        type: "PENDING";
+    };
+}
+export declare class Success<SuccessValue> implements Operation<SuccessValue, never> {
+    readonly type: "SUCCESS";
+    readonly isPending: false;
+    readonly isSuccess: true;
+    readonly isFailure: false;
+    readonly value: SuccessValue;
+    readonly val: SuccessValue;
+    constructor(value: SuccessValue);
+    valueOrNull(): SuccessValue;
+    valueOrThrow(): SuccessValue;
+    hasTruthyValue(): this is Success<Truthy<SuccessValue>>;
+    failureValueOrNull(): null;
+    failureValueOrThrow(): never;
+    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T;
+    mapSuccess<MappedValue>(mappingFn: (value: SuccessValue) => MappedValue): Success<MappedValue>;
+    mapFailure(): Success<SuccessValue>;
+    unpack<S, F, P>(mapS: (value: SuccessValue) => S, _mapF: (failure: never) => F, _mapP: () => P): S | F | P;
+    toJSON(): {
+        type: "SUCCESS";
+        value: SuccessValue;
+    };
+}
+export declare class Failure<FailureValue> implements Operation<never, FailureValue> {
+    readonly type: "FAILURE";
+    readonly isPending: false;
+    readonly isSuccess: false;
+    readonly isFailure: true;
+    readonly failure: FailureValue;
+    readonly val: FailureValue;
+    constructor(failure: FailureValue);
+    valueOrNull(): null;
+    valueOrThrow(): never;
+    hasTruthyValue(): false;
+    failureValueOrNull(): FailureValue;
+    failureValueOrThrow(): FailureValue;
+    flatMap(): Failure<FailureValue>;
+    mapSuccess(): Failure<FailureValue>;
+    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Failure<MappedFailure>;
+    unpack<S, F, P>(_mapS: (value: never) => S, mapF: (failure: FailureValue) => F, _mapP: () => P): S | F | P;
+    toJSON(): {
+        type: "FAILURE";
+        failure: FailureValue;
+    };
+}
+/**
+ * Folds multiple ops into a single op.
+ *
+ * To return a Success, all ops provided must be a Success. If any Failures are
+ * encountered, will return the first one found.
+ *
+ * If neither of these conditions is true, will return Pending.
+ *
+ * Note that if passed an empty array, will always return a Success (with an
+ * empty array as value). This mimics the semantics of many JS constructs, like
+ * Promise.all or Array.prototype.every.
+ */
+export declare function fold<Ops extends readonly AsyncOp<unknown, unknown>[] | []>(ops: Ops): AsyncOp<{
+    -readonly [Index in keyof Ops]: Ops[Index] extends AsyncOp<infer S, unknown> ? S : never;
+}, Ops[number] extends AsyncOp<unknown, infer F> ? F : never>;
+export declare function isAsyncOp(value: unknown): value is AsyncOp<unknown, unknown>;
+export type AsyncOp<SuccessValue, FailureValue> = Pending | Success<SuccessValue> | Failure<FailureValue>;
+export declare function fromTryCatch<T>(callback: () => T): Failure<unknown> | Success<T>;
+export {};

package/dist/atomic.css.d.ts

@@ -0,0 +1,6 @@
+export declare const textVariants: ((props: {
+    textAlign?: "center" | "end" | "start" | undefined;
+}) => string) & {
+    properties: Set<"textAlign">;
+};
+export type TextVariants = Parameters<typeof textVariants>[0];

package/{lib/caught-value.ts → dist/caught-value.d.ts}

@@ -12,14 +12,4 @@
  * if so, returns its message. If a string was caught, it returns that.
  * Otherwise, it returns "Unknown error".
  */
-export function caughtValueToString(value: unknown): string {
-  if (value instanceof Error) {
-    return value.message;
-  }
-
-  if (typeof value === "string") {
-    return value;
-  }
-
-  return "Unknown error.";
-}
+export declare function caughtValueToString(value: unknown): string;

package/{lib/class-names.ts → dist/class-names.d.ts}

@@ -1,22 +1,13 @@
 type Falsy = false | null | undefined;
-
 type PropsWithClassName = {
-  className?: ClassName;
+    className?: ClassName;
 };
-
 type ClassName = string | PropsWithClassName | Falsy;
-
 /**
  * Combines a list of strings or objects with className property into a single
  * string. Falsy values are ignored.
  */
-export function classNames(...classNames: ClassName[]) {
-  return classNames
-    .filter((cn) => !!cn)
-    .map((cn) => (typeof cn === "object" ? cn?.className : cn))
-    .join(" ");
-}
-
+export declare function classNames(...classNames: ClassName[]): string;
 /**
  * Given a list of strings or objects with the className property, returns an
  * object with className property and combined className. Falsy values will
@@ -25,9 +16,7 @@ export function classNames(...classNames: ClassName[]) {
  * @example
  * <h1 {...cx(props, 'heading', 'bold')}>Hello world!</h1>
  */
-
-export function cx(...cns: ClassName[]) {
-  return {
-    className: classNames(...cns),
-  };
-}
+export declare function cx(...cns: ClassName[]): {
+    className: string;
+};
+export {};

package/dist/client.d.ts

@@ -0,0 +1,424 @@
+import { FeatureUnlock, UserGameData } from '@indietabletop/types';
+import { Struct, Infer } from 'superstruct';
+import { Failure, Success } from './async-op.ts';
+import { CurrentUser, FailurePayload, SessionInfo } from './types.ts';
+export type GameCode = keyof UserGameData;
+export type ClientEventType = keyof ClientEventMap;
+type ClientEventMap = {
+    /**
+     * Triggered every time currentUser is received.
+     */
+    currentUser: {
+        currentUser: CurrentUser;
+    };
+    /**
+     * Triggered when new session info is received.
+     */
+    sessionInfo: {
+        sessionInfo: SessionInfo;
+    };
+    /**
+     * Triggered when token refresh fails due to a 401 error.
+     */
+    sessionExpired: undefined;
+};
+type ClientEventArgs<T extends ClientEventType> = ClientEventMap[T] extends undefined ? [type: T] : [type: T, detail: ClientEventMap[T]];
+export declare class ClientEvent<T extends keyof ClientEventMap> extends CustomEvent<ClientEventMap[T]> {
+    constructor(...args: ClientEventArgs<T>);
+}
+declare const logLevelToInt: {
+    off: number;
+    error: number;
+    warn: number;
+    info: number;
+};
+type LogLevel = keyof typeof logLevelToInt;
+export declare class IndieTabletopClient {
+    origin: string;
+    private refreshTokenPromise?;
+    private maxLogLevel;
+    private eventTarget;
+    constructor(props: {
+        apiOrigin: string;
+        /**
+         * Runs every time the current user is fetched from the API. Typically, this
+         * happens during login, signup, and when the current user is fetched.
+         */
+        onCurrentUser?: (currentUser: CurrentUser) => void;
+        /**
+         * Runs ever time new session info is fetched from the API. Typically, this
+         * happends during login, signup, and when tokens are refreshed.
+         */
+        onSessionInfo?: (sessionInfo: SessionInfo) => void;
+        /**
+         * Runs when token refresh is attempted, but fails due to 401 error.
+         */
+        onSessionExpired?: () => void;
+        /**
+         * Controls how much to log to the console.
+         *
+         * This is useful e.g. in Storybook, where errors are reported by MSW, and
+         * we don't want to pollute the console with duplicate data.
+         *
+         * @default 'info'
+         */
+        logLevel?: LogLevel;
+    });
+    private dispatchEvent;
+    addEventListener<T extends ClientEventType>(type: T, callback: (event: ClientEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<T extends ClientEventType>(type: T, callback: (event: ClientEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    private log;
+    private fetchWithTokenRefresh;
+    fetch<T, S>(path: string, struct: Struct<T, S>, init?: RequestInit & {
+        json?: object;
+    }): Promise<Success<Infer<Struct<T, S>>> | Failure<FailurePayload>>;
+    /**
+     * @deprecated Use the instance `fetch` method instead. Token refresh
+     * is determined dynamically by server response.
+     */
+    protected fetchWithAuth<T, S>(path: string, struct: Struct<T, S>, init?: RequestInit & {
+        json?: object;
+    }): Promise<Success<Infer<Struct<T, S>>> | Failure<FailurePayload>>;
+    login(payload: {
+        email: string;
+        password: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        currentUser: {
+            id: string;
+            email: string;
+            isVerified: boolean;
+            prefersScrollbarVisibility?: "ALWAYS" | undefined;
+        };
+        sessionInfo: {
+            createdTs: number;
+            expiresTs: number;
+        };
+    }>>;
+    userAgent(): Promise<Failure<FailurePayload> | Success<{
+        browser?: {
+            name?: string | undefined;
+            version?: string | undefined;
+            major?: string | undefined;
+        } | undefined;
+        device?: {
+            type?: string | undefined;
+            model?: string | undefined;
+            vendor?: string | undefined;
+        } | undefined;
+        engine?: {
+            name?: string | undefined;
+            version?: string | undefined;
+        } | undefined;
+        os?: {
+            name?: string | undefined;
+            version?: string | undefined;
+        } | undefined;
+    }>>;
+    logout(): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    join(payload: {
+        email: string;
+        password: string;
+        acceptedTos: boolean;
+        subscribedToNewsletter: boolean;
+    }): Promise<Failure<FailurePayload> | Success<{
+        currentUser: {
+            id: string;
+            email: string;
+            isVerified: boolean;
+            prefersScrollbarVisibility?: "ALWAYS" | undefined;
+        };
+        sessionInfo: {
+            createdTs: number;
+            expiresTs: number;
+        };
+        tokenId: string;
+    }>>;
+    /**
+     * Triggers token refresh process.
+     *
+     * Note that we do not want to perform multiple concurrent token refresh
+     * actions, as that will result in unnecessary 401s. For this reason, a
+     * reference to t
+     */
+    refreshTokens(): Promise<Success<{
+        sessionInfo: SessionInfo;
+    }> | Failure<FailurePayload>>;
+    requestPasswordReset(payload: {
+        email: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+        tokenId: string;
+    }>>;
+    checkPasswordResetCode(payload: {
+        tokenId: string;
+        code: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    setNewPassword(payload: {
+        tokenId: string;
+        code: string;
+        password: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    requestUserVerification(): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+        tokenId: string;
+    }>>;
+    verifyUser(payload: {
+        tokenId: string;
+        code: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    getSnapshot<T, S>(gameCode: string, snapshotId: string, struct: Struct<T, S>): Promise<Failure<FailurePayload> | Success<T>>;
+    createSnapshot(gameCode: string, payload: object): Promise<Failure<FailurePayload> | Success<{
+        snapshotId: string;
+    }>>;
+    getCurrentUser(): Promise<Failure<FailurePayload> | Success<{
+        id: string;
+        email: string;
+        isVerified: boolean;
+        prefersScrollbarVisibility?: "ALWAYS" | undefined;
+    }>>;
+    getRuleset(game: string, version: string): Promise<Success<unknown> | Failure<FailurePayload>>;
+    /**
+     * Uploads a file given S3 presigned config.
+     */
+    uploadFile(file: File, presigned: {
+        url: string;
+        key: string;
+        fields: Record<string, string>;
+    }): Promise<Success<string> | Failure<FailurePayload>>;
+    redeemPledge(campaignCode: string, id: string): Promise<Failure<FailurePayload> | Success<{
+        id: string;
+        email: string;
+        downloadUrl: string;
+        downloadUrlExpiresTs: number;
+        contactSubscribed: boolean;
+    }>>;
+    subscribeToNewsletterByPledgeId(newsletterCode: string, pledgeId: string): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    subscribeToNewsletterByEmail(newsletterCode: string, email: string): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+        tokenId: string;
+    }>>;
+    confirmNewsletterSignup(newsletterCode: string, tokenId: string, plaintextCode: string): Promise<Failure<FailurePayload> | Success<{
+        message: string;
+    }>>;
+    pullUserData(props: {
+        sinceTs: number | null;
+        include: GameCode | GameCode[];
+        expectCurrentUserId: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        spacegits?: {
+            gangs?: ({
+                id: string;
+                name: string;
+                updatedTs: number;
+                deleted: true;
+            } | {
+                id: string;
+                description: string;
+                name: string;
+                updatedTs: number;
+                deleted: false;
+                gits: {
+                    id: string;
+                    type: {
+                        id: string;
+                    };
+                    name: string;
+                    weapons: {
+                        id: string;
+                        count: number;
+                    }[];
+                    gear: {
+                        id: string;
+                    }[];
+                    offenses: {
+                        id: string;
+                    }[];
+                    treatments: {
+                        id: string;
+                        locationId: string;
+                    }[];
+                }[];
+                vehicles: {
+                    id: string;
+                    type: {
+                        id: string;
+                    };
+                    name: string;
+                    mods: {
+                        id: string;
+                    }[];
+                    repairs: {
+                        id: string;
+                        locationId: string;
+                    }[];
+                    weapons: {
+                        id: string;
+                        count: number;
+                        placement: "FIXED" | "PINTLE_MOUNTED";
+                    }[];
+                }[];
+                buildMode: "A_LA_CARTE" | "CHEFS_RECOMMENDATION" | "CHAOS_MODE" | "SANDBOX";
+                snapshotId: string | null;
+                faction: {
+                    id: string;
+                } | null;
+                createdTs: number;
+                rulesetVersion: string;
+            })[] | undefined;
+            settings?: {
+                id: "PRINT_SETTINGS";
+                updatedTs: number;
+                printWeaponRules: boolean;
+                printGitRules: boolean;
+                printVehicleRules: boolean;
+            }[] | undefined;
+        } | undefined;
+    }>>;
+    pushUserData(props: {
+        currentSyncTs: number;
+        pullSinceTs: number | null;
+        data: UserGameData;
+        expectCurrentUserId: string | null | undefined;
+    }): Promise<Failure<FailurePayload> | Success<{
+        spacegits?: {
+            gangs?: ({
+                id: string;
+                name: string;
+                updatedTs: number;
+                deleted: true;
+            } | {
+                id: string;
+                description: string;
+                name: string;
+                updatedTs: number;
+                deleted: false;
+                gits: {
+                    id: string;
+                    type: {
+                        id: string;
+                    };
+                    name: string;
+                    weapons: {
+                        id: string;
+                        count: number;
+                    }[];
+                    gear: {
+                        id: string;
+                    }[];
+                    offenses: {
+                        id: string;
+                    }[];
+                    treatments: {
+                        id: string;
+                        locationId: string;
+                    }[];
+                }[];
+                vehicles: {
+                    id: string;
+                    type: {
+                        id: string;
+                    };
+                    name: string;
+                    mods: {
+                        id: string;
+                    }[];
+                    repairs: {
+                        id: string;
+                        locationId: string;
+                    }[];
+                    weapons: {
+                        id: string;
+                        count: number;
+                        placement: "FIXED" | "PINTLE_MOUNTED";
+                    }[];
+                }[];
+                buildMode: "A_LA_CARTE" | "CHEFS_RECOMMENDATION" | "CHAOS_MODE" | "SANDBOX";
+                snapshotId: string | null;
+                faction: {
+                    id: string;
+                } | null;
+                createdTs: number;
+                rulesetVersion: string;
+            })[] | undefined;
+            settings?: {
+                id: "PRINT_SETTINGS";
+                updatedTs: number;
+                printWeaponRules: boolean;
+                printGitRules: boolean;
+                printVehicleRules: boolean;
+            }[] | undefined;
+        } | undefined;
+    }>>;
+    getUnlocks<T extends FeatureUnlock["gameCode"]>(gameCode: T): Promise<Failure<FailurePayload> | Success<{
+        unlocks: (Extract<{
+            feature: "SPACE_GITS_CORE_RULES";
+            gameCode: "spacegits";
+        }, {
+            gameCode: T;
+        }> | Extract<{
+            feature: "GREATHELM_CORE_RULES";
+            gameCode: "greathelm";
+        }, {
+            gameCode: T;
+        }>)[];
+    }>>;
+    getOwnedProduct(productCode: string): Promise<Failure<FailurePayload> | Success<{
+        id: string;
+        type: "DIGITAL";
+        name: string;
+        code: string;
+        downloadUrl?: string | undefined;
+        downloadUrlExpiresTs?: number | undefined;
+        unlocks?: ({
+            feature: "SPACE_GITS_CORE_RULES";
+            gameCode: "spacegits";
+        } | {
+            feature: "GREATHELM_CORE_RULES";
+            gameCode: "greathelm";
+        })[] | undefined;
+        downloadFileSize?: string | undefined;
+        downloadFileVersion?: string | undefined;
+    }>>;
+    startCheckoutSession(payload: {
+        products: {
+            code: string;
+            quantity: number;
+        }[];
+        successUrl: string;
+        cancelUrl: string;
+    }): Promise<Failure<FailurePayload> | Success<{
+        redirectTo: string;
+    }>>;
+    getCheckoutSession(sessionId: string): Promise<Failure<FailurePayload> | Success<{
+        status: string;
+        orderRef: string;
+        products: {
+            id: string;
+            type: "DIGITAL";
+            name: string;
+            code: string;
+            downloadUrl?: string | undefined;
+            downloadUrlExpiresTs?: number | undefined;
+            unlocks?: ({
+                feature: "SPACE_GITS_CORE_RULES";
+                gameCode: "spacegits";
+            } | {
+                feature: "GREATHELM_CORE_RULES";
+                gameCode: "greathelm";
+            })[] | undefined;
+            downloadFileSize?: string | undefined;
+            downloadFileVersion?: string | undefined;
+        }[];
+    }>>;
+}
+export {};

package/dist/common.css.d.ts

@@ -0,0 +1,5 @@
+export declare const itcSymbol: string;
+export declare const manofa: string;
+export declare const minion: string;
+export declare const itcCard: string;
+export declare const interactiveText: string;

package/dist/copyrightRange.d.ts

@@ -0,0 +1 @@
+export declare function copyrightRange(yearSince: number): string;

package/dist/copyrightRange.test.d.ts

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

package/dist/createSafeStorage.d.ts

@@ -0,0 +1,34 @@
+import { Struct } from 'superstruct';
+type AnyStruct = Struct<any, any>;
+type StructsConfig = Record<string, AnyStruct>;
+type SafeStorage<T extends Record<string, AnyStruct>> = ReturnType<typeof createSafeStorage<T>>;
+export type SafeStorageKey<T extends SafeStorage<StructsConfig>> = ReturnType<T["keys"]>[number];
+type StructValue<T> = T extends Struct<infer V> ? V : never;
+/**
+ * Creates an object with an interface similar to localStorage, but that
+ * enforces that values are parsed and validated before being retrieved,
+ * stringified when being set, and that both keys and values typecheck.
+ *
+ * @example
+ * ```ts
+ * const safeStorage = createSafeStorage({
+ *   currentUser: currentUser(),
+ *   sessionInfo: sessionInfo(),
+ *   lastSuccessfulSyncTs: number(),
+ * });
+ *
+ * safeStorage.getItem("currentUser") // Will be valid current user or `null`
+ * safeStorage.setItem("currentUser", { ... }) // Typechecked key and value
+ * safeStorage.removeItem("currentUser") // Typechecked key
+ * safeStorage.clear() // Removes all "owned" keys
+ *
+ * ```
+ */
+export declare function createSafeStorage<T extends StructsConfig>(structs: T): {
+    getItem<K extends keyof T & string>(key: K): StructValue<T[K]> | null;
+    setItem<K extends keyof T & string>(key: K, value: StructValue<T[K]>): void;
+    removeItem(key: keyof T & string): void;
+    clear(): void;
+    keys(): (keyof T)[];
+};
+export {};

package/dist/failureMessages.d.ts

@@ -0,0 +1,20 @@
+import { FailurePayload } from './types.ts';
+export type FetchFailureAction = {
+    type: "LINK";
+    href: string;
+    label: string;
+} | {
+    type: "RELOAD" | "REFETCH";
+    label: string;
+};
+export type FetchFailureMessages = {
+    title: string;
+    description: string;
+    action: FetchFailureAction;
+};
+export declare const getFetchFailureMessages: (failure: FailurePayload, overrides?: Record<number, Partial<FetchFailureMessages>>) => FetchFailureMessages;
+export declare const getSubmitFailureMessage: (failure: FailurePayload, overrides?: Record<number, string>) => string;
+/**
+ * @deprecated Use {@link getSubmitFailureMessage} instead.
+ */
+export declare function toKnownFailureMessage(failure: FailurePayload): string;

package/dist/failureMessages.test.d.ts

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

package/dist/form/FormSubmitButton.d.ts

@@ -0,0 +1,17 @@
+import { FormSubmitProps } from '@ariakit/react';
+import { ReactNode } from 'react';
+export type FormSubmitButtonProps = FormSubmitProps & {
+    children: ReactNode;
+    loading: ReactNode;
+};
+/**
+ * Renders Ariakit FormSubmit component.
+ *
+ * It's main responsibility is to render the loading component (provided via
+ * the `loading` prop) when the form is in the submitting state. This component
+ * will be rendered over the usual content of the button, which will be hidden
+ * as long as the form is submitting.
+ *
+ * @remarks Must be rendered within Ariakit Form Context.
+ */
+export declare function FormSubmitButton(props: FormSubmitButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/form/SubmitErrorAlert.d.ts

@@ -0,0 +1,5 @@
+export type SubmitErrorMessageProps = {
+    name: string;
+    className?: string;
+};
+export declare function SubmitErrorAlert(props: SubmitErrorMessageProps): import("react/jsx-runtime").JSX.Element;

package/dist/form/style.css.d.ts

@@ -0,0 +1,3 @@
+export declare const submitErrorAlert: {
+    container: string;
+};