type Maybe<T> = T | null;
type InputMaybe<T> = T | null | undefined;
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
};
type AddModuleInput = {
    description?: InputMaybe<Scalars['String']>;
    name: Scalars['String'];
};
type AddOperationErrorInput = {
    errorCode?: InputMaybe<Scalars['String']>;
    errorDescription?: InputMaybe<Scalars['String']>;
    errorName?: InputMaybe<Scalars['String']>;
    errorTemplate?: InputMaybe<Scalars['String']>;
    operationId: Scalars['ID'];
};
type AddOperationExampleInput = {
    example: Scalars['String'];
    operationId: Scalars['ID'];
};
type AddOperationInput = {
    description?: InputMaybe<Scalars['String']>;
    moduleId: Scalars['ID'];
    name: Scalars['String'];
    reducer?: InputMaybe<Scalars['String']>;
    schema?: InputMaybe<Scalars['String']>;
    template?: InputMaybe<Scalars['String']>;
};
type AddStateExampleInput = {
    example: Scalars['String'];
    insertBefore?: InputMaybe<Scalars['ID']>;
};
type Author = {
    __typename?: 'Author';
    name: Scalars['String'];
    website: Maybe<Scalars['String']>;
};
type CodeExample = {
    __typename?: 'CodeExample';
    id: Scalars['ID'];
    value: Scalars['String'];
};
type DeleteModuleInput = {
    id: Scalars['ID'];
};
type DeleteOperationErrorInput = {
    id: Scalars['ID'];
};
type DeleteOperationExampleInput = {
    id: Scalars['ID'];
};
type DeleteOperationInput = {
    id: Scalars['ID'];
};
type DeleteStateExampleInput = {
    id: Scalars['ID'];
};
type DocumentModelInput = AddModuleInput | AddOperationErrorInput | AddOperationExampleInput | AddOperationInput | AddStateExampleInput | DeleteModuleInput | DeleteOperationErrorInput | DeleteOperationExampleInput | DeleteOperationInput | DeleteStateExampleInput | MoveOperationInput | ReorderModuleOperationsInput | ReorderModulesInput | ReorderOperationErrorsInput | ReorderOperationExamplesInput | ReorderStateExamplesInput | SetAuthorNameInput | SetAuthorWebsiteInput | SetModelDescriptionInput | SetModelExtensionInput | SetModelIdInput | SetModelNameInput | SetModuleDescriptionInput | SetModuleNameInput | SetOperationDescriptionInput | SetOperationErrorCodeInput | SetOperationErrorDescriptionInput | SetOperationErrorNameInput | SetOperationErrorTemplateInput | SetOperationNameInput | SetOperationReducerInput | SetOperationSchemaInput | SetOperationTemplateInput | SetStateSchemaInput | UpdateOperationExampleInput | UpdateStateExampleInput;
type DocumentModelState = {
    __typename?: 'DocumentModelState';
    author: Author;
    description: Scalars['String'];
    extension: Scalars['String'];
    id: Scalars['String'];
    modules: Array<Module>;
    name: Scalars['String'];
    state: State;
};
type Module = {
    __typename?: 'Module';
    description: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Scalars['String'];
    operations: Array<Operation>;
};
type MoveOperationInput = {
    newModuleId: Scalars['ID'];
    operationId: Scalars['ID'];
};
type Mutation = {
    __typename?: 'Mutation';
    addModule: Maybe<DocumentModelState>;
    addOperation: Maybe<DocumentModelState>;
    addOperationError: Maybe<DocumentModelState>;
    addOperationExample: Maybe<DocumentModelState>;
    addStateExample: Maybe<DocumentModelState>;
    deleteModule: Maybe<DocumentModelState>;
    deleteOperation: Maybe<DocumentModelState>;
    deleteOperationError: Maybe<DocumentModelState>;
    deleteOperationExample: Maybe<DocumentModelState>;
    deleteStateExample: Maybe<DocumentModelState>;
    moveOperation: Maybe<DocumentModelState>;
    reorderModuleOperations: Maybe<DocumentModelState>;
    reorderModules: Maybe<DocumentModelState>;
    reorderOperationErrors: Maybe<DocumentModelState>;
    reorderOperationExamples: Maybe<DocumentModelState>;
    reorderStateExamples: Maybe<DocumentModelState>;
    setAuthorName: Maybe<DocumentModelState>;
    setAuthorWebsite: Maybe<DocumentModelState>;
    setModelDescription: Maybe<DocumentModelState>;
    setModelExtension: Maybe<DocumentModelState>;
    setModelId: Maybe<DocumentModelState>;
    setModelName: Maybe<DocumentModelState>;
    setModuleDescription: Maybe<DocumentModelState>;
    setModuleName: Maybe<DocumentModelState>;
    setOperationDescription: Maybe<DocumentModelState>;
    setOperationErrorCode: Maybe<DocumentModelState>;
    setOperationErrorDescription: Maybe<DocumentModelState>;
    setOperationErrorName: Maybe<DocumentModelState>;
    setOperationErrorTemplate: Maybe<DocumentModelState>;
    setOperationName: Maybe<DocumentModelState>;
    setOperationReducer: Maybe<DocumentModelState>;
    setOperationSchema: Maybe<DocumentModelState>;
    setOperationTemplate: Maybe<DocumentModelState>;
    setStateSchema: Maybe<DocumentModelState>;
    updateOperationExample: Maybe<DocumentModelState>;
    updateStateExample: Maybe<DocumentModelState>;
};
type MutationAddModuleArgs = {
    input: AddModuleInput;
};
type MutationAddOperationArgs = {
    input: AddOperationInput;
};
type MutationAddOperationErrorArgs = {
    input: AddOperationErrorInput;
};
type MutationAddOperationExampleArgs = {
    input: AddOperationExampleInput;
};
type MutationAddStateExampleArgs = {
    input: AddStateExampleInput;
};
type MutationDeleteModuleArgs = {
    input: DeleteModuleInput;
};
type MutationDeleteOperationArgs = {
    input: DeleteOperationInput;
};
type MutationDeleteOperationErrorArgs = {
    input: DeleteOperationErrorInput;
};
type MutationDeleteOperationExampleArgs = {
    input: DeleteOperationExampleInput;
};
type MutationDeleteStateExampleArgs = {
    input: DeleteStateExampleInput;
};
type MutationMoveOperationArgs = {
    input: MoveOperationInput;
};
type MutationReorderModuleOperationsArgs = {
    input: ReorderModuleOperationsInput;
};
type MutationReorderModulesArgs = {
    input: ReorderModulesInput;
};
type MutationReorderOperationErrorsArgs = {
    input: ReorderOperationErrorsInput;
};
type MutationReorderOperationExamplesArgs = {
    input: ReorderOperationExamplesInput;
};
type MutationReorderStateExamplesArgs = {
    input: ReorderStateExamplesInput;
};
type MutationSetAuthorNameArgs = {
    input: SetAuthorNameInput;
};
type MutationSetAuthorWebsiteArgs = {
    input: SetAuthorWebsiteInput;
};
type MutationSetModelDescriptionArgs = {
    input: SetModelDescriptionInput;
};
type MutationSetModelExtensionArgs = {
    input: SetModelExtensionInput;
};
type MutationSetModelIdArgs = {
    input: SetModelIdInput;
};
type MutationSetModelNameArgs = {
    input: SetModelNameInput;
};
type MutationSetModuleDescriptionArgs = {
    input: SetModuleDescriptionInput;
};
type MutationSetModuleNameArgs = {
    input: SetModuleNameInput;
};
type MutationSetOperationDescriptionArgs = {
    input: SetOperationDescriptionInput;
};
type MutationSetOperationErrorCodeArgs = {
    input: SetOperationErrorCodeInput;
};
type MutationSetOperationErrorDescriptionArgs = {
    input: SetOperationErrorDescriptionInput;
};
type MutationSetOperationErrorNameArgs = {
    input: SetOperationErrorNameInput;
};
type MutationSetOperationErrorTemplateArgs = {
    input: SetOperationErrorTemplateInput;
};
type MutationSetOperationNameArgs = {
    input: SetOperationNameInput;
};
type MutationSetOperationReducerArgs = {
    input: SetOperationReducerInput;
};
type MutationSetOperationSchemaArgs = {
    input: SetOperationSchemaInput;
};
type MutationSetOperationTemplateArgs = {
    input: SetOperationTemplateInput;
};
type MutationSetStateSchemaArgs = {
    input: SetStateSchemaInput;
};
type MutationUpdateOperationExampleArgs = {
    input: UpdateOperationExampleInput;
};
type MutationUpdateStateExampleArgs = {
    input: UpdateStateExampleInput;
};
type Operation = {
    __typename?: 'Operation';
    description: Maybe<Scalars['String']>;
    errors: Array<OperationError>;
    examples: Array<CodeExample>;
    id: Scalars['ID'];
    name: Maybe<Scalars['String']>;
    reducer: Maybe<Scalars['String']>;
    schema: Maybe<Scalars['String']>;
    template: Maybe<Scalars['String']>;
};
type OperationError = {
    __typename?: 'OperationError';
    code: Maybe<Scalars['String']>;
    description: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Maybe<Scalars['String']>;
    template: Maybe<Scalars['String']>;
};
type ReorderModuleOperationsInput = {
    moduleId: Scalars['ID'];
    order: Array<Scalars['ID']>;
};
type ReorderModulesInput = {
    order: Array<Scalars['ID']>;
};
type ReorderOperationErrorsInput = {
    operationId: Scalars['ID'];
    order: Array<Scalars['ID']>;
};
type ReorderOperationExamplesInput = {
    operationId: Scalars['ID'];
    order: Array<Scalars['ID']>;
};
type ReorderStateExamplesInput = {
    order: Array<Scalars['ID']>;
};
type SetAuthorNameInput = {
    authorName: Scalars['String'];
};
type SetAuthorWebsiteInput = {
    authorWebsite: Scalars['String'];
};
type SetModelDescriptionInput = {
    description: Scalars['String'];
};
type SetModelExtensionInput = {
    extension: Scalars['String'];
};
type SetModelIdInput = {
    id: Scalars['String'];
};
type SetModelNameInput = {
    name: Scalars['String'];
};
type SetModuleDescriptionInput = {
    description?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetModuleNameInput = {
    id: Scalars['ID'];
    name?: InputMaybe<Scalars['String']>;
};
type SetOperationDescriptionInput = {
    description?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetOperationErrorCodeInput = {
    errorCode?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetOperationErrorDescriptionInput = {
    errorDescription?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetOperationErrorNameInput = {
    errorName?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetOperationErrorTemplateInput = {
    errorTemplate?: InputMaybe<Scalars['String']>;
    id: Scalars['ID'];
};
type SetOperationNameInput = {
    id: Scalars['ID'];
    name?: InputMaybe<Scalars['String']>;
};
type SetOperationReducerInput = {
    id: Scalars['ID'];
    reducer?: InputMaybe<Scalars['String']>;
};
type SetOperationSchemaInput = {
    id: Scalars['ID'];
    schema?: InputMaybe<Scalars['String']>;
};
type SetOperationTemplateInput = {
    id: Scalars['ID'];
    template?: InputMaybe<Scalars['String']>;
};
type SetStateSchemaInput = {
    schema: Scalars['String'];
};
type State = {
    __typename?: 'State';
    examples: Array<CodeExample>;
    schema: Scalars['String'];
};
type UpdateOperationExampleInput = {
    example: Scalars['String'];
    id: Scalars['ID'];
};
type UpdateStateExampleInput = {
    id: Scalars['ID'];
    newExample: Scalars['String'];
};

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;
    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
    export const getValidEnumValues: (obj: any) => any[];
    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> = 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";
    string: "string";
    nan: "nan";
    integer: "integer";
    float: "float";
    boolean: "boolean";
    date: "date";
    bigint: "bigint";
    symbol: "symbol";
    undefined: "undefined";
    null: "null";
    array: "array";
    object: "object";
    unknown: "unknown";
    promise: "promise";
    void: "void";
    never: "never";
    map: "map";
    set: "set";
};
declare type ZodParsedType = keyof typeof ZodParsedType;

declare type allKeys<T> = T extends any ? keyof T : never;
declare type typeToFlattenedError<T, U = string> = {
    formErrors: U[];
    fieldErrors: {
        [P in allKeys<T>]?: U[];
    };
};
declare const ZodIssueCode: {
    invalid_type: "invalid_type";
    invalid_literal: "invalid_literal";
    custom: "custom";
    invalid_union: "invalid_union";
    invalid_union_discriminator: "invalid_union_discriminator";
    invalid_enum_value: "invalid_enum_value";
    unrecognized_keys: "unrecognized_keys";
    invalid_arguments: "invalid_arguments";
    invalid_return_type: "invalid_return_type";
    invalid_date: "invalid_date";
    invalid_string: "invalid_string";
    too_small: "too_small";
    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 = {
    path: (string | number)[];
    message?: string;
};
interface ZodInvalidTypeIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_type;
    expected: ZodParsedType;
    received: ZodParsedType;
}
interface ZodInvalidLiteralIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_literal;
    expected: unknown;
    received: unknown;
}
interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.unrecognized_keys;
    keys: string[];
}
interface ZodInvalidUnionIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_union;
    unionErrors: ZodError[];
}
interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_union_discriminator;
    options: Primitive[];
}
interface ZodInvalidEnumValueIssue extends ZodIssueBase {
    received: string | number;
    code: typeof ZodIssueCode.invalid_enum_value;
    options: (string | number)[];
}
interface ZodInvalidArgumentsIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_arguments;
    argumentsError: ZodError;
}
interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_return_type;
    returnTypeError: ZodError;
}
interface ZodInvalidDateIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_date;
}
declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
    includes: string;
    position?: number;
} | {
    startsWith: string;
} | {
    endsWith: string;
};
interface ZodInvalidStringIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_string;
    validation: StringValidation;
}
interface ZodTooSmallIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.too_small;
    minimum: number | bigint;
    inclusive: boolean;
    exact?: boolean;
    type: "array" | "string" | "number" | "set" | "date" | "bigint";
}
interface ZodTooBigIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.too_big;
    maximum: number | bigint;
    inclusive: boolean;
    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 | bigint;
}
interface ZodNotFiniteIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.not_finite;
}
interface ZodCustomIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.custom;
    params?: {
        [k: string]: any;
    };
}
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 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;
declare type ZodFormattedError<T, U = string> = {
    _errors: U[];
} & recursiveZodFormattedError<NonNullable<T>>;
declare class ZodError<T = any> extends Error {
    issues: ZodIssue[];
    get errors(): ZodIssue[];
    constructor(issues: ZodIssue[]);
    format(): ZodFormattedError<T>;
    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
    static create: (issues: ZodIssue[]) => ZodError<any>;
    toString(): string;
    get message(): string;
    get isEmpty(): boolean;
    addIssue: (sub: ZodIssue) => void;
    addIssues: (subs?: ZodIssue[]) => void;
    flatten(): typeToFlattenedError<T>;
    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
    get formErrors(): typeToFlattenedError<T, string>;
}
declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
    path?: (string | number)[];
    fatal?: boolean;
};
declare type ErrorMapCtx = {
    defaultError: string;
    data: any;
};
declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
    message: string;
};

declare type ParseParams = {
    path: (string | number)[];
    errorMap: ZodErrorMap;
    async: boolean;
};
declare type ParsePathComponent = string | number;
declare type ParsePath = ParsePathComponent[];
interface ParseContext {
    readonly common: {
        readonly issues: ZodIssue[];
        readonly contextualErrorMap?: ZodErrorMap;
        readonly async: boolean;
    };
    readonly path: ParsePath;
    readonly schemaErrorMap?: ZodErrorMap;
    readonly parent: ParseContext | null;
    readonly data: any;
    readonly parsedType: ZodParsedType;
}
declare type ParseInput = {
    data: any;
    path: (string | number)[];
    parent: ParseContext;
};
declare class ParseStatus {
    value: "aborted" | "dirty" | "valid";
    dirty(): void;
    abort(): void;
    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
    static mergeObjectAsync(status: ParseStatus, pairs: {
        key: ParseReturnType<any>;
        value: ParseReturnType<any>;
    }[]): Promise<SyncParseReturnType<any>>;
    static mergeObjectSync(status: ParseStatus, pairs: {
        key: SyncParseReturnType<any>;
        value: SyncParseReturnType<any>;
        alwaysSet?: boolean;
    }[]): SyncParseReturnType;
}
declare type INVALID = {
    status: "aborted";
};
declare const INVALID: INVALID;
declare type DIRTY<T> = {
    status: "dirty";
    value: T;
};
declare const DIRTY: <T>(value: T) => DIRTY<T>;
declare type OK<T> = {
    status: "valid";
    value: T;
};
declare const OK: <T>(value: T) => OK<T>;
declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;

declare namespace enumUtil {
    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
    export {};
}

declare namespace errorUtil {
    type ErrMessage = string | {
        message?: string;
    };
    const errToObj: (message?: ErrMessage | undefined) => {
        message?: string | undefined;
    };
    const toString: (message?: ErrMessage | undefined) => string | undefined;
}

declare namespace partialUtil {
    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;
}

declare type RefinementCtx = {
    addIssue: (arg: IssueData) => void;
    path: (string | number)[];
};
declare type ZodRawShape = {
    [k: string]: ZodTypeAny;
};
declare type ZodTypeAny = ZodType<any, any, any>;
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;
    description?: string;
}
declare type RawCreateParams = {
    errorMap?: ZodErrorMap;
    invalid_type_error?: string;
    required_error?: string;
    description?: string;
} | undefined;
declare type SafeParseSuccess<Output> = {
    success: true;
    data: Output;
};
declare type SafeParseError<Input> = {
    success: false;
    error: ZodError<Input>;
};
declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
    readonly _type: Output;
    readonly _output: Output;
    readonly _input: Input;
    readonly _def: Def;
    get description(): string | undefined;
    abstract _parse(input: ParseInput): ParseReturnType<Output>;
    _getType(input: ParseInput): string;
    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
    _processInputParams(input: ParseInput): {
        status: ParseStatus;
        ctx: ParseContext;
    };
    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
    parse(data: unknown, params?: Partial<ParseParams>): Output;
    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>>;
    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<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(): ZodOptional<ZodNullable<this>>;
    array(): ZodArray<this>;
    promise(): ZodPromise<this>;
    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
    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>(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;
}
interface ZodAnyDef extends ZodTypeDef {
    typeName: ZodFirstPartyTypeKind.ZodAny;
}
declare class ZodAny extends ZodType<any, ZodAnyDef> {
    _any: true;
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: (params?: RawCreateParams) => ZodAny;
}
interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    type: T;
    typeName: ZodFirstPartyTypeKind.ZodArray;
    exactLength: {
        value: number;
        message?: string;
    } | null;
    minLength: {
        value: number;
        message?: string;
    } | null;
    maxLength: {
        value: number;
        message?: string;
    } | null;
}
declare type ArrayCardinality = "many" | "atleastone";
declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get element(): T;
    min(minLength: number, message?: errorUtil.ErrMessage): this;
    max(maxLength: number, message?: errorUtil.ErrMessage): this;
    length(len: number, message?: errorUtil.ErrMessage): this;
    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
}
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;
    shape: () => T;
    catchall: Catchall;
    unknownKeys: UnknownKeys;
}
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 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 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;
        keys: string[];
    };
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get shape(): T;
    strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
    strip(): ZodObject<T, "strip", Catchall>;
    passthrough(): ZodObject<T, "passthrough", Catchall>;
    nonstrict: () => ZodObject<T, "passthrough", 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>;
    catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
    pick<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
    omit<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
    deepPartial(): partialUtil.DeepPartial<this>;
    partial(): ZodObject<{
        [k in keyof T]: ZodOptional<T[k]>;
    }, UnknownKeys, Catchall>;
    partial<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): ZodObject<objectUtil.noNever<{
        [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
    }>, UnknownKeys, Catchall>;
    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<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[]]>;
interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
    ZodTypeAny,
    ZodTypeAny,
    ...ZodTypeAny[]
]>> extends ZodTypeDef {
    options: T;
    typeName: ZodFirstPartyTypeKind.ZodUnion;
}
declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get options(): T;
    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
}
interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    left: T;
    right: U;
    typeName: ZodFirstPartyTypeKind.ZodIntersection;
}
declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
}
declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
declare type AssertArray<T> = T extends any[] ? T : never;
declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
}>;
declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_input"] : never;
}>;
declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
    items: T;
    rest: Rest;
    typeName: ZodFirstPartyTypeKind.ZodTuple;
}
declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get items(): T;
    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
}
declare type EnumValues = [string, ...string[]];
declare type Values<T extends EnumValues> = {
    [k in T[number]]: k;
};
interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
    values: T;
    typeName: ZodFirstPartyTypeKind.ZodEnum;
}
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>> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get options(): T;
    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 ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    type: T;
    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>;
}
declare type RefinementEffect<T> = {
    type: "refinement";
    refinement: (arg: T, ctx: RefinementCtx) => any;
};
declare type TransformEffect<T> = {
    type: "transform";
    transform: (arg: T, ctx: RefinementCtx) => any;
};
declare type PreprocessEffect<T> = {
    type: "preprocess";
    transform: (arg: T) => any;
};
declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    schema: T;
    typeName: ZodFirstPartyTypeKind.ZodEffects;
    effect: Effect<any>;
}
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"], input<I>>;
    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
}

interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    typeName: ZodFirstPartyTypeKind.ZodOptional;
}
declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    unwrap(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
}
interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    typeName: ZodFirstPartyTypeKind.ZodNullable;
}
declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    unwrap(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
}
interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    defaultValue: () => util.noUndefined<T["_input"]>;
    typeName: ZodFirstPartyTypeKind.ZodDefault;
}
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: {
        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;
    typeName: ZodFirstPartyTypeKind.ZodBranded;
}
declare const BRAND: unique symbol;
declare type BRAND<T extends string | number | symbol> = {
    [BRAND]: {
        [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"]> {
    _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",
    ZodNaN = "ZodNaN",
    ZodBigInt = "ZodBigInt",
    ZodBoolean = "ZodBoolean",
    ZodDate = "ZodDate",
    ZodSymbol = "ZodSymbol",
    ZodUndefined = "ZodUndefined",
    ZodNull = "ZodNull",
    ZodAny = "ZodAny",
    ZodUnknown = "ZodUnknown",
    ZodNever = "ZodNever",
    ZodVoid = "ZodVoid",
    ZodArray = "ZodArray",
    ZodObject = "ZodObject",
    ZodUnion = "ZodUnion",
    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
    ZodIntersection = "ZodIntersection",
    ZodTuple = "ZodTuple",
    ZodRecord = "ZodRecord",
    ZodMap = "ZodMap",
    ZodSet = "ZodSet",
    ZodFunction = "ZodFunction",
    ZodLazy = "ZodLazy",
    ZodLiteral = "ZodLiteral",
    ZodEnum = "ZodEnum",
    ZodEffects = "ZodEffects",
    ZodNativeEnum = "ZodNativeEnum",
    ZodOptional = "ZodOptional",
    ZodNullable = "ZodNullable",
    ZodDefault = "ZodDefault",
    ZodCatch = "ZodCatch",
    ZodPromise = "ZodPromise",
    ZodBranded = "ZodBranded",
    ZodPipeline = "ZodPipeline"
}

type Properties<T> = Required<{
    [K in keyof T]: ZodType<T[K], any, T[K]>;
}>;
type definedNonNullAny = {};
declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
declare const definedNonNullAnySchema: ZodEffects<ZodAny, any, any>;
declare function AddModuleInputSchema(): ZodObject<Properties<AddModuleInput>>;
declare function AddOperationErrorInputSchema(): ZodObject<Properties<AddOperationErrorInput>>;
declare function AddOperationExampleInputSchema(): ZodObject<Properties<AddOperationExampleInput>>;
declare function AddOperationInputSchema(): ZodObject<Properties<AddOperationInput>>;
declare function AddStateExampleInputSchema(): ZodObject<Properties<AddStateExampleInput>>;
declare function AuthorSchema(): ZodObject<Properties<Author>>;
declare function CodeExampleSchema(): ZodObject<Properties<CodeExample>>;
declare function DeleteModuleInputSchema(): ZodObject<Properties<DeleteModuleInput>>;
declare function DeleteOperationErrorInputSchema(): ZodObject<Properties<DeleteOperationErrorInput>>;
declare function DeleteOperationExampleInputSchema(): ZodObject<Properties<DeleteOperationExampleInput>>;
declare function DeleteOperationInputSchema(): ZodObject<Properties<DeleteOperationInput>>;
declare function DeleteStateExampleInputSchema(): ZodObject<Properties<DeleteStateExampleInput>>;
declare function DocumentModelInputSchema(): ZodUnion<[ZodObject<Required<{
    description?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    name: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    name: string;
    description?: InputMaybe<string>;
}, {
    name: string;
    description?: InputMaybe<string>;
}>, ZodObject<Required<{
    errorCode?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    errorDescription?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    errorName?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    errorTemplate?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    operationId: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    operationId: string;
    errorCode?: InputMaybe<string>;
    errorDescription?: InputMaybe<string>;
    errorName?: InputMaybe<string>;
    errorTemplate?: InputMaybe<string>;
}, {
    operationId: string;
    errorCode?: InputMaybe<string>;
    errorDescription?: InputMaybe<string>;
    errorName?: InputMaybe<string>;
    errorTemplate?: InputMaybe<string>;
}>, ZodObject<Required<{
    example: ZodType<string, any, string>;
    operationId: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    operationId: string;
    example: string;
}, {
    operationId: string;
    example: string;
}>, ZodObject<Required<{
    description?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    moduleId: ZodType<string, any, string>;
    name: ZodType<string, any, string>;
    reducer?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    schema?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    template?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    name: string;
    moduleId: string;
    description?: InputMaybe<string>;
    reducer?: InputMaybe<string>;
    schema?: InputMaybe<string>;
    template?: InputMaybe<string>;
}, {
    name: string;
    moduleId: string;
    description?: InputMaybe<string>;
    reducer?: InputMaybe<string>;
    schema?: InputMaybe<string>;
    template?: InputMaybe<string>;
}>, ZodObject<Required<{
    example: ZodType<string, any, string>;
    insertBefore?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    example: string;
    insertBefore?: InputMaybe<string>;
}, {
    example: string;
    insertBefore?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    newModuleId: ZodType<string, any, string>;
    operationId: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    operationId: string;
    newModuleId: string;
}, {
    operationId: string;
    newModuleId: string;
}>, ZodObject<Required<{
    moduleId: ZodType<string, any, string>;
    order: ZodType<string[], any, string[]>;
}>, UnknownKeysParam, ZodTypeAny, {
    moduleId: string;
    order: string[];
}, {
    moduleId: string;
    order: string[];
}>, ZodObject<Required<{
    order: ZodType<string[], any, string[]>;
}>, UnknownKeysParam, ZodTypeAny, {
    order: string[];
}, {
    order: string[];
}>, ZodObject<Required<{
    operationId: ZodType<string, any, string>;
    order: ZodType<string[], any, string[]>;
}>, UnknownKeysParam, ZodTypeAny, {
    operationId: string;
    order: string[];
}, {
    operationId: string;
    order: string[];
}>, ZodObject<Required<{
    operationId: ZodType<string, any, string>;
    order: ZodType<string[], any, string[]>;
}>, UnknownKeysParam, ZodTypeAny, {
    operationId: string;
    order: string[];
}, {
    operationId: string;
    order: string[];
}>, ZodObject<Required<{
    order: ZodType<string[], any, string[]>;
}>, UnknownKeysParam, ZodTypeAny, {
    order: string[];
}, {
    order: string[];
}>, ZodObject<Required<{
    authorName: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    authorName: string;
}, {
    authorName: string;
}>, ZodObject<Required<{
    authorWebsite: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    authorWebsite: string;
}, {
    authorWebsite: string;
}>, ZodObject<Required<{
    description: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    description: string;
}, {
    description: string;
}>, ZodObject<Required<{
    extension: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    extension: string;
}, {
    extension: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
}, {
    id: string;
}>, ZodObject<Required<{
    name: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    name: string;
}, {
    name: string;
}>, ZodObject<Required<{
    description?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    description?: InputMaybe<string>;
}, {
    id: string;
    description?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    name?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    name?: InputMaybe<string>;
}, {
    id: string;
    name?: InputMaybe<string>;
}>, ZodObject<Required<{
    description?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    description?: InputMaybe<string>;
}, {
    id: string;
    description?: InputMaybe<string>;
}>, ZodObject<Required<{
    errorCode?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    errorCode?: InputMaybe<string>;
}, {
    id: string;
    errorCode?: InputMaybe<string>;
}>, ZodObject<Required<{
    errorDescription?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    errorDescription?: InputMaybe<string>;
}, {
    id: string;
    errorDescription?: InputMaybe<string>;
}>, ZodObject<Required<{
    errorName?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    errorName?: InputMaybe<string>;
}, {
    id: string;
    errorName?: InputMaybe<string>;
}>, ZodObject<Required<{
    errorTemplate?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    errorTemplate?: InputMaybe<string>;
}, {
    id: string;
    errorTemplate?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    name?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    name?: InputMaybe<string>;
}, {
    id: string;
    name?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    reducer?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    reducer?: InputMaybe<string>;
}, {
    id: string;
    reducer?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    schema?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    schema?: InputMaybe<string>;
}, {
    id: string;
    schema?: InputMaybe<string>;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    template?: ZodType<InputMaybe<string>, any, InputMaybe<string>> | undefined;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    template?: InputMaybe<string>;
}, {
    id: string;
    template?: InputMaybe<string>;
}>, ZodObject<Required<{
    schema: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    schema: string;
}, {
    schema: string;
}>, ZodObject<Required<{
    example: ZodType<string, any, string>;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    example: string;
}, {
    id: string;
    example: string;
}>, ZodObject<Required<{
    id: ZodType<string, any, string>;
    newExample: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    newExample: string;
}, {
    id: string;
    newExample: string;
}>]>;
declare function DocumentModelStateSchema(): ZodObject<Properties<DocumentModelState>>;
declare function ModuleSchema(): ZodObject<Properties<Module>>;
declare function MoveOperationInputSchema(): ZodObject<Properties<MoveOperationInput>>;
declare function OperationSchema(): ZodObject<Properties<Operation>>;
declare function OperationErrorSchema(): ZodObject<Properties<OperationError>>;
declare function ReorderModuleOperationsInputSchema(): ZodObject<Properties<ReorderModuleOperationsInput>>;
declare function ReorderModulesInputSchema(): ZodObject<Properties<ReorderModulesInput>>;
declare function ReorderOperationErrorsInputSchema(): ZodObject<Properties<ReorderOperationErrorsInput>>;
declare function ReorderOperationExamplesInputSchema(): ZodObject<Properties<ReorderOperationExamplesInput>>;
declare function ReorderStateExamplesInputSchema(): ZodObject<Properties<ReorderStateExamplesInput>>;
declare function SetAuthorNameInputSchema(): ZodObject<Properties<SetAuthorNameInput>>;
declare function SetAuthorWebsiteInputSchema(): ZodObject<Properties<SetAuthorWebsiteInput>>;
declare function SetModelDescriptionInputSchema(): ZodObject<Properties<SetModelDescriptionInput>>;
declare function SetModelExtensionInputSchema(): ZodObject<Properties<SetModelExtensionInput>>;
declare function SetModelIdInputSchema(): ZodObject<Properties<SetModelIdInput>>;
declare function SetModelNameInputSchema(): ZodObject<Properties<SetModelNameInput>>;
declare function SetModuleDescriptionInputSchema(): ZodObject<Properties<SetModuleDescriptionInput>>;
declare function SetModuleNameInputSchema(): ZodObject<Properties<SetModuleNameInput>>;
declare function SetOperationDescriptionInputSchema(): ZodObject<Properties<SetOperationDescriptionInput>>;
declare function SetOperationErrorCodeInputSchema(): ZodObject<Properties<SetOperationErrorCodeInput>>;
declare function SetOperationErrorDescriptionInputSchema(): ZodObject<Properties<SetOperationErrorDescriptionInput>>;
declare function SetOperationErrorNameInputSchema(): ZodObject<Properties<SetOperationErrorNameInput>>;
declare function SetOperationErrorTemplateInputSchema(): ZodObject<Properties<SetOperationErrorTemplateInput>>;
declare function SetOperationNameInputSchema(): ZodObject<Properties<SetOperationNameInput>>;
declare function SetOperationReducerInputSchema(): ZodObject<Properties<SetOperationReducerInput>>;
declare function SetOperationSchemaInputSchema(): ZodObject<Properties<SetOperationSchemaInput>>;
declare function SetOperationTemplateInputSchema(): ZodObject<Properties<SetOperationTemplateInput>>;
declare function SetStateSchemaInputSchema(): ZodObject<Properties<SetStateSchemaInput>>;
declare function StateSchema(): ZodObject<Properties<State>>;
declare function UpdateOperationExampleInputSchema(): ZodObject<Properties<UpdateOperationExampleInput>>;
declare function UpdateStateExampleInputSchema(): ZodObject<Properties<UpdateStateExampleInput>>;

declare const zod_d_AddModuleInputSchema: typeof AddModuleInputSchema;
declare const zod_d_AddOperationErrorInputSchema: typeof AddOperationErrorInputSchema;
declare const zod_d_AddOperationExampleInputSchema: typeof AddOperationExampleInputSchema;
declare const zod_d_AddOperationInputSchema: typeof AddOperationInputSchema;
declare const zod_d_AddStateExampleInputSchema: typeof AddStateExampleInputSchema;
declare const zod_d_AuthorSchema: typeof AuthorSchema;
declare const zod_d_CodeExampleSchema: typeof CodeExampleSchema;
declare const zod_d_DeleteModuleInputSchema: typeof DeleteModuleInputSchema;
declare const zod_d_DeleteOperationErrorInputSchema: typeof DeleteOperationErrorInputSchema;
declare const zod_d_DeleteOperationExampleInputSchema: typeof DeleteOperationExampleInputSchema;
declare const zod_d_DeleteOperationInputSchema: typeof DeleteOperationInputSchema;
declare const zod_d_DeleteStateExampleInputSchema: typeof DeleteStateExampleInputSchema;
declare const zod_d_DocumentModelInputSchema: typeof DocumentModelInputSchema;
declare const zod_d_DocumentModelStateSchema: typeof DocumentModelStateSchema;
declare const zod_d_ModuleSchema: typeof ModuleSchema;
declare const zod_d_MoveOperationInputSchema: typeof MoveOperationInputSchema;
declare const zod_d_OperationErrorSchema: typeof OperationErrorSchema;
declare const zod_d_OperationSchema: typeof OperationSchema;
declare const zod_d_ReorderModuleOperationsInputSchema: typeof ReorderModuleOperationsInputSchema;
declare const zod_d_ReorderModulesInputSchema: typeof ReorderModulesInputSchema;
declare const zod_d_ReorderOperationErrorsInputSchema: typeof ReorderOperationErrorsInputSchema;
declare const zod_d_ReorderOperationExamplesInputSchema: typeof ReorderOperationExamplesInputSchema;
declare const zod_d_ReorderStateExamplesInputSchema: typeof ReorderStateExamplesInputSchema;
declare const zod_d_SetAuthorNameInputSchema: typeof SetAuthorNameInputSchema;
declare const zod_d_SetAuthorWebsiteInputSchema: typeof SetAuthorWebsiteInputSchema;
declare const zod_d_SetModelDescriptionInputSchema: typeof SetModelDescriptionInputSchema;
declare const zod_d_SetModelExtensionInputSchema: typeof SetModelExtensionInputSchema;
declare const zod_d_SetModelIdInputSchema: typeof SetModelIdInputSchema;
declare const zod_d_SetModelNameInputSchema: typeof SetModelNameInputSchema;
declare const zod_d_SetModuleDescriptionInputSchema: typeof SetModuleDescriptionInputSchema;
declare const zod_d_SetModuleNameInputSchema: typeof SetModuleNameInputSchema;
declare const zod_d_SetOperationDescriptionInputSchema: typeof SetOperationDescriptionInputSchema;
declare const zod_d_SetOperationErrorCodeInputSchema: typeof SetOperationErrorCodeInputSchema;
declare const zod_d_SetOperationErrorDescriptionInputSchema: typeof SetOperationErrorDescriptionInputSchema;
declare const zod_d_SetOperationErrorNameInputSchema: typeof SetOperationErrorNameInputSchema;
declare const zod_d_SetOperationErrorTemplateInputSchema: typeof SetOperationErrorTemplateInputSchema;
declare const zod_d_SetOperationNameInputSchema: typeof SetOperationNameInputSchema;
declare const zod_d_SetOperationReducerInputSchema: typeof SetOperationReducerInputSchema;
declare const zod_d_SetOperationSchemaInputSchema: typeof SetOperationSchemaInputSchema;
declare const zod_d_SetOperationTemplateInputSchema: typeof SetOperationTemplateInputSchema;
declare const zod_d_SetStateSchemaInputSchema: typeof SetStateSchemaInputSchema;
declare const zod_d_StateSchema: typeof StateSchema;
declare const zod_d_UpdateOperationExampleInputSchema: typeof UpdateOperationExampleInputSchema;
declare const zod_d_UpdateStateExampleInputSchema: typeof UpdateStateExampleInputSchema;
declare const zod_d_definedNonNullAnySchema: typeof definedNonNullAnySchema;
declare const zod_d_isDefinedNonNullAny: typeof isDefinedNonNullAny;
declare namespace zod_d {
  export {
    zod_d_AddModuleInputSchema as AddModuleInputSchema,
    zod_d_AddOperationErrorInputSchema as AddOperationErrorInputSchema,
    zod_d_AddOperationExampleInputSchema as AddOperationExampleInputSchema,
    zod_d_AddOperationInputSchema as AddOperationInputSchema,
    zod_d_AddStateExampleInputSchema as AddStateExampleInputSchema,
    zod_d_AuthorSchema as AuthorSchema,
    zod_d_CodeExampleSchema as CodeExampleSchema,
    zod_d_DeleteModuleInputSchema as DeleteModuleInputSchema,
    zod_d_DeleteOperationErrorInputSchema as DeleteOperationErrorInputSchema,
    zod_d_DeleteOperationExampleInputSchema as DeleteOperationExampleInputSchema,
    zod_d_DeleteOperationInputSchema as DeleteOperationInputSchema,
    zod_d_DeleteStateExampleInputSchema as DeleteStateExampleInputSchema,
    zod_d_DocumentModelInputSchema as DocumentModelInputSchema,
    zod_d_DocumentModelStateSchema as DocumentModelStateSchema,
    zod_d_ModuleSchema as ModuleSchema,
    zod_d_MoveOperationInputSchema as MoveOperationInputSchema,
    zod_d_OperationErrorSchema as OperationErrorSchema,
    zod_d_OperationSchema as OperationSchema,
    zod_d_ReorderModuleOperationsInputSchema as ReorderModuleOperationsInputSchema,
    zod_d_ReorderModulesInputSchema as ReorderModulesInputSchema,
    zod_d_ReorderOperationErrorsInputSchema as ReorderOperationErrorsInputSchema,
    zod_d_ReorderOperationExamplesInputSchema as ReorderOperationExamplesInputSchema,
    zod_d_ReorderStateExamplesInputSchema as ReorderStateExamplesInputSchema,
    zod_d_SetAuthorNameInputSchema as SetAuthorNameInputSchema,
    zod_d_SetAuthorWebsiteInputSchema as SetAuthorWebsiteInputSchema,
    zod_d_SetModelDescriptionInputSchema as SetModelDescriptionInputSchema,
    zod_d_SetModelExtensionInputSchema as SetModelExtensionInputSchema,
    zod_d_SetModelIdInputSchema as SetModelIdInputSchema,
    zod_d_SetModelNameInputSchema as SetModelNameInputSchema,
    zod_d_SetModuleDescriptionInputSchema as SetModuleDescriptionInputSchema,
    zod_d_SetModuleNameInputSchema as SetModuleNameInputSchema,
    zod_d_SetOperationDescriptionInputSchema as SetOperationDescriptionInputSchema,
    zod_d_SetOperationErrorCodeInputSchema as SetOperationErrorCodeInputSchema,
    zod_d_SetOperationErrorDescriptionInputSchema as SetOperationErrorDescriptionInputSchema,
    zod_d_SetOperationErrorNameInputSchema as SetOperationErrorNameInputSchema,
    zod_d_SetOperationErrorTemplateInputSchema as SetOperationErrorTemplateInputSchema,
    zod_d_SetOperationNameInputSchema as SetOperationNameInputSchema,
    zod_d_SetOperationReducerInputSchema as SetOperationReducerInputSchema,
    zod_d_SetOperationSchemaInputSchema as SetOperationSchemaInputSchema,
    zod_d_SetOperationTemplateInputSchema as SetOperationTemplateInputSchema,
    zod_d_SetStateSchemaInputSchema as SetStateSchemaInputSchema,
    zod_d_StateSchema as StateSchema,
    zod_d_UpdateOperationExampleInputSchema as UpdateOperationExampleInputSchema,
    zod_d_UpdateStateExampleInputSchema as UpdateStateExampleInputSchema,
    zod_d_definedNonNullAnySchema as definedNonNullAnySchema,
    zod_d_isDefinedNonNullAny as isDefinedNonNullAny,
  };
}

type index_d_AddModuleInput = AddModuleInput;
type index_d_AddOperationErrorInput = AddOperationErrorInput;
type index_d_AddOperationExampleInput = AddOperationExampleInput;
type index_d_AddOperationInput = AddOperationInput;
type index_d_AddStateExampleInput = AddStateExampleInput;
type index_d_Author = Author;
type index_d_CodeExample = CodeExample;
type index_d_DeleteModuleInput = DeleteModuleInput;
type index_d_DeleteOperationErrorInput = DeleteOperationErrorInput;
type index_d_DeleteOperationExampleInput = DeleteOperationExampleInput;
type index_d_DeleteOperationInput = DeleteOperationInput;
type index_d_DeleteStateExampleInput = DeleteStateExampleInput;
type index_d_DocumentModelInput = DocumentModelInput;
type index_d_DocumentModelState = DocumentModelState;
type index_d_Exact<T extends {
    [key: string]: unknown;
}> = Exact<T>;
type index_d_InputMaybe<T> = InputMaybe<T>;
type index_d_MakeMaybe<T, K extends keyof T> = MakeMaybe<T, K>;
type index_d_MakeOptional<T, K extends keyof T> = MakeOptional<T, K>;
type index_d_Maybe<T> = Maybe<T>;
type index_d_Module = Module;
type index_d_MoveOperationInput = MoveOperationInput;
type index_d_Mutation = Mutation;
type index_d_MutationAddModuleArgs = MutationAddModuleArgs;
type index_d_MutationAddOperationArgs = MutationAddOperationArgs;
type index_d_MutationAddOperationErrorArgs = MutationAddOperationErrorArgs;
type index_d_MutationAddOperationExampleArgs = MutationAddOperationExampleArgs;
type index_d_MutationAddStateExampleArgs = MutationAddStateExampleArgs;
type index_d_MutationDeleteModuleArgs = MutationDeleteModuleArgs;
type index_d_MutationDeleteOperationArgs = MutationDeleteOperationArgs;
type index_d_MutationDeleteOperationErrorArgs = MutationDeleteOperationErrorArgs;
type index_d_MutationDeleteOperationExampleArgs = MutationDeleteOperationExampleArgs;
type index_d_MutationDeleteStateExampleArgs = MutationDeleteStateExampleArgs;
type index_d_MutationMoveOperationArgs = MutationMoveOperationArgs;
type index_d_MutationReorderModuleOperationsArgs = MutationReorderModuleOperationsArgs;
type index_d_MutationReorderModulesArgs = MutationReorderModulesArgs;
type index_d_MutationReorderOperationErrorsArgs = MutationReorderOperationErrorsArgs;
type index_d_MutationReorderOperationExamplesArgs = MutationReorderOperationExamplesArgs;
type index_d_MutationReorderStateExamplesArgs = MutationReorderStateExamplesArgs;
type index_d_MutationSetAuthorNameArgs = MutationSetAuthorNameArgs;
type index_d_MutationSetAuthorWebsiteArgs = MutationSetAuthorWebsiteArgs;
type index_d_MutationSetModelDescriptionArgs = MutationSetModelDescriptionArgs;
type index_d_MutationSetModelExtensionArgs = MutationSetModelExtensionArgs;
type index_d_MutationSetModelIdArgs = MutationSetModelIdArgs;
type index_d_MutationSetModelNameArgs = MutationSetModelNameArgs;
type index_d_MutationSetModuleDescriptionArgs = MutationSetModuleDescriptionArgs;
type index_d_MutationSetModuleNameArgs = MutationSetModuleNameArgs;
type index_d_MutationSetOperationDescriptionArgs = MutationSetOperationDescriptionArgs;
type index_d_MutationSetOperationErrorCodeArgs = MutationSetOperationErrorCodeArgs;
type index_d_MutationSetOperationErrorDescriptionArgs = MutationSetOperationErrorDescriptionArgs;
type index_d_MutationSetOperationErrorNameArgs = MutationSetOperationErrorNameArgs;
type index_d_MutationSetOperationErrorTemplateArgs = MutationSetOperationErrorTemplateArgs;
type index_d_MutationSetOperationNameArgs = MutationSetOperationNameArgs;
type index_d_MutationSetOperationReducerArgs = MutationSetOperationReducerArgs;
type index_d_MutationSetOperationSchemaArgs = MutationSetOperationSchemaArgs;
type index_d_MutationSetOperationTemplateArgs = MutationSetOperationTemplateArgs;
type index_d_MutationSetStateSchemaArgs = MutationSetStateSchemaArgs;
type index_d_MutationUpdateOperationExampleArgs = MutationUpdateOperationExampleArgs;
type index_d_MutationUpdateStateExampleArgs = MutationUpdateStateExampleArgs;
type index_d_Operation = Operation;
type index_d_OperationError = OperationError;
type index_d_ReorderModuleOperationsInput = ReorderModuleOperationsInput;
type index_d_ReorderModulesInput = ReorderModulesInput;
type index_d_ReorderOperationErrorsInput = ReorderOperationErrorsInput;
type index_d_ReorderOperationExamplesInput = ReorderOperationExamplesInput;
type index_d_ReorderStateExamplesInput = ReorderStateExamplesInput;
type index_d_Scalars = Scalars;
type index_d_SetAuthorNameInput = SetAuthorNameInput;
type index_d_SetAuthorWebsiteInput = SetAuthorWebsiteInput;
type index_d_SetModelDescriptionInput = SetModelDescriptionInput;
type index_d_SetModelExtensionInput = SetModelExtensionInput;
type index_d_SetModelIdInput = SetModelIdInput;
type index_d_SetModelNameInput = SetModelNameInput;
type index_d_SetModuleDescriptionInput = SetModuleDescriptionInput;
type index_d_SetModuleNameInput = SetModuleNameInput;
type index_d_SetOperationDescriptionInput = SetOperationDescriptionInput;
type index_d_SetOperationErrorCodeInput = SetOperationErrorCodeInput;
type index_d_SetOperationErrorDescriptionInput = SetOperationErrorDescriptionInput;
type index_d_SetOperationErrorNameInput = SetOperationErrorNameInput;
type index_d_SetOperationErrorTemplateInput = SetOperationErrorTemplateInput;
type index_d_SetOperationNameInput = SetOperationNameInput;
type index_d_SetOperationReducerInput = SetOperationReducerInput;
type index_d_SetOperationSchemaInput = SetOperationSchemaInput;
type index_d_SetOperationTemplateInput = SetOperationTemplateInput;
type index_d_SetStateSchemaInput = SetStateSchemaInput;
type index_d_State = State;
type index_d_UpdateOperationExampleInput = UpdateOperationExampleInput;
type index_d_UpdateStateExampleInput = UpdateStateExampleInput;
declare namespace index_d {
  export {
    index_d_AddModuleInput as AddModuleInput,
    index_d_AddOperationErrorInput as AddOperationErrorInput,
    index_d_AddOperationExampleInput as AddOperationExampleInput,
    index_d_AddOperationInput as AddOperationInput,
    index_d_AddStateExampleInput as AddStateExampleInput,
    index_d_Author as Author,
    index_d_CodeExample as CodeExample,
    index_d_DeleteModuleInput as DeleteModuleInput,
    index_d_DeleteOperationErrorInput as DeleteOperationErrorInput,
    index_d_DeleteOperationExampleInput as DeleteOperationExampleInput,
    index_d_DeleteOperationInput as DeleteOperationInput,
    index_d_DeleteStateExampleInput as DeleteStateExampleInput,
    index_d_DocumentModelInput as DocumentModelInput,
    index_d_DocumentModelState as DocumentModelState,
    index_d_Exact as Exact,
    index_d_InputMaybe as InputMaybe,
    index_d_MakeMaybe as MakeMaybe,
    index_d_MakeOptional as MakeOptional,
    index_d_Maybe as Maybe,
    index_d_Module as Module,
    index_d_MoveOperationInput as MoveOperationInput,
    index_d_Mutation as Mutation,
    index_d_MutationAddModuleArgs as MutationAddModuleArgs,
    index_d_MutationAddOperationArgs as MutationAddOperationArgs,
    index_d_MutationAddOperationErrorArgs as MutationAddOperationErrorArgs,
    index_d_MutationAddOperationExampleArgs as MutationAddOperationExampleArgs,
    index_d_MutationAddStateExampleArgs as MutationAddStateExampleArgs,
    index_d_MutationDeleteModuleArgs as MutationDeleteModuleArgs,
    index_d_MutationDeleteOperationArgs as MutationDeleteOperationArgs,
    index_d_MutationDeleteOperationErrorArgs as MutationDeleteOperationErrorArgs,
    index_d_MutationDeleteOperationExampleArgs as MutationDeleteOperationExampleArgs,
    index_d_MutationDeleteStateExampleArgs as MutationDeleteStateExampleArgs,
    index_d_MutationMoveOperationArgs as MutationMoveOperationArgs,
    index_d_MutationReorderModuleOperationsArgs as MutationReorderModuleOperationsArgs,
    index_d_MutationReorderModulesArgs as MutationReorderModulesArgs,
    index_d_MutationReorderOperationErrorsArgs as MutationReorderOperationErrorsArgs,
    index_d_MutationReorderOperationExamplesArgs as MutationReorderOperationExamplesArgs,
    index_d_MutationReorderStateExamplesArgs as MutationReorderStateExamplesArgs,
    index_d_MutationSetAuthorNameArgs as MutationSetAuthorNameArgs,
    index_d_MutationSetAuthorWebsiteArgs as MutationSetAuthorWebsiteArgs,
    index_d_MutationSetModelDescriptionArgs as MutationSetModelDescriptionArgs,
    index_d_MutationSetModelExtensionArgs as MutationSetModelExtensionArgs,
    index_d_MutationSetModelIdArgs as MutationSetModelIdArgs,
    index_d_MutationSetModelNameArgs as MutationSetModelNameArgs,
    index_d_MutationSetModuleDescriptionArgs as MutationSetModuleDescriptionArgs,
    index_d_MutationSetModuleNameArgs as MutationSetModuleNameArgs,
    index_d_MutationSetOperationDescriptionArgs as MutationSetOperationDescriptionArgs,
    index_d_MutationSetOperationErrorCodeArgs as MutationSetOperationErrorCodeArgs,
    index_d_MutationSetOperationErrorDescriptionArgs as MutationSetOperationErrorDescriptionArgs,
    index_d_MutationSetOperationErrorNameArgs as MutationSetOperationErrorNameArgs,
    index_d_MutationSetOperationErrorTemplateArgs as MutationSetOperationErrorTemplateArgs,
    index_d_MutationSetOperationNameArgs as MutationSetOperationNameArgs,
    index_d_MutationSetOperationReducerArgs as MutationSetOperationReducerArgs,
    index_d_MutationSetOperationSchemaArgs as MutationSetOperationSchemaArgs,
    index_d_MutationSetOperationTemplateArgs as MutationSetOperationTemplateArgs,
    index_d_MutationSetStateSchemaArgs as MutationSetStateSchemaArgs,
    index_d_MutationUpdateOperationExampleArgs as MutationUpdateOperationExampleArgs,
    index_d_MutationUpdateStateExampleArgs as MutationUpdateStateExampleArgs,
    index_d_Operation as Operation,
    index_d_OperationError as OperationError,
    index_d_ReorderModuleOperationsInput as ReorderModuleOperationsInput,
    index_d_ReorderModulesInput as ReorderModulesInput,
    index_d_ReorderOperationErrorsInput as ReorderOperationErrorsInput,
    index_d_ReorderOperationExamplesInput as ReorderOperationExamplesInput,
    index_d_ReorderStateExamplesInput as ReorderStateExamplesInput,
    index_d_Scalars as Scalars,
    index_d_SetAuthorNameInput as SetAuthorNameInput,
    index_d_SetAuthorWebsiteInput as SetAuthorWebsiteInput,
    index_d_SetModelDescriptionInput as SetModelDescriptionInput,
    index_d_SetModelExtensionInput as SetModelExtensionInput,
    index_d_SetModelIdInput as SetModelIdInput,
    index_d_SetModelNameInput as SetModelNameInput,
    index_d_SetModuleDescriptionInput as SetModuleDescriptionInput,
    index_d_SetModuleNameInput as SetModuleNameInput,
    index_d_SetOperationDescriptionInput as SetOperationDescriptionInput,
    index_d_SetOperationErrorCodeInput as SetOperationErrorCodeInput,
    index_d_SetOperationErrorDescriptionInput as SetOperationErrorDescriptionInput,
    index_d_SetOperationErrorNameInput as SetOperationErrorNameInput,
    index_d_SetOperationErrorTemplateInput as SetOperationErrorTemplateInput,
    index_d_SetOperationNameInput as SetOperationNameInput,
    index_d_SetOperationReducerInput as SetOperationReducerInput,
    index_d_SetOperationSchemaInput as SetOperationSchemaInput,
    index_d_SetOperationTemplateInput as SetOperationTemplateInput,
    index_d_SetStateSchemaInput as SetStateSchemaInput,
    index_d_State as State,
    index_d_UpdateOperationExampleInput as UpdateOperationExampleInput,
    index_d_UpdateStateExampleInput as UpdateStateExampleInput,
    zod_d as z,
  };
}

export { AddModuleInput as A, AddStateExampleInput as B, UpdateStateExampleInput as C, DeleteModuleInput as D, DeleteStateExampleInput as E, ReorderStateExamplesInput as F, DocumentModelState as G, index_d as H, MoveOperationInput as M, ReorderModulesInput as R, SetModelNameInput as S, UpdateOperationExampleInput as U, SetModelIdInput as a, SetModelExtensionInput as b, SetModelDescriptionInput as c, SetAuthorNameInput as d, SetAuthorWebsiteInput as e, SetModuleNameInput as f, SetModuleDescriptionInput as g, AddOperationErrorInput as h, SetOperationErrorCodeInput as i, SetOperationErrorNameInput as j, SetOperationErrorDescriptionInput as k, SetOperationErrorTemplateInput as l, DeleteOperationErrorInput as m, ReorderOperationErrorsInput as n, AddOperationExampleInput as o, DeleteOperationExampleInput as p, ReorderOperationExamplesInput as q, AddOperationInput as r, SetOperationNameInput as s, SetOperationSchemaInput as t, SetOperationDescriptionInput as u, SetOperationTemplateInput as v, SetOperationReducerInput as w, DeleteOperationInput as x, ReorderModuleOperationsInput as y, SetStateSchemaInput as z };
