@forgerock/login-widget 1.0.0-beta.1 → 1.0.0-beta.10

package/{modal.d.ts → index.d.ts}

@@ -1,13 +1,3 @@
-interface StringDict<T> {
-    [name: string]: T;
-}
-interface Tokens {
-    accessToken: string;
-    idToken?: string;
-    refreshToken?: string;
-    tokenExpiry?: number;
-}
-
 declare enum ActionTypes {
     Authenticate = "AUTHENTICATE",
     Authorize = "AUTHORIZE",
@@ -21,6 +11,16 @@ declare enum ActionTypes {
     UserInfo = "USER_INFO"
 }
 
+interface StringDict<T> {
+    [name: string]: T;
+}
+interface Tokens {
+    accessToken: string;
+    idToken?: string;
+    refreshToken?: string;
+    tokenExpiry?: number;
+}
+
 /**
  * Types of callbacks directly supported by the SDK.
  */
@@ -225,15 +225,175 @@ interface TokenStoreObject {
 }
 
 /**
- * Tokens returned after successful authentication.
+ * An event-handling function.
  */
-interface OAuth2Tokens {
-    accessToken: string;
-    idToken?: string;
-    refreshToken?: string;
-    tokenExpiry?: number;
+declare type Listener = (e: FREvent) => void;
+interface FREvent {
+    type: string;
+}
+
+/**
+ * Event dispatcher for subscribing and publishing categorized events.
+ */
+declare class Dispatcher {
+    private callbacks;
+    /**
+     * Subscribes to an event type.
+     *
+     * @param type The event type
+     * @param listener The function to subscribe to events of this type
+     */
+    addEventListener(type: string, listener: Listener): void;
+    /**
+     * Unsubscribes from an event type.
+     *
+     * @param type The event type
+     * @param listener The function to unsubscribe from events of this type
+     */
+    removeEventListener(type: string, listener: Listener): void;
+    /**
+     * Unsubscribes all listener functions to a single event type or all event types.
+     *
+     * @param type The event type, or all event types if not specified
+     */
+    clearEventListeners(type?: string): void;
+    /**
+     * Publishes an event.
+     *
+     * @param event The event object to publish
+     */
+    dispatchEvent<T extends FREvent>(event: T): void;
+}
+
+/**
+ * Types of steps returned by the authentication tree.
+ */
+declare enum StepType {
+    LoginFailure = "LoginFailure",
+    LoginSuccess = "LoginSuccess",
+    Step = "Step"
+}
+
+/**
+ * Base interface for all types of authentication step responses.
+ */
+interface AuthResponse {
+    type: StepType;
+}
+/**
+ * Represents details of a failure in an authentication step.
+ */
+interface FailureDetail {
+    failureUrl?: string;
+}
+
+/**
+ * Represents a single step of an authentication tree.
+ */
+declare class FRStep implements AuthResponse {
+    payload: Step;
+    /**
+     * The type of step.
+     */
+    readonly type = StepType.Step;
+    /**
+     * The callbacks contained in this step.
+     */
+    callbacks: FRCallback[];
+    /**
+     * @param payload The raw payload returned by OpenAM
+     * @param callbackFactory A function that returns am implementation of FRCallback
+     */
+    constructor(payload: Step, callbackFactory?: FRCallbackFactory);
+    /**
+     * Gets the first callback of the specified type in this step.
+     *
+     * @param type The type of callback to find.
+     */
+    getCallbackOfType<T extends FRCallback>(type: CallbackType): T;
+    /**
+     * Gets all callbacks of the specified type in this step.
+     *
+     * @param type The type of callback to find.
+     */
+    getCallbacksOfType<T extends FRCallback>(type: CallbackType): T[];
+    /**
+     * Sets the value of the first callback of the specified type in this step.
+     *
+     * @param type The type of callback to find.
+     * @param value The value to set for the callback.
+     */
+    setCallbackValue(type: CallbackType, value: unknown): void;
+    /**
+     * Gets the step's description.
+     */
+    getDescription(): string | undefined;
+    /**
+     * Gets the step's header.
+     */
+    getHeader(): string | undefined;
+    /**
+     * Gets the step's stage.
+     */
+    getStage(): string | undefined;
+    private convertCallbacks;
+}
+
+declare type HandleStep = (step: FRStep) => Promise<FRStep>;
+/**
+ * Options to use when making an HTTP call.
+ */
+interface HttpClientRequestOptions {
+    bypassAuthentication?: boolean;
+    authorization?: {
+        config?: ConfigOptions;
+        handleStep: HandleStep;
+        idToken?: string;
+        txnID?: string;
+    };
+    init: RequestInit;
+    requiresNewToken?: RequiresNewTokenFn;
+    timeout: number;
+    url: string;
 }
+/**
+ * A function that determines whether a new token is required based on a HTTP response.
+ */
+declare type RequiresNewTokenFn = (res: Response) => boolean;
 
+/**
+ * HTTP client that includes bearer token injection and refresh.
+ * This module also supports authorization for policy protected endpoints.
+ *
+ * Example:
+ *
+ * ```js
+ * return forgerock.HttpClient.request({
+ *   url: `https://example.com/protected/resource`,
+ *   init: {
+ *     method: 'GET',
+ *     credentials: 'include',
+ *   },
+ *   authorization: {
+ *     handleStep: async (step) => {
+ *       step.getCallbackOfType('PasswordCallback').setPassword(pw);
+ *       return Promise.resolve(step);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare abstract class HttpClient extends Dispatcher {
+    /**
+     * Makes a request using the specified options.
+     *
+     * @param options The options to use when making the request
+     */
+    static request(options: HttpClientRequestOptions): Promise<Response>;
+    private static setAuthHeaders;
+    private static stepIterator;
+    private static _request;
+}
 
 declare function noop(): void;
 
@@ -392,6 +552,37 @@ declare class SvelteComponentTyped<Props extends Record<string, any> = any, Even
     constructor(options: ComponentConstructorOptions<Props>);
 }
 
+/** Callback to inform of a value updates. */
+declare type Subscriber<T> = (value: T) => void;
+/** Unsubscribes from value updates. */
+declare type Unsubscriber = () => void;
+/** Callback to update a value. */
+declare type Updater<T> = (value: T) => T;
+/** Cleanup logic callback. */
+declare type Invalidator<T> = (value?: T) => void;
+/** Readable interface for subscribing. */
+interface Readable<T> {
+    /**
+     * Subscribe on value changes.
+     * @param run subscription callback
+     * @param invalidate cleanup callback
+     */
+    subscribe(this: void, run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+/** Writable interface for both updating and subscribing. */
+interface Writable<T> extends Readable<T> {
+    /**
+     * Set value and inform subscribers.
+     * @param value to set
+     */
+    set(this: void, value: T): void;
+    /**
+     * Update value using callback and inform subscribers.
+     * @param updater callback
+     */
+    update(this: void, updater: Updater<T>): void;
+}
+
 interface MessageCreator {
     [key: string]: (propertyName: string, params?: {
         [key: string]: unknown;
@@ -402,28 +593,6 @@ interface ProcessedPropertyError {
     messages: string[];
 }
 
-/**
- * Types of steps returned by the authentication tree.
- */
-declare enum StepType {
-    LoginFailure = "LoginFailure",
-    LoginSuccess = "LoginSuccess",
-    Step = "Step"
-}
-
-/**
- * Base interface for all types of authentication step responses.
- */
-interface AuthResponse {
-    type: StepType;
-}
-/**
- * Represents details of a failure in an authentication step.
- */
-interface FailureDetail {
-    failureUrl?: string;
-}
-
 declare class FRLoginFailure implements AuthResponse {
     payload: Step;
     /**
@@ -481,78 +650,14 @@ declare class FRLoginSuccess implements AuthResponse {
 }
 
 /**
- * Represents a single step of an authentication tree.
- */
-declare class FRStep implements AuthResponse {
-    payload: Step;
-    /**
-     * The type of step.
-     */
-    readonly type = StepType.Step;
-    /**
-     * The callbacks contained in this step.
-     */
-    callbacks: FRCallback[];
-    /**
-     * @param payload The raw payload returned by OpenAM
-     * @param callbackFactory A function that returns am implementation of FRCallback
-     */
-    constructor(payload: Step, callbackFactory?: FRCallbackFactory);
-    /**
-     * Gets the first callback of the specified type in this step.
-     *
-     * @param type The type of callback to find.
-     */
-    getCallbackOfType<T extends FRCallback>(type: CallbackType): T;
-    /**
-     * Gets all callbacks of the specified type in this step.
-     *
-     * @param type The type of callback to find.
-     */
-    getCallbacksOfType<T extends FRCallback>(type: CallbackType): T[];
-    /**
-     * Sets the value of the first callback of the specified type in this step.
-     *
-     * @param type The type of callback to find.
-     * @param value The value to set for the callback.
-     */
-    setCallbackValue(type: CallbackType, value: unknown): void;
-    /**
-     * Gets the step's description.
-     */
-    getDescription(): string | undefined;
-    /**
-     * Gets the step's header.
-     */
-    getHeader(): string | undefined;
-    /**
-     * Gets the step's stage.
-     */
-    getStage(): string | undefined;
-    private convertCallbacks;
-}
-
-declare type HandleStep = (step: FRStep) => Promise<FRStep>;
-/**
- * Options to use when making an HTTP call.
+ * Tokens returned after successful authentication.
  */
-interface HttpClientRequestOptions {
-    bypassAuthentication?: boolean;
-    authorization?: {
-        config?: ConfigOptions;
-        handleStep: HandleStep;
-        idToken?: string;
-        txnID?: string;
-    };
-    init: RequestInit;
-    requiresNewToken?: RequiresNewTokenFn;
-    timeout: number;
-    url: string;
+interface OAuth2Tokens {
+    accessToken: string;
+    idToken?: string;
+    refreshToken?: string;
+    tokenExpiry?: number;
 }
-/**
- * A function that determines whether a new token is required based on a HTTP response.
- */
-declare type RequiresNewTokenFn = (res: Response) => boolean;
 
 interface GetTokensOptions extends ConfigOptions {
     forceRenew?: boolean;
@@ -562,6 +667,38 @@ interface GetTokensOptions extends ConfigOptions {
 
 type Maybe<T> = T | null | undefined;
 
+interface UserStore extends Pick<Writable<UserStoreValue>, 'subscribe'> {
+    get: (getOptions?: ConfigOptions) => void;
+    reset: () => void;
+}
+interface UserStoreValue {
+    completed: boolean;
+    error: Maybe<{
+        code?: Maybe<number>;
+        message: Maybe<string>;
+        troubleshoot: Maybe<string>;
+    }>;
+    loading: boolean;
+    successful: boolean;
+    response: unknown;
+}
+
+interface OAuthStore extends Pick<Writable<OAuthTokenStoreValue>, 'subscribe'> {
+    get: (getOptions?: GetTokensOptions) => void;
+    reset: () => void;
+}
+interface OAuthTokenStoreValue {
+    completed: boolean;
+    error: Maybe<{
+        code?: Maybe<number>;
+        message: Maybe<string>;
+        troubleshoot: Maybe<string>;
+    }>;
+    loading: boolean;
+    successful: boolean;
+    response: Maybe<OAuth2Tokens> | void;
+}
+
 interface CallbackMetadata {
     derived: {
         canForceUserInputOptionality: boolean;
@@ -573,12 +710,21 @@ interface CallbackMetadata {
     idx: number;
     platform?: Record<string, unknown>;
 }
+interface JourneyStore extends Pick<Writable<JourneyStoreValue>, 'subscribe'> {
+    next: (prevStep?: StepTypes, nextOptions?: StepOptions) => void;
+    pop: () => void;
+    push: (changeOptions: StepOptions) => void;
+    reset: () => void;
+    resume: (url: string, resumeOptions?: StepOptions) => void;
+    start: (startOptions?: StepOptions) => void;
+}
 interface JourneyStoreValue {
     completed: boolean;
     error: Maybe<{
         code: Maybe<number>;
         message: Maybe<string>;
         step: Maybe<Step>;
+        troubleshoot: Maybe<string>;
     }>;
     loading: boolean;
     metadata: {
@@ -601,45 +747,11 @@ interface StepMetadata {
 }
 type StepTypes = FRStep | FRLoginSuccess | FRLoginFailure | null;
 
-interface OAuthTokenStoreValue {
-    completed: boolean;
-    error: Maybe<{
-        code?: Maybe<number>;
-        message: Maybe<string>;
-    }>;
-    loading: boolean;
-    successful: boolean;
-    response: Maybe<OAuth2Tokens> | void;
-}
-
-interface UserStoreValue {
-    completed: boolean;
-    error: Maybe<{
-        code?: Maybe<number>;
-        message: Maybe<string>;
-    }>;
-    loading: boolean;
-    successful: boolean;
-    response: unknown;
-}
-
-interface Response$1 {
-    journey?: JourneyStoreValue;
-    oauth?: OAuthTokenStoreValue;
-    user?: UserStoreValue;
-}
-interface JourneyOptions {
-    config?: StepOptions;
-    journey?: string;
-    oauth?: boolean;
-    resumeUrl?: string;
-    user?: boolean;
-}
-
-declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;
 
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+    export type isAny<T> = 0 extends 1 & T ? true : false;
     export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
     export function assertIs<T>(_arg: T): void;
     export function assertNever(_x: never): never;
@@ -651,16 +763,36 @@ declare namespace util {
     export const objectValues: (obj: any) => any[];
     export const objectKeys: ObjectConstructor["keys"];
     export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-    export type identity<T> = T;
-    export type flatten<T> = identity<{
-        [k in keyof T]: T[k];
-    }>;
+    export type identity<T> = objectUtil.identity<T>;
+    export type flatten<T> = objectUtil.flatten<T>;
     export type noUndefined<T> = T extends undefined ? never : T;
     export const isInteger: NumberConstructor["isInteger"];
     export function joinValues<T extends any[]>(array: T, separator?: string): string;
     export const jsonStringifyReplacer: (_: string, value: any) => any;
     export {};
 }
+declare namespace objectUtil {
+    export type MergeShapes<U, V> = {
+        [k in Exclude<keyof U, keyof V>]: U[k];
+    } & V;
+    type requiredKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? never : k;
+    }[keyof T];
+    export type addQuestionMarks<T extends object, R extends keyof T = requiredKeys<T>> = Pick<Required<T>, R> & Partial<T>;
+    export type identity<T> = T;
+    export type flatten<T> = identity<{
+        [k in keyof T]: T[k];
+    }>;
+    export type noNeverKeys<T> = {
+        [k in keyof T]: [T[k]] extends [never] ? never : k;
+    }[keyof T];
+    export type noNever<T> = identity<{
+        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
+    }>;
+    export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+    export type extendShape<A, B> = flatten<Omit<A, keyof B> & B>;
+    export {};
+}
 declare const ZodParsedType: {
     function: "function";
     number: "number";
@@ -708,6 +840,7 @@ declare const ZodIssueCode: {
     too_big: "too_big";
     invalid_intersection_types: "invalid_intersection_types";
     not_multiple_of: "not_multiple_of";
+    not_finite: "not_finite";
 };
 declare type ZodIssueCode = keyof typeof ZodIssueCode;
 declare type ZodIssueBase = {
@@ -722,6 +855,7 @@ interface ZodInvalidTypeIssue extends ZodIssueBase {
 interface ZodInvalidLiteralIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_literal;
     expected: unknown;
+    received: unknown;
 }
 interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.unrecognized_keys;
@@ -751,7 +885,10 @@ interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
 interface ZodInvalidDateIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_date;
 }
-declare type StringValidation = "email" | "url" | "uuid" | "regex" | "cuid" | {
+declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
+    includes: string;
+    position?: number;
+} | {
     startsWith: string;
 } | {
     endsWith: string;
@@ -762,22 +899,27 @@ interface ZodInvalidStringIssue extends ZodIssueBase {
 }
 interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
-    minimum: number;
+    minimum: number | bigint;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set" | "date";
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
 }
 interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
-    maximum: number;
+    maximum: number | bigint;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set" | "date";
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
 }
 interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;
 }
 interface ZodNotMultipleOfIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.not_multiple_of;
-    multipleOf: number;
+    multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
 }
 interface ZodCustomIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.custom;
@@ -785,19 +927,21 @@ interface ZodCustomIssue extends ZodIssueBase {
         [k: string]: any;
     };
 }
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 declare type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean;
     message: string;
 };
-declare type ZodFormattedError<T, U = string> = {
-    _errors: U[];
-} & (T extends [any, ...any[]] ? {
+declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
 } : T extends any[] ? {
     [k: number]: ZodFormattedError<T[number]>;
 } : T extends object ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
-} : unknown);
+} : unknown;
+declare type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
 declare class ZodError<T = any> extends Error {
     issues: ZodIssue[];
     get errors(): ZodIssue[];
@@ -897,20 +1041,16 @@ declare namespace errorUtil {
     type ErrMessage = string | {
         message?: string;
     };
-    const errToObj: (message?: string | {
-        message?: string | undefined;
-    } | undefined) => {
+    const errToObj: (message?: ErrMessage | undefined) => {
         message?: string | undefined;
     };
-    const toString: (message?: string | {
-        message?: string | undefined;
-    } | undefined) => string | undefined;
+    const toString: (message?: ErrMessage | undefined) => string | undefined;
 }
 
 declare namespace partialUtil {
-    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<infer Shape, infer Params, infer Catchall> ? ZodObject<{
-        [k in keyof Shape]: ZodOptional<DeepPartial<Shape[k]>>;
-    }, Params, Catchall> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
+    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
+        [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
+    }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
         [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
     } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
 }
@@ -924,6 +1064,9 @@ declare type ZodRawShape = {
 };
 declare type ZodTypeAny = ZodType<any, any, any>;
 declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+declare type input<T extends ZodType<any, any, any>> = T["_input"];
+declare type output<T extends ZodType<any, any, any>> = T["_output"];
+
 declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
     errorMap?: ZodErrorMap;
@@ -963,18 +1106,18 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
     parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-    /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
     refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
     _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-    superRefine: (refinement: RefinementEffect<Output>["refinement"]) => ZodEffects<this, Output, Input>;
+    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
     constructor(def: Def);
     optional(): ZodOptional<this>;
     nullable(): ZodNullable<this>;
-    nullish(): ZodNullable<ZodOptional<this>>;
+    nullish(): ZodOptional<ZodNullable<this>>;
     array(): ZodArray<this>;
     promise(): ZodPromise<this>;
     or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
@@ -982,11 +1125,18 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
     default(def: util.noUndefined<Input>): ZodDefault<this>;
     default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-    brand<B extends string | number | symbol>(): ZodBranded<this, B>;
+    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+    catch(def: Output): ZodCatch<this>;
+    catch(def: (ctx: {
+        error: ZodError;
+        input: Input;
+    }) => Output): ZodCatch<this>;
     describe(description: string): this;
+    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
     isOptional(): boolean;
     isNullable(): boolean;
 }
+declare type IpVersion = "v4" | "v6";
 declare type ZodStringCheck = {
     kind: "min";
     value: number;
@@ -995,18 +1145,36 @@ declare type ZodStringCheck = {
     kind: "max";
     value: number;
     message?: string;
+} | {
+    kind: "length";
+    value: number;
+    message?: string;
 } | {
     kind: "email";
     message?: string;
 } | {
     kind: "url";
     message?: string;
+} | {
+    kind: "emoji";
+    message?: string;
 } | {
     kind: "uuid";
     message?: string;
 } | {
     kind: "cuid";
     message?: string;
+} | {
+    kind: "includes";
+    value: string;
+    position?: number;
+    message?: string;
+} | {
+    kind: "cuid2";
+    message?: string;
+} | {
+    kind: "ulid";
+    message?: string;
 } | {
     kind: "startsWith";
     value: string;
@@ -1022,42 +1190,80 @@ declare type ZodStringCheck = {
 } | {
     kind: "trim";
     message?: string;
+} | {
+    kind: "toLowerCase";
+    message?: string;
+} | {
+    kind: "toUpperCase";
+    message?: string;
+} | {
+    kind: "datetime";
+    offset: boolean;
+    precision: number | null;
+    message?: string;
+} | {
+    kind: "ip";
+    version?: IpVersion;
+    message?: string;
 };
 interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
     typeName: ZodFirstPartyTypeKind.ZodString;
+    coerce: boolean;
 }
 declare class ZodString extends ZodType<string, ZodStringDef> {
     _parse(input: ParseInput): ParseReturnType<string>;
-    protected _regex: (regex: RegExp, validation: StringValidation, message?: string | {
-        message?: string | undefined;
-    } | undefined) => ZodEffects<this, string, string>;
+    protected _regex: (regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage | undefined) => ZodEffects<this, string, string>;
     _addCheck(check: ZodStringCheck): ZodString;
     email(message?: errorUtil.ErrMessage): ZodString;
     url(message?: errorUtil.ErrMessage): ZodString;
+    emoji(message?: errorUtil.ErrMessage): ZodString;
     uuid(message?: errorUtil.ErrMessage): ZodString;
     cuid(message?: errorUtil.ErrMessage): ZodString;
+    cuid2(message?: errorUtil.ErrMessage): ZodString;
+    ulid(message?: errorUtil.ErrMessage): ZodString;
+    ip(options?: string | {
+        version?: "v4" | "v6";
+        message?: string;
+    }): ZodString;
+    datetime(options?: string | {
+        message?: string | undefined;
+        precision?: number | null;
+        offset?: boolean;
+    }): ZodString;
     regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+    includes(value: string, options?: {
+        message?: string;
+        position?: number;
+    }): ZodString;
     startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
     endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
     min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
     max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
     length(len: number, message?: errorUtil.ErrMessage): ZodString;
-    /**
-     * @deprecated Use z.string().min(1) instead.
-     * @see {@link ZodString.min}
-     */
-    nonempty: (message?: string | {
-        message?: string | undefined;
-    } | undefined) => ZodString;
+    nonempty: (message?: errorUtil.ErrMessage | undefined) => ZodString;
     trim: () => ZodString;
+    toLowerCase: () => ZodString;
+    toUpperCase: () => ZodString;
+    get isDatetime(): boolean;
     get isEmail(): boolean;
     get isURL(): boolean;
+    get isEmoji(): boolean;
     get isUUID(): boolean;
     get isCUID(): boolean;
+    get isCUID2(): boolean;
+    get isULID(): boolean;
+    get isIP(): boolean;
     get minLength(): number | null;
     get maxLength(): number | null;
-    static create: (params?: RawCreateParams) => ZodString;
+    static create: (params?: ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: true | undefined;
+    }) | undefined) => ZodString;
 }
 declare type ZodNumberCheck = {
     kind: "min";
@@ -1076,23 +1282,30 @@ declare type ZodNumberCheck = {
     kind: "multipleOf";
     value: number;
     message?: string;
+} | {
+    kind: "finite";
+    message?: string;
 };
 interface ZodNumberDef extends ZodTypeDef {
     checks: ZodNumberCheck[];
     typeName: ZodFirstPartyTypeKind.ZodNumber;
+    coerce: boolean;
 }
 declare class ZodNumber extends ZodType<number, ZodNumberDef> {
     _parse(input: ParseInput): ParseReturnType<number>;
-    static create: (params?: RawCreateParams) => ZodNumber;
+    static create: (params?: ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => ZodNumber;
     gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    min: (value: number, message?: string | {
-        message?: string | undefined;
-    } | undefined) => ZodNumber;
+    min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
     gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
     lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    max: (value: number, message?: string | {
-        message?: string | undefined;
-    } | undefined) => ZodNumber;
+    max: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
     lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
     protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
     _addCheck(check: ZodNumberCheck): ZodNumber;
@@ -1102,12 +1315,28 @@ declare class ZodNumber extends ZodType<number, ZodNumberDef> {
     nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
     nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
     multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    step: (value: number, message?: string | {
-        message?: string | undefined;
-    } | undefined) => ZodNumber;
+    step: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+    finite(message?: errorUtil.ErrMessage): ZodNumber;
+    safe(message?: errorUtil.ErrMessage): ZodNumber;
     get minValue(): number | null;
     get maxValue(): number | null;
     get isInt(): boolean;
+    get isFinite(): boolean;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodBoolean;
+    coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
+    _parse(input: ParseInput): ParseReturnType<boolean>;
+    static create: (params?: ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => ZodBoolean;
 }
 interface ZodUnknownDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodUnknown;
@@ -1127,6 +1356,10 @@ declare class ZodVoid extends ZodType<void, ZodVoidDef> {
 interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     type: T;
     typeName: ZodFirstPartyTypeKind.ZodArray;
+    exactLength: {
+        value: number;
+        message?: string;
+    } | null;
     minLength: {
         value: number;
         message?: string;
@@ -1147,31 +1380,6 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
 }
-declare namespace objectUtil {
-    export type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
-        [k in Exclude<keyof U, keyof V>]: U[k];
-    } & V;
-    type optionalKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? k : never;
-    }[keyof T];
-    type requiredKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? never : k;
-    }[keyof T];
-    export type addQuestionMarks<T extends object> = Partial<Pick<T, optionalKeys<T>>> & Pick<T, requiredKeys<T>>;
-    export type identity<T> = T;
-    export type flatten<T extends object> = identity<{
-        [k in keyof T]: T[k];
-    }>;
-    export type noNeverKeys<T extends ZodRawShape> = {
-        [k in keyof T]: [T[k]] extends [never] ? never : k;
-    }[keyof T];
-    export type noNever<T extends ZodRawShape> = identity<{
-        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-    }>;
-    export const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
-    export {};
-}
-declare type extendShape<A, B> = Omit<A, keyof B> & B;
 declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodObject;
@@ -1179,20 +1387,25 @@ interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends
     catchall: Catchall;
     unknownKeys: UnknownKeys;
 }
-declare type baseObjectOutputType<Shape extends ZodRawShape> = objectUtil.flatten<objectUtil.addQuestionMarks<{
+declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+declare type baseObjectOutputType<Shape extends ZodRawShape> = {
     [k in keyof Shape]: Shape[k]["_output"];
-}>>;
-declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = ZodTypeAny extends Catchall ? baseObjectOutputType<Shape> : objectUtil.flatten<baseObjectOutputType<Shape> & {
-    [k: string]: Catchall["_output"];
-}>;
-declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.flatten<objectUtil.addQuestionMarks<{
+};
+declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
     [k in keyof Shape]: Shape[k]["_input"];
-}>>;
-declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = ZodTypeAny extends Catchall ? baseObjectInputType<Shape> : objectUtil.flatten<baseObjectInputType<Shape> & {
-    [k: string]: Catchall["_input"];
 }>;
-declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T;
-declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+declare type CatchallOutput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+    [k: string]: T["_output"];
+};
+declare type CatchallInput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+    [k: string]: T["_input"];
+};
+declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+    [k: string]: unknown;
+} : unknown;
+declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
     private _cached;
     _getCached(): {
         shape: T;
@@ -1203,22 +1416,13 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
     strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
     strip(): ZodObject<T, "strip", Catchall>;
     passthrough(): ZodObject<T, "passthrough", Catchall>;
-    /**
-     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-     * If you want to pass through unknown properties, use `.passthrough()` instead.
-     */
     nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<extendShape<T, Augmentation>, UnknownKeys, Catchall, objectOutputType<extendShape<T, Augmentation>, Catchall>, objectInputType<extendShape<T, Augmentation>, Catchall>>;
-    extend: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<extendShape<T, Augmentation>, UnknownKeys, Catchall, objectOutputType<extendShape<T, Augmentation>, Catchall>, objectInputType<extendShape<T, Augmentation>, Catchall>>;
+    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, UnknownKeys, Catchall, objectOutputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall, UnknownKeys>, objectInputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall, UnknownKeys>>;
+    merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
     setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
         [k in Key]: Schema;
     }, UnknownKeys, Catchall>;
-    /**
-     * Prior to zod@1.0.12 there was a bug in the
-     * inferred type of merged objects. Please
-     * upgrade if you are experiencing issues.
-     */
-    merge<Incoming extends AnyZodObject>(merging: Incoming): ZodObject<extendShape<T, ReturnType<Incoming["_def"]["shape"]>>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
     pick<Mask extends {
         [k in keyof T]?: true;
@@ -1238,10 +1442,15 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
     required(): ZodObject<{
         [k in keyof T]: deoptional<T[k]>;
     }, UnknownKeys, Catchall>;
+    required<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+        [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
+    }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
+    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
+    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
+    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
 }
 declare type AnyZodObject = ZodObject<any, any, any>;
 declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
@@ -1303,7 +1512,7 @@ declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTy
     _parse(input: ParseInput): ParseReturnType<any>;
     parameters(): Args;
     returnType(): Returns;
-    args<Items extends Parameters<typeof ZodTuple["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
+    args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
     returns<NewReturnType extends ZodType<any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
     implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
     strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
@@ -1320,7 +1529,7 @@ interface ZodLiteralDef<T = any> extends ZodTypeDef {
 declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
-    static create: <T_1 extends string | number | bigint | boolean | null | undefined>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+    static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
 }
 declare type EnumValues = [string, ...string[]];
 declare type Values<T extends EnumValues> = {
@@ -1333,6 +1542,8 @@ interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
 declare type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+declare type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>> {
@@ -1341,6 +1552,8 @@ declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number]
     get enum(): Values<T>;
     get Values(): Values<T>;
     get Enum(): Values<T>;
+    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract): ZodEnum<Writeable<ToExtract>>;
+    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
     static create: typeof createZodEnum;
 }
 interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
@@ -1361,6 +1574,7 @@ interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodPromise;
 }
 declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+    unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
 }
@@ -1382,10 +1596,11 @@ interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodEffects;
     effect: Effect<any>;
 }
-declare class ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
     innerType(): T;
+    sourceType(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], input<I>>;
     static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 }
 
@@ -1415,7 +1630,34 @@ interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
+    }) => ZodDefault<T_1>;
+}
+interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    innerType: T;
+    catchValue: (ctx: {
+        error: ZodError;
+        input: unknown;
+    }) => T["_input"];
+    typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    removeCatch(): T;
+    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        catch: T_1["_output"] | (() => T_1["_output"]);
+    }) => ZodCatch<T_1>;
 }
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -1427,10 +1669,19 @@ declare type BRAND<T extends string | number | symbol> = {
         [k in T]: true;
     };
 };
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"] & BRAND<B>> {
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
     unwrap(): T;
 }
+interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+    in: A;
+    out: B;
+    typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+}
 declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
     ZodNumber = "ZodNumber",
@@ -1438,6 +1689,7 @@ declare enum ZodFirstPartyTypeKind {
     ZodBigInt = "ZodBigInt",
     ZodBoolean = "ZodBoolean",
     ZodDate = "ZodDate",
+    ZodSymbol = "ZodSymbol",
     ZodUndefined = "ZodUndefined",
     ZodNull = "ZodNull",
     ZodAny = "ZodAny",
@@ -1462,34 +1714,10 @@ declare enum ZodFirstPartyTypeKind {
     ZodOptional = "ZodOptional",
     ZodNullable = "ZodNullable",
     ZodDefault = "ZodDefault",
+    ZodCatch = "ZodCatch",
     ZodPromise = "ZodPromise",
-    ZodBranded = "ZodBranded"
-}
-
-declare const partialLinksSchema: ZodObject<{
-    termsAndConditions: ZodOptional<ZodString>;
-}, "strict", ZodTypeAny, {
-    termsAndConditions?: string | undefined;
-}, {
-    termsAndConditions?: string | undefined;
-}>;
-
-interface Logo {
-    dark?: string;
-    height?: number;
-    light: string;
-    width?: number;
-}
-interface Style {
-    checksAndRadios?: 'animated' | 'standard';
-    labels?: 'floating' | 'stacked';
-    logo?: Logo;
-    sections?: {
-        header?: boolean;
-    };
-    stage?: {
-        icon: boolean;
-    };
+    ZodBranded = "ZodBranded",
+    ZodPipeline = "ZodPipeline"
 }
 
 declare const partialConfigSchema: ZodObject<{
@@ -1499,45 +1727,45 @@ declare const partialConfigSchema: ZodObject<{
             name: ZodString;
             value: ZodUnknown;
         }, "strip", ZodTypeAny, {
-            value?: unknown;
             name: string;
-        }, {
             value?: unknown;
+        }, {
             name: string;
+            value?: unknown;
         }>, "many">>;
         output: ZodArray<ZodObject<{
             name: ZodString;
             value: ZodUnknown;
         }, "strip", ZodTypeAny, {
-            value?: unknown;
             name: string;
-        }, {
             value?: unknown;
+        }, {
             name: string;
+            value?: unknown;
         }>, "many">;
         type: ZodNativeEnum<typeof CallbackType>;
     }, "strip", ZodTypeAny, {
-        input?: {
-            value?: unknown;
-            name: string;
-        }[] | undefined;
-        _id?: number | undefined;
         type: CallbackType;
         output: {
-            value?: unknown;
             name: string;
+            value?: unknown;
         }[];
-    }, {
+        _id?: number | undefined;
         input?: {
-            value?: unknown;
             name: string;
+            value?: unknown;
         }[] | undefined;
-        _id?: number | undefined;
+    }, {
         type: CallbackType;
         output: {
-            value?: unknown;
             name: string;
+            value?: unknown;
         }[];
+        _id?: number | undefined;
+        input?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
     }>], ZodUnknown>, ZodType<FRCallback, ZodTypeDef, FRCallback>>>>;
     clientId: ZodOptional<ZodOptional<ZodString>>;
     middleware: ZodOptional<ZodOptional<ZodArray<ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>, "many">>>;
@@ -1573,6 +1801,8 @@ declare const partialConfigSchema: ZodObject<{
         }>>;
         timeout: ZodNumber;
     }, "strip", ZodTypeAny, {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1582,9 +1812,9 @@ declare const partialConfigSchema: ZodObject<{
             revoke: string;
             sessions: string;
         } | undefined;
+    }, {
         timeout: number;
         baseUrl: string;
-    }, {
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1594,8 +1824,6 @@ declare const partialConfigSchema: ZodObject<{
             revoke: string;
             sessions: string;
         } | undefined;
-        timeout: number;
-        baseUrl: string;
     }>>;
     support: ZodOptional<ZodOptional<ZodUnion<[ZodLiteral<"legacy">, ZodLiteral<"modern">]>>>;
     tokenStore: ZodOptional<ZodOptional<ZodUnion<[ZodObject<{
@@ -1605,15 +1833,15 @@ declare const partialConfigSchema: ZodObject<{
             refreshToken: ZodOptional<ZodString>;
             tokenExpiry: ZodOptional<ZodNumber>;
         }, "strip", ZodTypeAny, {
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }, {
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }>>>;
         set: ZodFunction<ZodTuple<[ZodString], ZodUnknown>, ZodPromise<ZodVoid>>;
         remove: ZodFunction<ZodTuple<[ZodString], ZodUnknown>, ZodPromise<ZodVoid>>;
@@ -1621,37 +1849,36 @@ declare const partialConfigSchema: ZodObject<{
         set: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         remove: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         get: (args_0: string, ...args_1: unknown[]) => Promise<{
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }>;
     }, {
         set: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         remove: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         get: (args_0: string, ...args_1: unknown[]) => Promise<{
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }>;
     }>, ZodLiteral<"indexedDB">, ZodLiteral<"sessionStorage">, ZodLiteral<"localStorage">]>>>;
     tree: ZodOptional<ZodOptional<ZodString>>;
     type: ZodOptional<ZodOptional<ZodString>>;
     oauthThreshold: ZodOptional<ZodOptional<ZodNumber>>;
 }, "strict", ZodTypeAny, {
-    type?: string | undefined;
     callbackFactory?: ((args_0: {
-        input?: {
-            value?: unknown;
-            name: string;
-        }[] | undefined;
-        _id?: number | undefined;
         type: CallbackType;
         output: {
-            value?: unknown;
             name: string;
+            value?: unknown;
         }[];
+        _id?: number | undefined;
+        input?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
     }, ...args_1: unknown[]) => FRCallback) | undefined;
     clientId?: string | undefined;
     middleware?: ((...args: unknown[]) => unknown)[] | undefined;
@@ -1659,6 +1886,8 @@ declare const partialConfigSchema: ZodObject<{
     redirectUri?: string | undefined;
     scope?: string | undefined;
     serverConfig?: {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1668,35 +1897,33 @@ declare const partialConfigSchema: ZodObject<{
             revoke: string;
             sessions: string;
         } | undefined;
-        timeout: number;
-        baseUrl: string;
     } | undefined;
     support?: "modern" | "legacy" | undefined;
     tokenStore?: "localStorage" | "indexedDB" | "sessionStorage" | {
         set: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         remove: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         get: (args_0: string, ...args_1: unknown[]) => Promise<{
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }>;
     } | undefined;
     tree?: string | undefined;
+    type?: string | undefined;
     oauthThreshold?: number | undefined;
 }, {
-    type?: string | undefined;
     callbackFactory?: ((args_0: {
-        input?: {
-            value?: unknown;
-            name: string;
-        }[] | undefined;
-        _id?: number | undefined;
         type: CallbackType;
         output: {
-            value?: unknown;
             name: string;
+            value?: unknown;
         }[];
+        _id?: number | undefined;
+        input?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
     }, ...args_1: unknown[]) => FRCallback) | undefined;
     clientId?: string | undefined;
     middleware?: ((...args: unknown[]) => unknown)[] | undefined;
@@ -1704,6 +1931,8 @@ declare const partialConfigSchema: ZodObject<{
     redirectUri?: string | undefined;
     scope?: string | undefined;
     serverConfig?: {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1713,99 +1942,106 @@ declare const partialConfigSchema: ZodObject<{
             revoke: string;
             sessions: string;
         } | undefined;
-        timeout: number;
-        baseUrl: string;
     } | undefined;
     support?: "modern" | "legacy" | undefined;
     tokenStore?: "localStorage" | "indexedDB" | "sessionStorage" | {
         set: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         remove: (args_0: string, ...args_1: unknown[]) => Promise<void>;
         get: (args_0: string, ...args_1: unknown[]) => Promise<{
+            accessToken: string;
             idToken?: string | undefined;
             refreshToken?: string | undefined;
             tokenExpiry?: number | undefined;
-            accessToken: string;
         }>;
     } | undefined;
     tree?: string | undefined;
+    type?: string | undefined;
     oauthThreshold?: number | undefined;
 }>;
 
 declare const journeyConfigSchema: ZodObject<{
-    forgotPassword: ZodObject<{
+    forgotPassword: ZodOptional<ZodObject<{
         journey: ZodOptional<ZodString>;
         match: ZodArray<ZodString, "many">;
     }, "strip", ZodTypeAny, {
-        journey?: string | undefined;
         match: string[];
-    }, {
         journey?: string | undefined;
+    }, {
         match: string[];
-    }>;
-    forgotUsername: ZodObject<{
+        journey?: string | undefined;
+    }>>;
+    forgotUsername: ZodOptional<ZodObject<{
         journey: ZodOptional<ZodString>;
         match: ZodArray<ZodString, "many">;
     }, "strip", ZodTypeAny, {
-        journey?: string | undefined;
         match: string[];
-    }, {
         journey?: string | undefined;
+    }, {
         match: string[];
-    }>;
-    login: ZodObject<{
+        journey?: string | undefined;
+    }>>;
+    login: ZodOptional<ZodObject<{
         journey: ZodOptional<ZodString>;
         match: ZodArray<ZodString, "many">;
     }, "strip", ZodTypeAny, {
-        journey?: string | undefined;
         match: string[];
-    }, {
         journey?: string | undefined;
+    }, {
         match: string[];
-    }>;
-    register: ZodObject<{
+        journey?: string | undefined;
+    }>>;
+    register: ZodOptional<ZodObject<{
         journey: ZodOptional<ZodString>;
         match: ZodArray<ZodString, "many">;
     }, "strip", ZodTypeAny, {
-        journey?: string | undefined;
         match: string[];
-    }, {
         journey?: string | undefined;
+    }, {
         match: string[];
-    }>;
-}, "strip", ZodTypeAny, {
-    forgotPassword: {
         journey?: string | undefined;
+    }>>;
+}, "strip", ZodTypeAny, {
+    forgotPassword?: {
         match: string[];
-    };
-    forgotUsername: {
         journey?: string | undefined;
+    } | undefined;
+    forgotUsername?: {
         match: string[];
-    };
-    login: {
         journey?: string | undefined;
+    } | undefined;
+    login?: {
         match: string[];
-    };
-    register: {
         journey?: string | undefined;
+    } | undefined;
+    register?: {
         match: string[];
-    };
-}, {
-    forgotPassword: {
         journey?: string | undefined;
+    } | undefined;
+}, {
+    forgotPassword?: {
         match: string[];
-    };
-    forgotUsername: {
         journey?: string | undefined;
+    } | undefined;
+    forgotUsername?: {
         match: string[];
-    };
-    login: {
         journey?: string | undefined;
+    } | undefined;
+    login?: {
         match: string[];
-    };
-    register: {
         journey?: string | undefined;
+    } | undefined;
+    register?: {
         match: string[];
-    };
+        journey?: string | undefined;
+    } | undefined;
+}>;
+
+declare const partialLinksSchema: ZodObject<{
+    termsAndConditions: ZodOptional<ZodString>;
+}, "strict", ZodTypeAny, {
+    termsAndConditions?: string | undefined;
+}, {
+    termsAndConditions?: string | undefined;
 }>;
 
 declare const partialStringsSchema: ZodObject<{
@@ -1823,6 +2059,7 @@ declare const partialStringsSchema: ZodObject<{
     doesNotMeetMinimumCharacterLength: ZodOptional<ZodString>;
     ensurePasswordIsMoreThan: ZodOptional<ZodString>;
     ensurePasswordHasOne: ZodOptional<ZodString>;
+    enterVerificationCode: ZodOptional<ZodString>;
     exceedsMaximumCharacterLength: ZodOptional<ZodString>;
     fieldCanNotContainFollowingCharacters: ZodOptional<ZodString>;
     fieldCanNotContainFollowingValues: ZodOptional<ZodString>;
@@ -1866,16 +2103,17 @@ declare const partialStringsSchema: ZodObject<{
     termsAndConditions: ZodOptional<ZodString>;
     termsAndConditionsLinkText: ZodOptional<ZodString>;
     tryAgain: ZodOptional<ZodString>;
+    twoFactorAuthentication: ZodOptional<ZodString>;
     useValidEmail: ZodOptional<ZodString>;
     unrecoverableError: ZodOptional<ZodString>;
     unknownNetworkError: ZodOptional<ZodString>;
+    userName: ZodOptional<ZodString>;
     usernameRequirements: ZodOptional<ZodString>;
+    useTheAuthenticatorAppOnYourPhone: ZodOptional<ZodString>;
     validatedCreatePasswordCallback: ZodOptional<ZodString>;
     validatedCreateUsernameCallback: ZodOptional<ZodString>;
     valueRequirements: ZodOptional<ZodString>;
 }, "strict", ZodTypeAny, {
-    loading?: string | undefined;
-    termsAndConditions?: string | undefined;
     alreadyHaveAnAccount?: string | undefined;
     backToDefault?: string | undefined;
     backToLogin?: string | undefined;
@@ -1890,6 +2128,7 @@ declare const partialStringsSchema: ZodObject<{
     doesNotMeetMinimumCharacterLength?: string | undefined;
     ensurePasswordIsMoreThan?: string | undefined;
     ensurePasswordHasOne?: string | undefined;
+    enterVerificationCode?: string | undefined;
     exceedsMaximumCharacterLength?: string | undefined;
     fieldCanNotContainFollowingCharacters?: string | undefined;
     fieldCanNotContainFollowingValues?: string | undefined;
@@ -1897,6 +2136,7 @@ declare const partialStringsSchema: ZodObject<{
     forgotUsername?: string | undefined;
     givenName?: string | undefined;
     inputRequiredError?: string | undefined;
+    loading?: string | undefined;
     loginButton?: string | undefined;
     loginFailure?: string | undefined;
     loginHeader?: string | undefined;
@@ -1929,18 +2169,20 @@ declare const partialStringsSchema: ZodObject<{
     sn?: string | undefined;
     submitButton?: string | undefined;
     successMessage?: string | undefined;
+    termsAndConditions?: string | undefined;
     termsAndConditionsLinkText?: string | undefined;
     tryAgain?: string | undefined;
+    twoFactorAuthentication?: string | undefined;
     useValidEmail?: string | undefined;
     unrecoverableError?: string | undefined;
     unknownNetworkError?: string | undefined;
+    userName?: string | undefined;
     usernameRequirements?: string | undefined;
+    useTheAuthenticatorAppOnYourPhone?: string | undefined;
     validatedCreatePasswordCallback?: string | undefined;
     validatedCreateUsernameCallback?: string | undefined;
     valueRequirements?: string | undefined;
 }, {
-    loading?: string | undefined;
-    termsAndConditions?: string | undefined;
     alreadyHaveAnAccount?: string | undefined;
     backToDefault?: string | undefined;
     backToLogin?: string | undefined;
@@ -1955,6 +2197,7 @@ declare const partialStringsSchema: ZodObject<{
     doesNotMeetMinimumCharacterLength?: string | undefined;
     ensurePasswordIsMoreThan?: string | undefined;
     ensurePasswordHasOne?: string | undefined;
+    enterVerificationCode?: string | undefined;
     exceedsMaximumCharacterLength?: string | undefined;
     fieldCanNotContainFollowingCharacters?: string | undefined;
     fieldCanNotContainFollowingValues?: string | undefined;
@@ -1962,6 +2205,7 @@ declare const partialStringsSchema: ZodObject<{
     forgotUsername?: string | undefined;
     givenName?: string | undefined;
     inputRequiredError?: string | undefined;
+    loading?: string | undefined;
     loginButton?: string | undefined;
     loginFailure?: string | undefined;
     loginHeader?: string | undefined;
@@ -1994,59 +2238,218 @@ declare const partialStringsSchema: ZodObject<{
     sn?: string | undefined;
     submitButton?: string | undefined;
     successMessage?: string | undefined;
+    termsAndConditions?: string | undefined;
     termsAndConditionsLinkText?: string | undefined;
     tryAgain?: string | undefined;
+    twoFactorAuthentication?: string | undefined;
     useValidEmail?: string | undefined;
     unrecoverableError?: string | undefined;
     unknownNetworkError?: string | undefined;
+    userName?: string | undefined;
     usernameRequirements?: string | undefined;
+    useTheAuthenticatorAppOnYourPhone?: string | undefined;
     validatedCreatePasswordCallback?: string | undefined;
     validatedCreateUsernameCallback?: string | undefined;
     valueRequirements?: string | undefined;
 }>;
 
-declare const journey: {
-    start(options?: JourneyOptions): void;
-    onFailure(fn: (response: Response$1) => void): void;
-    onSuccess(fn: (response: Response$1) => void): void;
+declare const partialStyleSchema: ZodObject<{
+    checksAndRadios: ZodOptional<ZodOptional<ZodUnion<[ZodLiteral<"animated">, ZodLiteral<"standard">]>>>;
+    labels: ZodOptional<ZodOptional<ZodUnion<[ZodOptional<ZodLiteral<"floating">>, ZodLiteral<"stacked">]>>>;
+    logo: ZodOptional<ZodOptional<ZodObject<{
+        dark: ZodOptional<ZodString>;
+        height: ZodOptional<ZodNumber>;
+        light: ZodOptional<ZodString>;
+        width: ZodOptional<ZodNumber>;
+    }, "strict", ZodTypeAny, {
+        dark?: string | undefined;
+        height?: number | undefined;
+        light?: string | undefined;
+        width?: number | undefined;
+    }, {
+        dark?: string | undefined;
+        height?: number | undefined;
+        light?: string | undefined;
+        width?: number | undefined;
+    }>>>;
+    sections: ZodOptional<ZodOptional<ZodObject<{
+        header: ZodOptional<ZodBoolean>;
+    }, "strip", ZodTypeAny, {
+        header?: boolean | undefined;
+    }, {
+        header?: boolean | undefined;
+    }>>>;
+    stage: ZodOptional<ZodOptional<ZodObject<{
+        icon: ZodOptional<ZodBoolean>;
+    }, "strip", ZodTypeAny, {
+        icon?: boolean | undefined;
+    }, {
+        icon?: boolean | undefined;
+    }>>>;
+}, "strict", ZodTypeAny, {
+    checksAndRadios?: "standard" | "animated" | undefined;
+    labels?: "floating" | "stacked" | undefined;
+    logo?: {
+        dark?: string | undefined;
+        height?: number | undefined;
+        light?: string | undefined;
+        width?: number | undefined;
+    } | undefined;
+    sections?: {
+        header?: boolean | undefined;
+    } | undefined;
+    stage?: {
+        icon?: boolean | undefined;
+    } | undefined;
+}, {
+    checksAndRadios?: "standard" | "animated" | undefined;
+    labels?: "floating" | "stacked" | undefined;
+    logo?: {
+        dark?: string | undefined;
+        height?: number | undefined;
+        light?: string | undefined;
+        width?: number | undefined;
+    } | undefined;
+    sections?: {
+        header?: boolean | undefined;
+    } | undefined;
+    stage?: {
+        icon?: boolean | undefined;
+    } | undefined;
+}>;
+
+interface JourneyOptions {
+    oauth?: boolean;
+    user?: boolean;
+}
+interface JourneyOptionsChange {
+    forgerock?: StepOptions;
+    journey: string;
+}
+interface JourneyOptionsStart {
+    forgerock?: StepOptions;
+    journey?: string;
+    resumeUrl?: string;
+}
+interface WidgetConfigOptions {
+    forgerock?: TypeOf<typeof partialConfigSchema>;
+    content?: TypeOf<typeof partialStringsSchema>;
+    journeys?: TypeOf<typeof journeyConfigSchema>;
+    links?: TypeOf<typeof partialLinksSchema>;
+    style?: TypeOf<typeof partialStyleSchema>;
+}
+
+
+interface ComponentStoreValue {
+    lastAction: 'close' | 'open' | 'mount' | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    modal: {
+        component: SvelteComponentDev$1;
+        element: HTMLDialogElement;
+    } | null;
+    mounted: boolean;
+    open: boolean | null;
+    reason: 'auto' | 'external' | 'user' | null;
+    type: 'inline' | 'modal' | null;
+}
+
+declare const api: {
+    component: {
+        close: (args?: {
+            reason: "auto" | "external" | "user";
+        } | undefined) => void;
+        open: () => void;
+        subscribe: (this: void, run: Subscriber<Pick<ComponentStoreValue, "reason" | "error" | "open" | "lastAction" | "mounted">>, invalidate?: ((value?: Pick<ComponentStoreValue, "reason" | "error" | "open" | "lastAction" | "mounted"> | undefined) => void) | undefined) => Unsubscriber;
+    };
+    configuration: (options?: WidgetConfigOptions | undefined) => {
+        set(setOptions?: WidgetConfigOptions | undefined): void;
+    };
+    getStores: () => {
+        journeyStore: JourneyStore;
+        oauthStore: OAuthStore;
+        userStore: UserStore;
+    };
+    journey: (options?: JourneyOptions | undefined) => {
+        change: (changeOptions: JourneyOptionsChange) => Promise<unknown>;
+        start: (startOptions?: JourneyOptionsStart | undefined) => Promise<unknown>;
+        subscribe: (this: void, run: Subscriber<{
+            journey: JourneyStoreValue;
+            oauth: OAuthTokenStoreValue;
+            user: UserStoreValue;
+        }>, invalidate?: ((value?: {
+            journey: JourneyStoreValue;
+            oauth: OAuthTokenStoreValue;
+            user: UserStoreValue;
+        } | undefined) => void) | undefined) => Unsubscriber;
+    };
+    request: typeof HttpClient.request;
+    user: {
+        info(): {
+            get: (options?: ConfigOptions | undefined) => Promise<unknown>;
+            subscribe: (this: void, run: Subscriber<UserStoreValue>, invalidate?: ((value?: UserStoreValue | undefined) => void) | undefined) => Unsubscriber;
+        };
+        logout(): Promise<void>;
+        tokens(): {
+            get: (options?: ConfigOptions | undefined) => Promise<unknown>;
+            subscribe: (this: void, run: Subscriber<OAuthTokenStoreValue>, invalidate?: ((value?: OAuthTokenStoreValue | undefined) => void) | undefined) => Unsubscriber;
+        };
+    };
+};
+declare const configuration: (options?: WidgetConfigOptions | undefined) => {
+    set(setOptions?: WidgetConfigOptions | undefined): void;
+};
+declare const journey: (options?: JourneyOptions | undefined) => {
+    change: (changeOptions: JourneyOptionsChange) => Promise<unknown>;
+    start: (startOptions?: JourneyOptionsStart | undefined) => Promise<unknown>;
+    subscribe: (this: void, run: Subscriber<{
+        journey: JourneyStoreValue;
+        oauth: OAuthTokenStoreValue;
+        user: UserStoreValue;
+    }>, invalidate?: ((value?: {
+        journey: JourneyStoreValue;
+        oauth: OAuthTokenStoreValue;
+        user: UserStoreValue;
+    } | undefined) => void) | undefined) => Unsubscriber;
 };
-declare const modal: {
-    close(args?: {
-        reason: 'auto' | 'external' | 'user';
-    }): void;
-    onClose(fn: (args: {
-        reason: 'auto' | 'external' | 'user';
-    }) => void): void;
-    onMount(fn: (dialog: HTMLDialogElement, form: HTMLFormElement) => void): void;
-    open(options?: JourneyOptions): void;
+declare const component: () => {
+    close: (args?: {
+        reason: "auto" | "external" | "user";
+    } | undefined) => void;
+    open: () => void;
+    subscribe: (this: void, run: Subscriber<Pick<ComponentStoreValue, "reason" | "error" | "open" | "lastAction" | "mounted">>, invalidate?: ((value?: Pick<ComponentStoreValue, "reason" | "error" | "open" | "lastAction" | "mounted"> | undefined) => void) | undefined) => Unsubscriber;
 };
-declare const request: (options: HttpClientRequestOptions) => Promise<globalThis.Response>;
+declare const request: typeof HttpClient.request;
 declare const user: {
-    authorized(remote?: boolean): Promise<boolean>;
-    info(remote?: boolean): Promise<unknown>;
+    info(): {
+        get: (options?: ConfigOptions | undefined) => Promise<unknown>;
+        subscribe: (this: void, run: Subscriber<UserStoreValue>, invalidate?: ((value?: UserStoreValue | undefined) => void) | undefined) => Unsubscriber;
+    };
     logout(): Promise<void>;
-    tokens(options?: GetTokensOptions): Promise<void | OAuth2Tokens>;
+    tokens(): {
+        get: (options?: ConfigOptions | undefined) => Promise<unknown>;
+        subscribe: (this: void, run: Subscriber<OAuthTokenStoreValue>, invalidate?: ((value?: OAuthTokenStoreValue | undefined) => void) | undefined) => Unsubscriber;
+    };
 };
-
+type ConfigurationApi = ReturnType<typeof api.configuration>;
+type JourneyApi = ReturnType<typeof api.journey>;
+type UserInfoApi = ReturnType<typeof api.user.info>;
+type UserTokensApi = ReturnType<typeof api.user.tokens>;
 declare const __propDef: {
     props: {
-        config: TypeOf<typeof partialConfigSchema>;
-        content: TypeOf<typeof partialStringsSchema>;
-        journeys?: TypeOf<typeof journeyConfigSchema> | undefined;
-        links?: TypeOf<typeof partialLinksSchema> | undefined;
-        style?: Style | undefined;
+        type?: "inline" | "modal" | undefined;
     };
     events: {
-        'modal-mount': CustomEvent<any>;
-    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-type ModalProps = typeof __propDef.props;
-type ModalEvents = typeof __propDef.events;
-type ModalSlots = typeof __propDef.slots;
-declare class Modal extends SvelteComponentTyped<ModalProps, ModalEvents, ModalSlots> {
+type IndexProps = typeof __propDef.props;
+type IndexEvents = typeof __propDef.events;
+type IndexSlots = typeof __propDef.slots;
+declare class Index extends SvelteComponentTyped<IndexProps, IndexEvents, IndexSlots> {
 }
 
-export { ModalEvents, ModalProps, ModalSlots, Modal as default, journey, modal, request, user };
+export { ConfigurationApi, IndexEvents, IndexProps, IndexSlots, JourneyApi, UserInfoApi, UserTokensApi, component, configuration, Index as default, journey, request, user };