@forgerock/login-widget 1.0.0-beta.7 → 1.0.0-beta.9

package/index.d.ts

@@ -676,6 +676,7 @@ interface UserStoreValue {
     error: Maybe<{
         code?: Maybe<number>;
         message: Maybe<string>;
+        troubleshoot: Maybe<string>;
     }>;
     loading: boolean;
     successful: boolean;
@@ -691,6 +692,7 @@ interface OAuthTokenStoreValue {
     error: Maybe<{
         code?: Maybe<number>;
         message: Maybe<string>;
+        troubleshoot: Maybe<string>;
     }>;
     loading: boolean;
     successful: boolean;
@@ -722,6 +724,7 @@ interface JourneyStoreValue {
         code: Maybe<number>;
         message: Maybe<string>;
         step: Maybe<Step>;
+        troubleshoot: Maybe<string>;
     }>;
     loading: boolean;
     metadata: {
@@ -744,10 +747,11 @@ interface StepMetadata {
 }
 type StepTypes = FRStep | FRLoginSuccess | FRLoginFailure | null;
 
-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;
@@ -759,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";
@@ -816,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 = {
@@ -830,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;
@@ -859,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;
@@ -870,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;
@@ -893,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[];
@@ -1005,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;
 }
@@ -1032,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;
@@ -1071,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]>;
@@ -1090,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;
@@ -1103,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;
@@ -1130,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";
@@ -1184,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;
@@ -1210,19 +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?: RawCreateParams) => ZodBoolean;
+    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;
@@ -1242,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;
@@ -1262,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;
@@ -1294,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;
@@ -1318,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;
@@ -1353,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[]]>;
@@ -1418,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>;
@@ -1435,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> = {
@@ -1448,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>> {
@@ -1456,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 {
@@ -1476,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>;
 }
@@ -1497,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>;
 }
 
@@ -1530,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;
@@ -1542,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",
@@ -1553,6 +1689,7 @@ declare enum ZodFirstPartyTypeKind {
     ZodBigInt = "ZodBigInt",
     ZodBoolean = "ZodBoolean",
     ZodDate = "ZodDate",
+    ZodSymbol = "ZodSymbol",
     ZodUndefined = "ZodUndefined",
     ZodNull = "ZodNull",
     ZodAny = "ZodAny",
@@ -1577,8 +1714,10 @@ declare enum ZodFirstPartyTypeKind {
     ZodOptional = "ZodOptional",
     ZodNullable = "ZodNullable",
     ZodDefault = "ZodDefault",
+    ZodCatch = "ZodCatch",
     ZodPromise = "ZodPromise",
-    ZodBranded = "ZodBranded"
+    ZodBranded = "ZodBranded",
+    ZodPipeline = "ZodPipeline"
 }
 
 declare const partialConfigSchema: ZodObject<{
@@ -1588,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">>>;
@@ -1662,6 +1801,8 @@ declare const partialConfigSchema: ZodObject<{
         }>>;
         timeout: ZodNumber;
     }, "strip", ZodTypeAny, {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1671,9 +1812,9 @@ declare const partialConfigSchema: ZodObject<{
             revoke: string;
             sessions: string;
         } | undefined;
+    }, {
         timeout: number;
         baseUrl: string;
-    }, {
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1683,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<{
@@ -1694,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>>;
@@ -1710,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;
@@ -1748,6 +1886,8 @@ declare const partialConfigSchema: ZodObject<{
     redirectUri?: string | undefined;
     scope?: string | undefined;
     serverConfig?: {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1757,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;
@@ -1793,6 +1931,8 @@ declare const partialConfigSchema: ZodObject<{
     redirectUri?: string | undefined;
     scope?: string | undefined;
     serverConfig?: {
+        timeout: number;
+        baseUrl: string;
         paths?: {
             authenticate: string;
             authorize: string;
@@ -1802,99 +1942,98 @@ 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<{
@@ -1975,8 +2114,6 @@ declare const partialStringsSchema: ZodObject<{
     validatedCreateUsernameCallback: ZodOptional<ZodString>;
     valueRequirements: ZodOptional<ZodString>;
 }, "strict", ZodTypeAny, {
-    loading?: string | undefined;
-    termsAndConditions?: string | undefined;
     alreadyHaveAnAccount?: string | undefined;
     backToDefault?: string | undefined;
     backToLogin?: string | undefined;
@@ -1999,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;
@@ -2031,6 +2169,7 @@ 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;
@@ -2044,8 +2183,6 @@ declare const partialStringsSchema: ZodObject<{
     validatedCreateUsernameCallback?: string | undefined;
     valueRequirements?: string | undefined;
 }, {
-    loading?: string | undefined;
-    termsAndConditions?: string | undefined;
     alreadyHaveAnAccount?: string | undefined;
     backToDefault?: string | undefined;
     backToLogin?: string | undefined;
@@ -2068,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;
@@ -2100,6 +2238,7 @@ 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;
@@ -2123,15 +2262,15 @@ declare const partialStyleSchema: ZodObject<{
         light: ZodOptional<ZodString>;
         width: ZodOptional<ZodNumber>;
     }, "strict", ZodTypeAny, {
-        height?: number | undefined;
-        width?: number | undefined;
         dark?: string | undefined;
-        light?: 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>;
@@ -2148,13 +2287,13 @@ declare const partialStyleSchema: ZodObject<{
         icon?: boolean | undefined;
     }>>>;
 }, "strict", ZodTypeAny, {
-    labels?: "floating" | "stacked" | undefined;
     checksAndRadios?: "standard" | "animated" | undefined;
+    labels?: "floating" | "stacked" | undefined;
     logo?: {
-        height?: number | undefined;
-        width?: number | undefined;
         dark?: string | undefined;
+        height?: number | undefined;
         light?: string | undefined;
+        width?: number | undefined;
     } | undefined;
     sections?: {
         header?: boolean | undefined;
@@ -2163,13 +2302,13 @@ declare const partialStyleSchema: ZodObject<{
         icon?: boolean | undefined;
     } | undefined;
 }, {
-    labels?: "floating" | "stacked" | undefined;
     checksAndRadios?: "standard" | "animated" | undefined;
+    labels?: "floating" | "stacked" | undefined;
     logo?: {
-        height?: number | undefined;
-        width?: number | undefined;
         dark?: string | undefined;
+        height?: number | undefined;
         light?: string | undefined;
+        width?: number | undefined;
     } | undefined;
     sections?: {
         header?: boolean | undefined;
@@ -2183,13 +2322,17 @@ interface JourneyOptions {
     oauth?: boolean;
     user?: boolean;
 }
+interface JourneyOptionsChange {
+    forgerock?: StepOptions;
+    journey: string;
+}
 interface JourneyOptionsStart {
-    config?: StepOptions;
+    forgerock?: StepOptions;
     journey?: string;
     resumeUrl?: string;
 }
 interface WidgetConfigOptions {
-    config?: TypeOf<typeof partialConfigSchema>;
+    forgerock?: TypeOf<typeof partialConfigSchema>;
     content?: TypeOf<typeof partialStringsSchema>;
     journeys?: TypeOf<typeof journeyConfigSchema>;
     links?: TypeOf<typeof partialLinksSchema>;
@@ -2198,6 +2341,7 @@ interface WidgetConfigOptions {
 
 
 interface ComponentStoreValue {
+    lastAction: 'close' | 'open' | 'mount' | null;
     error: {
         code: string;
         message: string;
@@ -2217,9 +2361,8 @@ declare const api: {
         close: (args?: {
             reason: "auto" | "external" | "user";
         } | undefined) => void;
-        mount: (component: SvelteComponentDev$1, element: HTMLDialogElement) => void;
         open: () => void;
-        subscribe: (this: void, run: Subscriber<ComponentStoreValue>, invalidate?: ((value?: ComponentStoreValue | undefined) => void) | undefined) => Unsubscriber;
+        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;
@@ -2230,6 +2373,7 @@ declare const api: {
         userStore: UserStore;
     };
     journey: (options?: JourneyOptions | undefined) => {
+        change: (changeOptions: JourneyOptionsChange) => Promise<unknown>;
         start: (startOptions?: JourneyOptionsStart | undefined) => Promise<unknown>;
         subscribe: (this: void, run: Subscriber<{
             journey: JourneyStoreValue;
@@ -2258,6 +2402,7 @@ 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;
@@ -2273,9 +2418,8 @@ declare const component: () => {
     close: (args?: {
         reason: "auto" | "external" | "user";
     } | undefined) => void;
-    mount: (component: SvelteComponentDev$1, element: HTMLDialogElement) => void;
     open: () => void;
-    subscribe: (this: void, run: Subscriber<ComponentStoreValue>, invalidate?: ((value?: ComponentStoreValue | undefined) => void) | undefined) => Unsubscriber;
+    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: typeof HttpClient.request;
 declare const user: {
@@ -2293,7 +2437,6 @@ 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: {
         type?: "inline" | "modal" | undefined;