@shopify/cli-kit 0.12.0 → 0.30.2

package/dist/index.d.ts

@@ -0,0 +1,3864 @@
+/// <reference types="node" />
+import { Writable } from 'node:stream';
+import path$1 from 'path';
+import * as fs from 'fs';
+import { EventEmitter } from 'events';
+import { RequestOptions } from 'http';
+
+interface Question {
+    type: 'input' | 'select';
+    name: string;
+    message: string;
+    default?: string;
+    choices?: string[];
+}
+declare const prompt: <T>(questions: Question[]) => Promise<T>;
+interface Task$1 {
+    title: string;
+    output: string;
+}
+interface Context {
+}
+interface ListTask {
+    title: string;
+    task: (ctx: Context, task: Task$1) => Promise<void>;
+}
+interface ListOptions {
+    concurrent?: boolean;
+}
+declare const list: (tasks: ListTask[], options?: ListOptions | undefined) => Promise<void>;
+
+type ui_Question = Question;
+declare const ui_prompt: typeof prompt;
+type ui_Context = Context;
+declare const ui_list: typeof list;
+declare namespace ui {
+  export {
+    ui_Question as Question,
+    ui_prompt as prompt,
+    Task$1 as Task,
+    ui_Context as Context,
+    ui_list as list,
+  };
+}
+
+/**
+ * A fatal error represents an error shouldn't be rescued and that causes the execution to terminate.
+ * There shouldn't be code that catches fatal errors.
+ */
+declare class Fatal extends Error {
+    tryMessage: string | null;
+    constructor(message: string, tryMessage?: string | null);
+}
+/**
+ * An abort error is a fatal error that shouldn't be reported as a bug.
+ * Those usually represent unexpected scenarios that we can't handle and that usually require some action from the developer
+ */
+declare class Abort extends Fatal {
+}
+/**
+ * A bug error is an error that represents a bug and therefore should be reported.
+ */
+declare class Bug extends Fatal {
+}
+/**
+ * A function that handles errors that blow up in the CLI.
+ * @param error Error to be handled.
+ * @returns A promise that resolves with the error passed.
+ */
+declare function handler(error: Error): Promise<Error>;
+
+type error$1_Fatal = Fatal;
+declare const error$1_Fatal: typeof Fatal;
+type error$1_Abort = Abort;
+declare const error$1_Abort: typeof Abort;
+type error$1_Bug = Bug;
+declare const error$1_Bug: typeof Bug;
+declare const error$1_handler: typeof handler;
+declare namespace error$1 {
+  export {
+    error$1_Fatal as Fatal,
+    error$1_Abort as Abort,
+    error$1_Bug as Bug,
+    error$1_handler as handler,
+  };
+}
+
+interface ExecOptions {
+    cwd?: string;
+    stdout?: Writable;
+    stderr?: Writable;
+}
+/**
+ * Runs a command asynchronously, aggregates the stdout data, and returns it.
+ * @param command {string} Command to be executed.
+ * @param args {string[]} Arguments to pass to the command.
+ * @returns A promise that resolves with the aggregatted stdout of the command.
+ */
+declare const captureOutput: (command: string, args: string[]) => Promise<string>;
+declare const exec: (command: string, args: string[], options?: ExecOptions | undefined) => Promise<void>;
+
+type system_ExecOptions = ExecOptions;
+declare const system_captureOutput: typeof captureOutput;
+declare const system_exec: typeof exec;
+declare namespace system {
+  export {
+    system_ExecOptions as ExecOptions,
+    system_captureOutput as captureOutput,
+    system_exec as exec,
+  };
+}
+
+declare function template(templateContent: string): (data: object) => Promise<string>;
+
+interface Options$4 {
+    splitRegexp?: RegExp | RegExp[];
+    stripRegexp?: RegExp | RegExp[];
+    delimiter?: string;
+    transform?: (part: string, index: number, parts: string[]) => string;
+}
+
+declare function camelCase(input: string, options?: Options$4): string;
+
+declare function paramCase(input: string, options?: Options$4): string;
+
+declare namespace string {
+  export {
+    camelCase as camelize,
+    paramCase as hyphenize,
+  };
+}
+
+declare const sep = "/";
+declare const delimiter = ":";
+declare const normalize: typeof path$1.normalize;
+declare const join: typeof path$1.join;
+declare const resolve: typeof path$1.resolve;
+declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+declare const isAbsolute: typeof path$1.isAbsolute;
+declare const toNamespacedPath: typeof path$1.toNamespacedPath;
+declare const extname: typeof path$1.extname;
+declare const relative: typeof path$1.relative;
+declare const dirname: typeof path$1.dirname;
+declare const format: typeof path$1.format;
+declare const basename: typeof path$1.basename;
+declare const parse$1: typeof path$1.parse;
+
+interface Options$3 {
+	/**
+	The current working directory.
+
+	@default process.cwd()
+	*/
+	readonly cwd?: URL | string;
+
+	/**
+	The type of path to match.
+
+	@default 'file'
+	*/
+	readonly type?: 'file' | 'directory';
+
+	/**
+	Allow symbolic links to match if they point to the requested path type.
+
+	@default true
+	*/
+	readonly allowSymlinks?: boolean;
+}
+
+/* eslint-disable @typescript-eslint/unified-signatures */
+
+
+/**
+Return this in a `matcher` function to stop the search and force `findUp` to immediately return `undefined`.
+*/
+declare const findUpStop: unique symbol;
+
+type Match = string | typeof findUpStop | undefined;
+
+interface Options$2 extends Options$3 {
+	/**
+	The path to the directory to stop the search before reaching root if there were no matches before the `stopAt` directory.
+
+	@default path.parse(cwd).root
+	*/
+	readonly stopAt?: string;
+}
+
+/**
+Find a file or directory by walking up parent directories.
+
+@param name - The name of the file or directory to find. Can be multiple.
+@returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found.
+
+@example
+```
+// /
+// └── Users
+//     └── sindresorhus
+//         ├── unicorn.png
+//         └── foo
+//             └── bar
+//                 ├── baz
+//                 └── example.js
+
+// example.js
+import {findUp} from 'find-up';
+
+console.log(await findUp('unicorn.png'));
+//=> '/Users/sindresorhus/unicorn.png'
+
+console.log(await findUp(['rainbow.png', 'unicorn.png']));
+//=> '/Users/sindresorhus/unicorn.png'
+```
+*/
+declare function findUp(name: string | readonly string[], options?: Options$2): Promise<string | undefined>;
+
+/**
+Find a file or directory by walking up parent directories.
+
+@param matcher - Called for each directory in the search. Return a path or `findUpStop` to stop the search.
+@returns The first path found or `undefined` if none could be found.
+
+@example
+```
+import path from 'node:path';
+import {findUp, pathExists} from 'find-up';
+
+console.log(await findUp(async directory => {
+	const hasUnicorns = await pathExists(path.join(directory, 'unicorn.png'));
+	return hasUnicorns && directory;
+}, {type: 'directory'}));
+//=> '/Users/sindresorhus'
+```
+*/
+declare function findUp(matcher: (directory: string) => (Match | Promise<Match>), options?: Options$2): Promise<string | undefined>;
+
+declare type ErrnoException$1 = NodeJS.ErrnoException;
+
+declare type StatAsynchronousMethod = (path: string, callback: (error: ErrnoException$1 | null, stats: fs.Stats) => void) => void;
+declare type StatSynchronousMethod = (path: string) => fs.Stats;
+interface FileSystemAdapter$2 {
+    lstat: StatAsynchronousMethod;
+    stat: StatAsynchronousMethod;
+    lstatSync: StatSynchronousMethod;
+    statSync: StatSynchronousMethod;
+}
+
+interface Entry$2 {
+    dirent: Dirent;
+    name: string;
+    path: string;
+    stats?: Stats;
+}
+declare type Stats = fs.Stats;
+declare type ErrnoException = NodeJS.ErrnoException;
+interface Dirent {
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isDirectory: () => boolean;
+    isFIFO: () => boolean;
+    isFile: () => boolean;
+    isSocket: () => boolean;
+    isSymbolicLink: () => boolean;
+    name: string;
+}
+
+interface ReaddirAsynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
+    (filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
+}
+interface ReaddirSynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }): Dirent[];
+    (filepath: string): string[];
+}
+declare type FileSystemAdapter$1 = FileSystemAdapter$2 & {
+    readdir: ReaddirAsynchronousMethod;
+    readdirSync: ReaddirSynchronousMethod;
+};
+
+declare type Entry$1 = Entry$2;
+
+declare type Entry = Entry$1;
+declare type Pattern = string;
+declare type FileSystemAdapter = FileSystemAdapter$1;
+
+declare type Options$1 = {
+    /**
+     * Return the absolute path for entries.
+     *
+     * @default false
+     */
+    absolute?: boolean;
+    /**
+     * If set to `true`, then patterns without slashes will be matched against
+     * the basename of the path if it contains slashes.
+     *
+     * @default false
+     */
+    baseNameMatch?: boolean;
+    /**
+     * Enables Bash-like brace expansion.
+     *
+     * @default true
+     */
+    braceExpansion?: boolean;
+    /**
+     * Enables a case-sensitive mode for matching files.
+     *
+     * @default true
+     */
+    caseSensitiveMatch?: boolean;
+    /**
+     * Specifies the maximum number of concurrent requests from a reader to read
+     * directories.
+     *
+     * @default os.cpus().length
+     */
+    concurrency?: number;
+    /**
+     * The current working directory in which to search.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Specifies the maximum depth of a read directory relative to the start
+     * directory.
+     *
+     * @default Infinity
+     */
+    deep?: number;
+    /**
+     * Allow patterns to match entries that begin with a period (`.`).
+     *
+     * @default false
+     */
+    dot?: boolean;
+    /**
+     * Enables Bash-like `extglob` functionality.
+     *
+     * @default true
+     */
+    extglob?: boolean;
+    /**
+     * Indicates whether to traverse descendants of symbolic link directories.
+     *
+     * @default true
+     */
+    followSymbolicLinks?: boolean;
+    /**
+     * Custom implementation of methods for working with the file system.
+     *
+     * @default fs.*
+     */
+    fs?: Partial<FileSystemAdapter>;
+    /**
+     * Enables recursively repeats a pattern containing `**`.
+     * If `false`, `**` behaves exactly like `*`.
+     *
+     * @default true
+     */
+    globstar?: boolean;
+    /**
+     * An array of glob patterns to exclude matches.
+     * This is an alternative way to use negative patterns.
+     *
+     * @default []
+     */
+    ignore?: Pattern[];
+    /**
+     * Mark the directory path with the final slash.
+     *
+     * @default false
+     */
+    markDirectories?: boolean;
+    /**
+     * Returns objects (instead of strings) describing entries.
+     *
+     * @default false
+     */
+    objectMode?: boolean;
+    /**
+     * Return only directories.
+     *
+     * @default false
+     */
+    onlyDirectories?: boolean;
+    /**
+     * Return only files.
+     *
+     * @default true
+     */
+    onlyFiles?: boolean;
+    /**
+     * Enables an object mode (`objectMode`) with an additional `stats` field.
+     *
+     * @default false
+     */
+    stats?: boolean;
+    /**
+     * By default this package suppress only `ENOENT` errors.
+     * Set to `true` to suppress any error.
+     *
+     * @default false
+     */
+    suppressErrors?: boolean;
+    /**
+     * Throw an error when symbolic link is broken if `true` or safely
+     * return `lstat` call if `false`.
+     *
+     * @default false
+     */
+    throwErrorOnBrokenSymbolicLink?: boolean;
+    /**
+     * Ensures that the returned entries are unique.
+     *
+     * @default true
+     */
+    unique?: boolean;
+};
+
+declare type Task = {
+    base: string;
+    dynamic: boolean;
+    patterns: Pattern[];
+    positive: Pattern[];
+    negative: Pattern[];
+};
+
+declare type EntryObjectModePredicate = {
+    [TKey in keyof Pick<Options$1, 'objectMode'>]-?: true;
+};
+declare type EntryStatsPredicate = {
+    [TKey in keyof Pick<Options$1, 'stats'>]-?: true;
+};
+declare type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+declare function FastGlob(source: Pattern | Pattern[], options: Options$1 & EntryObjectPredicate): Promise<Entry[]>;
+declare function FastGlob(source: Pattern | Pattern[], options?: Options$1): Promise<string[]>;
+declare namespace FastGlob {
+    type Options = Options$1;
+    type Entry = Entry;
+    type Task = Task;
+    type Pattern = Pattern;
+    type FileSystemAdapter = FileSystemAdapter;
+    function sync(source: Pattern | Pattern[], options: Options$1 & EntryObjectPredicate): Entry[];
+    function sync(source: Pattern | Pattern[], options?: Options$1): string[];
+    function stream(source: Pattern | Pattern[], options?: Options$1): NodeJS.ReadableStream;
+    function generateTasks(source: Pattern | Pattern[], options?: Options$1): Task[];
+    function isDynamicPattern(source: Pattern, options?: Options$1): boolean;
+    function escapePath(source: Pattern): Pattern;
+}
+
+declare const path_findUp: typeof findUp;
+declare const path_basename: typeof basename;
+declare const path_delimiter: typeof delimiter;
+declare const path_dirname: typeof dirname;
+declare const path_extname: typeof extname;
+declare const path_format: typeof format;
+declare const path_isAbsolute: typeof isAbsolute;
+declare const path_join: typeof join;
+declare const path_normalize: typeof normalize;
+declare const path_normalizeString: typeof normalizeString;
+declare const path_relative: typeof relative;
+declare const path_resolve: typeof resolve;
+declare const path_sep: typeof sep;
+declare const path_toNamespacedPath: typeof toNamespacedPath;
+declare namespace path {
+  export {
+    path_findUp as findUp,
+    FastGlob as glob,
+    path_basename as basename,
+    path_delimiter as delimiter,
+    path_dirname as dirname,
+    path_extname as extname,
+    path_format as format,
+    path_isAbsolute as isAbsolute,
+    path_join as join,
+    path_normalize as normalize,
+    path_normalizeString as normalizeString,
+    parse$1 as parse,
+    path_relative as relative,
+    path_resolve as resolve,
+    path_sep as sep,
+    path_toNamespacedPath as toNamespacedPath,
+  };
+}
+
+declare function read(path: string): Promise<string>;
+declare function write(path: string, data: string): Promise<void>;
+declare function mkdir(path: string): Promise<void>;
+declare function rmdir(path: string): Promise<void>;
+declare function mkTmpDir(): Promise<string>;
+declare function isDirectory(path: string): Promise<boolean>;
+declare function exists(path: string): Promise<boolean>;
+
+declare const file_read: typeof read;
+declare const file_write: typeof write;
+declare const file_mkdir: typeof mkdir;
+declare const file_rmdir: typeof rmdir;
+declare const file_mkTmpDir: typeof mkTmpDir;
+declare const file_isDirectory: typeof isDirectory;
+declare const file_exists: typeof exists;
+declare namespace file {
+  export {
+    file_read as read,
+    file_write as write,
+    file_mkdir as mkdir,
+    file_rmdir as rmdir,
+    file_mkTmpDir as mkTmpDir,
+    file_isDirectory as isDirectory,
+    file_exists as exists,
+  };
+}
+
+declare enum ContentTokenType {
+    Command = 0,
+    Path = 1,
+    Link = 2
+}
+interface ContentMetadata {
+    link?: string;
+}
+declare class ContentToken {
+    type: ContentTokenType;
+    value: string;
+    metadata: ContentMetadata;
+    constructor(value: string, metadata: ContentMetadata | undefined, type: ContentTokenType);
+}
+declare const token: {
+    command: (value: string) => ContentToken;
+    path: (value: string) => ContentToken;
+    link: (value: string, link: string) => ContentToken;
+};
+declare class TokenizedString {
+    value: string;
+    constructor(value: string);
+}
+declare type Message = string | TokenizedString;
+declare function content(strings: TemplateStringsArray, ...keys: (ContentToken | string)[]): TokenizedString;
+declare const success: (content: Message) => void;
+declare const message: (content: Message) => void;
+declare const error: (content: Message) => void;
+declare const warning: (content: Message) => void;
+
+declare const output$1_token: typeof token;
+declare const output$1_content: typeof content;
+declare const output$1_success: typeof success;
+declare const output$1_message: typeof message;
+declare const output$1_error: typeof error;
+declare const output$1_warning: typeof warning;
+declare namespace output$1 {
+  export {
+    output$1_token as token,
+    output$1_content as content,
+    output$1_success as success,
+    output$1_message as message,
+    output$1_error as error,
+    output$1_warning as warning,
+  };
+}
+
+declare enum DependencyManager {
+    Npm = "npm",
+    Yarn = "yarn",
+    Pnpm = "pnpm"
+}
+declare const dependencyManager: string[];
+/**
+ * Returns the dependency manager used to run the create workflow.
+ * @param env {Object} The environment variables of the process in which the CLI runs.
+ * @returns The dependency manager
+ */
+declare function dependencyManagerUsedForCreating(env?: NodeJS.ProcessEnv): DependencyManager;
+/**
+ * Installs the dependencies in the given directory.
+ * @param directory {string} The directory that contains the package.json
+ * @param dependencyManager {DependencyManager} The dependency manager to use to install the dependencies.
+ * @returns
+ */
+declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable): Promise<void>;
+
+type dependency_DependencyManager = DependencyManager;
+declare const dependency_DependencyManager: typeof DependencyManager;
+declare const dependency_dependencyManager: typeof dependencyManager;
+declare const dependency_dependencyManagerUsedForCreating: typeof dependencyManagerUsedForCreating;
+declare const dependency_install: typeof install;
+declare namespace dependency {
+  export {
+    dependency_DependencyManager as DependencyManager,
+    dependency_dependencyManager as dependencyManager,
+    dependency_dependencyManagerUsedForCreating as dependencyManagerUsedForCreating,
+    dependency_install as install,
+  };
+}
+
+/**
+ * Returns the latest available version of an NPM package.
+ * @param name {string} The name of the NPM package.
+ * @returns A promise to get the latest available version of a package.
+ */
+declare function latestNpmPackageVersion(name: string): Promise<string>;
+
+declare const version_latestNpmPackageVersion: typeof latestNpmPackageVersion;
+declare namespace version {
+  export {
+    version_latestNpmPackageVersion as latestNpmPackageVersion,
+  };
+}
+
+declare const username: () => Promise<string | null>;
+
+declare const os_username: typeof username;
+declare namespace os {
+  export {
+    os_username as username,
+  };
+}
+
+/**
+ * Returns true if the CLI is running in debug mode.
+ * @param env The environment variables from the environment of the current process.
+ * @returns true if SHOPIFY_CONFIG is debug
+ */
+declare function isDebug(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Returns true if the environment in which the CLI is running is either
+ * a local environment (where dev is present) or a cloud environment (spin).
+ * @returns {boolean} True if the CLI is used in a Shopify environment.
+ */
+declare function isShopify(env?: NodeJS.ProcessEnv): Promise<boolean>;
+
+declare const local_isDebug: typeof isDebug;
+declare const local_isShopify: typeof isShopify;
+declare namespace local {
+  export {
+    local_isDebug as isDebug,
+    local_isShopify as isShopify,
+  };
+}
+
+/**
+ * Enum that represents the environment to use for a given service.
+ * @readonly
+ * @enum {number}
+ */
+declare enum Environment {
+    Local = "local",
+    Production = "production",
+    Spin = "spin"
+}
+
+/**
+ * Returns the environment to be used for the interactions with the partners' CLI API.
+ * @param env The environment variables from the environment of the current process.
+ */
+declare function partners$1(env?: NodeJS.ProcessEnv): Environment;
+/**
+ * Returns the environment to be used for the interactions with the admin API.
+ * @param env The environment variables from the environment of the current process.
+ */
+declare function shopify$1(env?: NodeJS.ProcessEnv): Environment;
+/**
+ * Returns the environment to be used for the interactions with identity.
+ * @param env The environment variables from the environment of the current process.
+ */
+declare function identity$1(env?: NodeJS.ProcessEnv): Environment;
+
+declare namespace service {
+  export {
+    partners$1 as partners,
+    shopify$1 as shopify,
+    identity$1 as identity,
+  };
+}
+
+declare const CouldntObtainPartnersSpinFQDNError: Abort;
+declare const CouldntObtainIdentitySpinFQDNError: Abort;
+declare const CouldntObtainShopifySpinFQDNError: Abort;
+declare const NotProvidedStoreFQDNError: Abort;
+/**
+ * It returns the Partners' API service we should interact with.
+ * @returns {string} Fully-qualified domain of the partners service we should interact with.
+ */
+declare function partners(): Promise<string>;
+/**
+ * It returns the Identity service we should interact with.
+ * @returns {string} Fully-qualified domain of the Identity service we should interact with.
+ */
+declare function identity(): Promise<string>;
+/**
+ * It returns the Shopify service we should interact with.
+ * Note the same fqdn is sued for the Admin and the Storefront Renderer APIs.
+ * @returns {string} Fully-qualified domain of the Shopify service we should interact with.
+ */
+declare function shopify(options?: {
+    storeFqdn?: string;
+}): Promise<string>;
+
+declare const fqdn_CouldntObtainPartnersSpinFQDNError: typeof CouldntObtainPartnersSpinFQDNError;
+declare const fqdn_CouldntObtainIdentitySpinFQDNError: typeof CouldntObtainIdentitySpinFQDNError;
+declare const fqdn_CouldntObtainShopifySpinFQDNError: typeof CouldntObtainShopifySpinFQDNError;
+declare const fqdn_NotProvidedStoreFQDNError: typeof NotProvidedStoreFQDNError;
+declare const fqdn_partners: typeof partners;
+declare const fqdn_identity: typeof identity;
+declare const fqdn_shopify: typeof shopify;
+declare namespace fqdn {
+  export {
+    fqdn_CouldntObtainPartnersSpinFQDNError as CouldntObtainPartnersSpinFQDNError,
+    fqdn_CouldntObtainIdentitySpinFQDNError as CouldntObtainIdentitySpinFQDNError,
+    fqdn_CouldntObtainShopifySpinFQDNError as CouldntObtainShopifySpinFQDNError,
+    fqdn_NotProvidedStoreFQDNError as NotProvidedStoreFQDNError,
+    fqdn_partners as partners,
+    fqdn_identity as identity,
+    fqdn_shopify as shopify,
+  };
+}
+
+declare const environment_local: typeof local;
+declare const environment_service: typeof service;
+declare const environment_fqdn: typeof fqdn;
+declare namespace environment {
+  export {
+    environment_local as local,
+    environment_service as service,
+    environment_fqdn as fqdn,
+  };
+}
+
+declare namespace util {
+    type AssertEqual<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? true : false : false;
+    function assertNever(_x: never): never;
+    type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+    type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+    type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
+    const getValidEnumValues: (obj: any) => any[];
+    const objectValues: (obj: any) => any[];
+    const objectKeys: ObjectConstructor["keys"];
+    const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+    type identity<T> = T;
+    type flatten<T extends object> = identity<{
+        [k in keyof T]: T[k];
+    }>;
+    type noUndefined<T> = T extends undefined ? never : T;
+    const isInteger: NumberConstructor["isInteger"];
+}
+
+declare const ZodIssueCode: {
+    invalid_type: "invalid_type";
+    custom: "custom";
+    invalid_union: "invalid_union";
+    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";
+};
+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 ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    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" | "uuid" | "regex" | "cuid";
+interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number;
+    inclusive: boolean;
+    type: "array" | "string" | "number";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number;
+    inclusive: boolean;
+    type: "array" | "string" | "number";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+declare type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+declare type ZodIssue = ZodIssueOptionalMessage & {
+    message: string;
+};
+declare const quotelessJson: (obj: any) => string;
+declare type ZodFormattedError<T> = {
+    _errors: string[];
+} & (T extends [any, ...any[]] ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? ZodFormattedError<T[number]>[] : T extends object ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown);
+declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format: () => ZodFormattedError<T>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten: <U = string>(mapper?: (issue: ZodIssue) => U) => {
+        formErrors: U[];
+        fieldErrors: {
+            [k: string]: U[];
+        };
+    };
+    get formErrors(): {
+        formErrors: string[];
+        fieldErrors: {
+            [k: string]: 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 MakeErrorData = IssueData;
+declare type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+declare type ZodErrorMap = typeof defaultErrorMap;
+declare const defaultErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+declare let overrideErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+declare const setErrorMap: (map: ZodErrorMap) => void;
+
+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 const getParsedType: (data: any, cache?: Map<any, "function" | "number" | "string" | "nan" | "integer" | "float" | "boolean" | "date" | "bigint" | "symbol" | "undefined" | "null" | "array" | "object" | "unknown" | "promise" | "void" | "never" | "map" | "set"> | undefined) => ZodParsedType;
+declare const makeIssue: (params: {
+    data: any;
+    path: (string | number)[];
+    errorMaps: ZodErrorMap[];
+    issueData: IssueData;
+}) => ZodIssue;
+declare type ParseParams = {
+    path: (string | number)[];
+    errorMap: ZodErrorMap;
+    async: boolean;
+};
+declare type ParsePathComponent = string | number;
+declare type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
+interface ParseContext {
+    readonly path: ParsePath;
+    readonly issues: ZodIssue[];
+    readonly schemaErrorMap?: ZodErrorMap;
+    readonly contextualErrorMap?: ZodErrorMap;
+    readonly async: boolean;
+    readonly parent: ParseContext | null;
+    readonly typeCache: Map<any, ZodParsedType>;
+    readonly data: any;
+    readonly parsedType: ZodParsedType;
+}
+declare type ParseInput = {
+    data: any;
+    path: (string | number)[];
+    parent: ParseContext;
+};
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+declare type ObjectPair = {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+};
+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;
+}
+interface ParseResult {
+    status: "aborted" | "dirty" | "valid";
+    data: any;
+}
+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 const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
+
+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<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> ? {
+        [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 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;
+    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, 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>;
+    _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>>;
+    /** Alias of safeParseAsync */
+    spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
+    /** The .is method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
+    is: never;
+    /** The .check method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
+    check: never;
+    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
+    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, RefinedOutput>;
+    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>;
+    constructor(def: Def);
+    optional(): ZodOptional<this>;
+    nullable(): ZodNullable<this>;
+    nullish(): ZodNullable<ZodOptional<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) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+    default(def: util.noUndefined<Input>): ZodDefault<this>;
+    default(def: () => util.noUndefined<Input>): ZodDefault<this>;
+    describe(description: string): this;
+    isOptional(): boolean;
+    isNullable(): boolean;
+}
+declare type ZodStringCheck = {
+    kind: "min";
+    value: number;
+    message?: string;
+} | {
+    kind: "max";
+    value: number;
+    message?: string;
+} | {
+    kind: "email";
+    message?: string;
+} | {
+    kind: "url";
+    message?: string;
+} | {
+    kind: "uuid";
+    message?: string;
+} | {
+    kind: "cuid";
+    message?: string;
+} | {
+    kind: "regex";
+    regex: RegExp;
+    message?: string;
+};
+interface ZodStringDef extends ZodTypeDef {
+    checks: ZodStringCheck[];
+    typeName: ZodFirstPartyTypeKind.ZodString;
+}
+declare class ZodString extends ZodType<string, ZodStringDef> {
+    _parse(input: ParseInput): ParseReturnType<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;
+    uuid(message?: errorUtil.ErrMessage): ZodString;
+    cuid(message?: errorUtil.ErrMessage): ZodString;
+    regex(regex: RegExp, 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.
+     */
+    nonempty: (message?: errorUtil.ErrMessage | undefined) => ZodString;
+    get isEmail(): boolean;
+    get isURL(): boolean;
+    get isUUID(): boolean;
+    get isCUID(): boolean;
+    get minLength(): number;
+    get maxLength(): null;
+    static create: (params?: RawCreateParams) => ZodString;
+}
+declare type ZodNumberCheck = {
+    kind: "min";
+    value: number;
+    inclusive: boolean;
+    message?: string;
+} | {
+    kind: "max";
+    value: number;
+    inclusive: boolean;
+    message?: string;
+} | {
+    kind: "int";
+    message?: string;
+} | {
+    kind: "multipleOf";
+    value: number;
+    message?: string;
+};
+interface ZodNumberDef extends ZodTypeDef {
+    checks: ZodNumberCheck[];
+    typeName: ZodFirstPartyTypeKind.ZodNumber;
+}
+declare class ZodNumber extends ZodType<number, ZodNumberDef> {
+    _parse(input: ParseInput): ParseReturnType<number>;
+    static create: (params?: RawCreateParams) => ZodNumber;
+    gte(value: number, message?: errorUtil.ErrMessage): 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?: 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;
+    int(message?: errorUtil.ErrMessage): ZodNumber;
+    positive(message?: errorUtil.ErrMessage): ZodNumber;
+    negative(message?: errorUtil.ErrMessage): ZodNumber;
+    nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
+    nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
+    multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+    step: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+    get minValue(): number | null;
+    get maxValue(): number | null;
+    get isInt(): boolean;
+}
+interface ZodBigIntDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodBigInt;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef> {
+    _parse(input: ParseInput): ParseReturnType<bigint>;
+    static create: (params?: RawCreateParams) => ZodBigInt;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodBoolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
+    _parse(input: ParseInput): ParseReturnType<boolean>;
+    static create: (params?: RawCreateParams) => ZodBoolean;
+}
+interface ZodDateDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodDate;
+}
+declare class ZodDate extends ZodType<Date, ZodDateDef> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => ZodDate;
+}
+interface ZodUndefinedDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    params?: RawCreateParams;
+    static create: (params?: RawCreateParams) => ZodUndefined;
+}
+interface ZodNullDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodNull;
+}
+declare class ZodNull extends ZodType<null, ZodNullDef> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => ZodNull;
+}
+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 ZodUnknownDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodUnknown;
+}
+declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef> {
+    _unknown: true;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => ZodUnknown;
+}
+interface ZodNeverDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodNever;
+}
+declare class ZodNever extends ZodType<never, ZodNeverDef> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => ZodNever;
+}
+interface ZodVoidDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodVoid;
+}
+declare class ZodVoid extends ZodType<void, ZodVoidDef> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => ZodVoid;
+}
+interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    type: T;
+    typeName: ZodFirstPartyTypeKind.ZodArray;
+    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 ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
+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> = Exclude<keyof T, optionalKeys<T>>;
+    export type addQuestionMarks<T extends object> = {
+        [k in optionalKeys<T>]?: T[k];
+    } & {
+        [k in requiredKeys<T>]: T[k];
+    };
+    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> = {
+    [k in Exclude<keyof A, keyof B>]: A[k];
+} & {
+    [k in keyof B]: B[k];
+};
+declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type Scalars = Primitive | Primitive[];
+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 baseObjectOutputType<Shape extends ZodRawShape> = objectUtil.flatten<objectUtil.addQuestionMarks<{
+    [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<{
+    [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 type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny, any, any>;
+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> {
+    readonly _shape: T;
+    readonly _unknownKeys: UnknownKeys;
+    readonly _catchall: Catchall;
+    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>;
+    /**
+     * @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>>;
+    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, Incoming["_shape"]>, UnknownKeys, Catchall>;
+    catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
+    pick<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+        [k in keyof Mask]: k extends keyof T ? T[k] : never;
+    }>, UnknownKeys, Catchall>;
+    omit<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+        [k in keyof T]: k extends keyof Mask ? never : T[k];
+    }>, 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>;
+    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]; }>;
+}
+declare type AnyZodObject = ZodObject<any, any, any>;
+declare type ZodUnionOptions = [ZodTypeAny, ...ZodTypeAny[]];
+interface ZodUnionDef<T extends ZodUnionOptions = [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 [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 extends any> = 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>;
+}
+interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    valueType: Value;
+    keyType: Key;
+    typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+declare type KeySchema = ZodType<string | number | symbol, any, any>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Record<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, Record<Key["_input"], Value["_input"]>> {
+    get keySchema(): Key;
+    get valueSchema(): Value;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get element(): Value;
+    static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+    static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    valueType: Value;
+    keyType: Key;
+    typeName: ZodFirstPartyTypeKind.ZodMap;
+}
+declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <Key_1 extends ZodTypeAny = ZodTypeAny, Value_1 extends ZodTypeAny = ZodTypeAny>(keyType: Key_1, valueType: Value_1, params?: RawCreateParams) => ZodMap<Key_1, Value_1>;
+}
+interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    valueType: Value;
+    typeName: ZodFirstPartyTypeKind.ZodSet;
+}
+declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <Value_1 extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
+}
+interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    args: Args;
+    returns: Returns;
+    typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+declare type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+declare type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    parameters(): Args;
+    returnType(): 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): F;
+    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => F;
+    static create: <T extends ZodTuple<any, any> = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined, params?: RawCreateParams) => ZodFunction<T, U>;
+}
+interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    getter: () => T;
+    typeName: ZodFirstPartyTypeKind.ZodLazy;
+}
+declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
+    get schema(): T;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
+}
+interface ZodLiteralDef<T extends any = any> extends ZodTypeDef {
+    value: T;
+    typeName: ZodFirstPartyTypeKind.ZodLiteral;
+}
+declare class ZodLiteral<T extends any> extends ZodType<T, ZodLiteralDef<T>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get value(): T;
+    static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+}
+declare type ArrayKeys = keyof any[];
+declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
+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 function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T): 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>;
+    static create: typeof createZodEnum;
+}
+interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
+    values: T;
+    typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
+}
+declare type EnumLike = {
+    [k: string]: string | number;
+    [nu: number]: string;
+};
+declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>> {
+    _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+    static create: <T_1 extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
+}
+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"]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+}
+declare type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+declare type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void;
+declare type RefinementEffect<T> = {
+    type: "refinement";
+    refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type TransformEffect<T> = {
+    type: "transform";
+    transform: (arg: T) => 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 = T["_output"], Input = T["_input"]> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+    innerType(): 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 createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+}
+
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    innerType: T;
+    typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+declare type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
+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 type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
+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?: RawCreateParams) => ZodOptional<T_1>;
+}
+declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<T, ZodTypeDef, T>;
+
+declare const late: {
+    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
+};
+declare enum ZodFirstPartyTypeKind {
+    ZodString = "ZodString",
+    ZodNumber = "ZodNumber",
+    ZodBigInt = "ZodBigInt",
+    ZodBoolean = "ZodBoolean",
+    ZodDate = "ZodDate",
+    ZodUndefined = "ZodUndefined",
+    ZodNull = "ZodNull",
+    ZodAny = "ZodAny",
+    ZodUnknown = "ZodUnknown",
+    ZodNever = "ZodNever",
+    ZodVoid = "ZodVoid",
+    ZodArray = "ZodArray",
+    ZodObject = "ZodObject",
+    ZodUnion = "ZodUnion",
+    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",
+    ZodPromise = "ZodPromise"
+}
+declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodPromise<any>;
+declare const instanceOfType: <T extends new (...args: any[]) => any>(cls: T, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams) => ZodString;
+declare const numberType: (params?: RawCreateParams) => ZodNumber;
+declare const bigIntType: (params?: RawCreateParams) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams) => ZodDate;
+declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
+declare const nullType: (params?: RawCreateParams) => ZodNull;
+declare const anyType: (params?: RawCreateParams) => ZodAny;
+declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
+declare const neverType: (params?: RawCreateParams) => ZodNever;
+declare const voidType: (params?: RawCreateParams) => ZodVoid;
+declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, "many">;
+declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
+declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
+declare const unionType: <T extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
+declare const tupleType: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key, valueType: Value, params?: RawCreateParams) => ZodMap<Key, Value>;
+declare const setType: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value, params?: RawCreateParams) => ZodSet<Value>;
+declare const functionType: <T extends ZodTuple<any, any> = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined, params?: RawCreateParams) => ZodFunction<T, U>;
+declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
+declare const literalType: <T extends Primitive>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
+declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
+declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+declare const ostring: () => ZodOptional<ZodString>;
+declare const onumber: () => ZodOptional<ZodNumber>;
+declare const oboolean: () => ZodOptional<ZodBoolean>;
+
+//# sourceMappingURL=external.d.ts.map
+
+type external_d_ZodParsedType = ZodParsedType;
+declare const external_d_getParsedType: typeof getParsedType;
+declare const external_d_makeIssue: typeof makeIssue;
+type external_d_ParseParams = ParseParams;
+type external_d_ParsePathComponent = ParsePathComponent;
+type external_d_ParsePath = ParsePath;
+declare const external_d_EMPTY_PATH: typeof EMPTY_PATH;
+type external_d_ParseContext = ParseContext;
+type external_d_ParseInput = ParseInput;
+declare const external_d_addIssueToContext: typeof addIssueToContext;
+type external_d_ObjectPair = ObjectPair;
+type external_d_ParseStatus = ParseStatus;
+declare const external_d_ParseStatus: typeof ParseStatus;
+type external_d_ParseResult = ParseResult;
+declare const external_d_INVALID: typeof INVALID;
+declare const external_d_DIRTY: typeof DIRTY;
+declare const external_d_OK: typeof OK;
+type external_d_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
+type external_d_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
+type external_d_ParseReturnType<T> = ParseReturnType<T>;
+declare const external_d_isAborted: typeof isAborted;
+declare const external_d_isDirty: typeof isDirty;
+declare const external_d_isValid: typeof isValid;
+declare const external_d_isAsync: typeof isAsync;
+declare const external_d_oboolean: typeof oboolean;
+declare const external_d_onumber: typeof onumber;
+declare const external_d_ostring: typeof ostring;
+type external_d_RefinementCtx = RefinementCtx;
+type external_d_ZodRawShape = ZodRawShape;
+type external_d_ZodTypeAny = ZodTypeAny;
+type external_d_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
+type external_d_input<T extends ZodType<any, any, any>> = input<T>;
+type external_d_output<T extends ZodType<any, any, any>> = output<T>;
+type external_d_CustomErrorParams = CustomErrorParams;
+type external_d_ZodTypeDef = ZodTypeDef;
+type external_d_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
+type external_d_SafeParseError<Input> = SafeParseError<Input>;
+type external_d_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
+type external_d_ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
+declare const external_d_ZodType: typeof ZodType;
+type external_d_ZodStringDef = ZodStringDef;
+type external_d_ZodString = ZodString;
+declare const external_d_ZodString: typeof ZodString;
+type external_d_ZodNumberDef = ZodNumberDef;
+type external_d_ZodNumber = ZodNumber;
+declare const external_d_ZodNumber: typeof ZodNumber;
+type external_d_ZodBigIntDef = ZodBigIntDef;
+type external_d_ZodBigInt = ZodBigInt;
+declare const external_d_ZodBigInt: typeof ZodBigInt;
+type external_d_ZodBooleanDef = ZodBooleanDef;
+type external_d_ZodBoolean = ZodBoolean;
+declare const external_d_ZodBoolean: typeof ZodBoolean;
+type external_d_ZodDateDef = ZodDateDef;
+type external_d_ZodDate = ZodDate;
+declare const external_d_ZodDate: typeof ZodDate;
+type external_d_ZodUndefinedDef = ZodUndefinedDef;
+type external_d_ZodUndefined = ZodUndefined;
+declare const external_d_ZodUndefined: typeof ZodUndefined;
+type external_d_ZodNullDef = ZodNullDef;
+type external_d_ZodNull = ZodNull;
+declare const external_d_ZodNull: typeof ZodNull;
+type external_d_ZodAnyDef = ZodAnyDef;
+type external_d_ZodAny = ZodAny;
+declare const external_d_ZodAny: typeof ZodAny;
+type external_d_ZodUnknownDef = ZodUnknownDef;
+type external_d_ZodUnknown = ZodUnknown;
+declare const external_d_ZodUnknown: typeof ZodUnknown;
+type external_d_ZodNeverDef = ZodNeverDef;
+type external_d_ZodNever = ZodNever;
+declare const external_d_ZodNever: typeof ZodNever;
+type external_d_ZodVoidDef = ZodVoidDef;
+type external_d_ZodVoid = ZodVoid;
+declare const external_d_ZodVoid: typeof ZodVoid;
+type external_d_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
+type external_d_ArrayCardinality = ArrayCardinality;
+type external_d_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
+declare const external_d_ZodArray: typeof ZodArray;
+type external_d_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
+declare const external_d_objectUtil: typeof objectUtil;
+type external_d_extendShape<A, B> = extendShape<A, B>;
+type external_d_Primitive = Primitive;
+type external_d_Scalars = Scalars;
+type external_d_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
+type external_d_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
+type external_d_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectOutputType<Shape, Catchall>;
+type external_d_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
+type external_d_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectInputType<Shape, Catchall>;
+type external_d_SomeZodObject = SomeZodObject;
+type external_d_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
+declare const external_d_ZodObject: typeof ZodObject;
+type external_d_AnyZodObject = AnyZodObject;
+type external_d_ZodUnionDef<T extends ZodUnionOptions = [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]> = ZodUnionDef<T>;
+type external_d_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
+declare const external_d_ZodUnion: typeof ZodUnion;
+type external_d_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
+type external_d_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
+declare const external_d_ZodIntersection: typeof ZodIntersection;
+type external_d_ZodTupleItems = ZodTupleItems;
+type external_d_AssertArray<T extends any> = AssertArray<T>;
+type external_d_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
+type external_d_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
+type external_d_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
+type external_d_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
+type external_d_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
+type external_d_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
+declare const external_d_ZodTuple: typeof ZodTuple;
+type external_d_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
+type external_d_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
+declare const external_d_ZodRecord: typeof ZodRecord;
+type external_d_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
+type external_d_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
+declare const external_d_ZodMap: typeof ZodMap;
+type external_d_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
+type external_d_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
+declare const external_d_ZodSet: typeof ZodSet;
+type external_d_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
+type external_d_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
+type external_d_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
+type external_d_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
+declare const external_d_ZodFunction: typeof ZodFunction;
+type external_d_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
+type external_d_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
+declare const external_d_ZodLazy: typeof ZodLazy;
+type external_d_ZodLiteralDef<T extends any = any> = ZodLiteralDef<T>;
+type external_d_ZodLiteral<T extends any> = ZodLiteral<T>;
+declare const external_d_ZodLiteral: typeof ZodLiteral;
+type external_d_ArrayKeys = ArrayKeys;
+type external_d_Indices<T> = Indices<T>;
+type external_d_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
+type external_d_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
+declare const external_d_ZodEnum: typeof ZodEnum;
+type external_d_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
+type external_d_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
+declare const external_d_ZodNativeEnum: typeof ZodNativeEnum;
+type external_d_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
+type external_d_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
+declare const external_d_ZodPromise: typeof ZodPromise;
+type external_d_Refinement<T> = Refinement<T>;
+type external_d_SuperRefinement<T> = SuperRefinement<T>;
+type external_d_RefinementEffect<T> = RefinementEffect<T>;
+type external_d_TransformEffect<T> = TransformEffect<T>;
+type external_d_PreprocessEffect<T> = PreprocessEffect<T>;
+type external_d_Effect<T> = Effect<T>;
+type external_d_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
+type external_d_ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> = ZodEffects<T, Output, Input>;
+declare const external_d_ZodEffects: typeof ZodEffects;
+type external_d_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
+type external_d_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
+type external_d_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
+declare const external_d_ZodOptional: typeof ZodOptional;
+type external_d_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
+type external_d_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
+type external_d_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
+declare const external_d_ZodNullable: typeof ZodNullable;
+type external_d_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
+type external_d_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
+declare const external_d_ZodDefault: typeof ZodDefault;
+declare const external_d_custom: typeof custom;
+declare const external_d_late: typeof late;
+type external_d_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
+declare const external_d_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
+type external_d_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
+type external_d_ZodIssueCode = ZodIssueCode;
+type external_d_ZodIssueBase = ZodIssueBase;
+type external_d_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
+type external_d_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
+type external_d_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
+type external_d_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
+type external_d_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
+type external_d_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
+type external_d_ZodInvalidDateIssue = ZodInvalidDateIssue;
+type external_d_StringValidation = StringValidation;
+type external_d_ZodInvalidStringIssue = ZodInvalidStringIssue;
+type external_d_ZodTooSmallIssue = ZodTooSmallIssue;
+type external_d_ZodTooBigIssue = ZodTooBigIssue;
+type external_d_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
+type external_d_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
+type external_d_ZodCustomIssue = ZodCustomIssue;
+type external_d_DenormalizedError = DenormalizedError;
+type external_d_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
+type external_d_ZodIssue = ZodIssue;
+declare const external_d_quotelessJson: typeof quotelessJson;
+type external_d_ZodFormattedError<T> = ZodFormattedError<T>;
+type external_d_ZodError<T = any> = ZodError<T>;
+declare const external_d_ZodError: typeof ZodError;
+type external_d_IssueData = IssueData;
+type external_d_MakeErrorData = MakeErrorData;
+type external_d_ZodErrorMap = ZodErrorMap;
+declare const external_d_defaultErrorMap: typeof defaultErrorMap;
+declare const external_d_overrideErrorMap: typeof overrideErrorMap;
+declare const external_d_setErrorMap: typeof setErrorMap;
+declare namespace external_d {
+  export {
+    external_d_ZodParsedType as ZodParsedType,
+    external_d_getParsedType as getParsedType,
+    external_d_makeIssue as makeIssue,
+    external_d_ParseParams as ParseParams,
+    external_d_ParsePathComponent as ParsePathComponent,
+    external_d_ParsePath as ParsePath,
+    external_d_EMPTY_PATH as EMPTY_PATH,
+    external_d_ParseContext as ParseContext,
+    external_d_ParseInput as ParseInput,
+    external_d_addIssueToContext as addIssueToContext,
+    external_d_ObjectPair as ObjectPair,
+    external_d_ParseStatus as ParseStatus,
+    external_d_ParseResult as ParseResult,
+    external_d_INVALID as INVALID,
+    external_d_DIRTY as DIRTY,
+    external_d_OK as OK,
+    external_d_SyncParseReturnType as SyncParseReturnType,
+    external_d_AsyncParseReturnType as AsyncParseReturnType,
+    external_d_ParseReturnType as ParseReturnType,
+    external_d_isAborted as isAborted,
+    external_d_isDirty as isDirty,
+    external_d_isValid as isValid,
+    external_d_isAsync as isAsync,
+    TypeOf as infer,
+    ZodEffects as ZodTransformer,
+    ZodType as Schema,
+    ZodType as ZodSchema,
+    anyType as any,
+    arrayType as array,
+    bigIntType as bigint,
+    booleanType as boolean,
+    dateType as date,
+    effectsType as effect,
+    enumType as enum,
+    functionType as function,
+    instanceOfType as instanceof,
+    intersectionType as intersection,
+    lazyType as lazy,
+    literalType as literal,
+    mapType as map,
+    nativeEnumType as nativeEnum,
+    neverType as never,
+    nullType as null,
+    nullableType as nullable,
+    numberType as number,
+    objectType as object,
+    external_d_oboolean as oboolean,
+    external_d_onumber as onumber,
+    optionalType as optional,
+    external_d_ostring as ostring,
+    preprocessType as preprocess,
+    promiseType as promise,
+    recordType as record,
+    setType as set,
+    strictObjectType as strictObject,
+    stringType as string,
+    effectsType as transformer,
+    tupleType as tuple,
+    undefinedType as undefined,
+    unionType as union,
+    unknownType as unknown,
+    voidType as void,
+    external_d_RefinementCtx as RefinementCtx,
+    external_d_ZodRawShape as ZodRawShape,
+    external_d_ZodTypeAny as ZodTypeAny,
+    external_d_TypeOf as TypeOf,
+    external_d_input as input,
+    external_d_output as output,
+    external_d_CustomErrorParams as CustomErrorParams,
+    external_d_ZodTypeDef as ZodTypeDef,
+    external_d_SafeParseSuccess as SafeParseSuccess,
+    external_d_SafeParseError as SafeParseError,
+    external_d_SafeParseReturnType as SafeParseReturnType,
+    external_d_ZodType as ZodType,
+    external_d_ZodStringDef as ZodStringDef,
+    external_d_ZodString as ZodString,
+    external_d_ZodNumberDef as ZodNumberDef,
+    external_d_ZodNumber as ZodNumber,
+    external_d_ZodBigIntDef as ZodBigIntDef,
+    external_d_ZodBigInt as ZodBigInt,
+    external_d_ZodBooleanDef as ZodBooleanDef,
+    external_d_ZodBoolean as ZodBoolean,
+    external_d_ZodDateDef as ZodDateDef,
+    external_d_ZodDate as ZodDate,
+    external_d_ZodUndefinedDef as ZodUndefinedDef,
+    external_d_ZodUndefined as ZodUndefined,
+    external_d_ZodNullDef as ZodNullDef,
+    external_d_ZodNull as ZodNull,
+    external_d_ZodAnyDef as ZodAnyDef,
+    external_d_ZodAny as ZodAny,
+    external_d_ZodUnknownDef as ZodUnknownDef,
+    external_d_ZodUnknown as ZodUnknown,
+    external_d_ZodNeverDef as ZodNeverDef,
+    external_d_ZodNever as ZodNever,
+    external_d_ZodVoidDef as ZodVoidDef,
+    external_d_ZodVoid as ZodVoid,
+    external_d_ZodArrayDef as ZodArrayDef,
+    external_d_ArrayCardinality as ArrayCardinality,
+    external_d_ZodArray as ZodArray,
+    external_d_ZodNonEmptyArray as ZodNonEmptyArray,
+    external_d_objectUtil as objectUtil,
+    external_d_extendShape as extendShape,
+    external_d_Primitive as Primitive,
+    external_d_Scalars as Scalars,
+    external_d_ZodObjectDef as ZodObjectDef,
+    external_d_baseObjectOutputType as baseObjectOutputType,
+    external_d_objectOutputType as objectOutputType,
+    external_d_baseObjectInputType as baseObjectInputType,
+    external_d_objectInputType as objectInputType,
+    external_d_SomeZodObject as SomeZodObject,
+    external_d_ZodObject as ZodObject,
+    external_d_AnyZodObject as AnyZodObject,
+    external_d_ZodUnionDef as ZodUnionDef,
+    external_d_ZodUnion as ZodUnion,
+    external_d_ZodIntersectionDef as ZodIntersectionDef,
+    external_d_ZodIntersection as ZodIntersection,
+    external_d_ZodTupleItems as ZodTupleItems,
+    external_d_AssertArray as AssertArray,
+    external_d_OutputTypeOfTuple as OutputTypeOfTuple,
+    external_d_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
+    external_d_InputTypeOfTuple as InputTypeOfTuple,
+    external_d_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
+    external_d_ZodTupleDef as ZodTupleDef,
+    external_d_ZodTuple as ZodTuple,
+    external_d_ZodRecordDef as ZodRecordDef,
+    external_d_ZodRecord as ZodRecord,
+    external_d_ZodMapDef as ZodMapDef,
+    external_d_ZodMap as ZodMap,
+    external_d_ZodSetDef as ZodSetDef,
+    external_d_ZodSet as ZodSet,
+    external_d_ZodFunctionDef as ZodFunctionDef,
+    external_d_OuterTypeOfFunction as OuterTypeOfFunction,
+    external_d_InnerTypeOfFunction as InnerTypeOfFunction,
+    external_d_ZodFunction as ZodFunction,
+    external_d_ZodLazyDef as ZodLazyDef,
+    external_d_ZodLazy as ZodLazy,
+    external_d_ZodLiteralDef as ZodLiteralDef,
+    external_d_ZodLiteral as ZodLiteral,
+    external_d_ArrayKeys as ArrayKeys,
+    external_d_Indices as Indices,
+    external_d_ZodEnumDef as ZodEnumDef,
+    external_d_ZodEnum as ZodEnum,
+    external_d_ZodNativeEnumDef as ZodNativeEnumDef,
+    external_d_ZodNativeEnum as ZodNativeEnum,
+    external_d_ZodPromiseDef as ZodPromiseDef,
+    external_d_ZodPromise as ZodPromise,
+    external_d_Refinement as Refinement,
+    external_d_SuperRefinement as SuperRefinement,
+    external_d_RefinementEffect as RefinementEffect,
+    external_d_TransformEffect as TransformEffect,
+    external_d_PreprocessEffect as PreprocessEffect,
+    external_d_Effect as Effect,
+    external_d_ZodEffectsDef as ZodEffectsDef,
+    external_d_ZodEffects as ZodEffects,
+    external_d_ZodOptionalDef as ZodOptionalDef,
+    external_d_ZodOptionalType as ZodOptionalType,
+    external_d_ZodOptional as ZodOptional,
+    external_d_ZodNullableDef as ZodNullableDef,
+    external_d_ZodNullableType as ZodNullableType,
+    external_d_ZodNullable as ZodNullable,
+    external_d_ZodDefaultDef as ZodDefaultDef,
+    external_d_ZodDefault as ZodDefault,
+    external_d_custom as custom,
+    external_d_late as late,
+    external_d_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
+    external_d_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
+    external_d_ZodIssueCode as ZodIssueCode,
+    external_d_ZodIssueBase as ZodIssueBase,
+    external_d_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
+    external_d_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
+    external_d_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
+    external_d_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
+    external_d_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
+    external_d_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
+    external_d_ZodInvalidDateIssue as ZodInvalidDateIssue,
+    external_d_StringValidation as StringValidation,
+    external_d_ZodInvalidStringIssue as ZodInvalidStringIssue,
+    external_d_ZodTooSmallIssue as ZodTooSmallIssue,
+    external_d_ZodTooBigIssue as ZodTooBigIssue,
+    external_d_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
+    external_d_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
+    external_d_ZodCustomIssue as ZodCustomIssue,
+    external_d_DenormalizedError as DenormalizedError,
+    external_d_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
+    external_d_ZodIssue as ZodIssue,
+    external_d_quotelessJson as quotelessJson,
+    external_d_ZodFormattedError as ZodFormattedError,
+    external_d_ZodError as ZodError,
+    external_d_IssueData as IssueData,
+    external_d_MakeErrorData as MakeErrorData,
+    external_d_ZodErrorMap as ZodErrorMap,
+    external_d_defaultErrorMap as defaultErrorMap,
+    external_d_overrideErrorMap as overrideErrorMap,
+    external_d_setErrorMap as setErrorMap,
+  };
+}
+
+declare namespace schema {
+  export {
+    external_d as define,
+  };
+}
+
+/**
+ * This schema represents the format of the session
+ * that we cache in the system to avoid unnecessary
+ * token exchanges.
+ *
+ * @example
+ *   {
+ *      "accounts.shopify.com": {...}
+ *      "identity.spin.com": {...}
+ *   }
+ *
+ */
+declare const SessionSchema: ZodObject<{}, "strip", ZodObject<{
+    /**
+     * It contains the identity token. Before usint it, we exchange it
+     * to get a token that we can use with different applications. The exchanged
+     * tokens for the applications are stored under applications.
+     */
+    identity: ZodObject<{
+        accessToken: ZodString;
+        refreshToken: ZodString;
+        expiresAt: ZodEffects<ZodDate, Date, Date>;
+        scopes: ZodArray<ZodString, "many">;
+    }, "strip", ZodTypeAny, {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: Date;
+        scopes: string[];
+    }, {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: Date;
+        scopes: string[];
+    }>;
+    /**
+     * It contains exchanged tokens for the applications the CLI
+     * authenticates with. Tokens are scoped under the fqdn of the applications.
+     */
+    applications: ZodObject<{
+        /**
+         * Exchanged tokens for Admin applications.
+         */
+        adminApi: ZodObject<{}, "strip", ZodObject<{
+            accessToken: ZodString;
+            expiresAt: ZodEffects<ZodDate, Date, Date>;
+            scopes: ZodArray<ZodString, "many">;
+        }, "strip", ZodTypeAny, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }>, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }>;
+        /**
+         * Exchanged tokens for Partner applications.
+         */
+        partnersApi: ZodObject<{}, "strip", ZodObject<{
+            accessToken: ZodString;
+            expiresAt: ZodEffects<ZodDate, Date, Date>;
+            scopes: ZodArray<ZodString, "many">;
+        }, "strip", ZodTypeAny, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }>, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }>;
+        /**
+         * Exchanged tokens for Storefront Renderer applications.
+         */
+        storefrontRendererApi: ZodObject<{}, "strip", ZodObject<{
+            accessToken: ZodString;
+            expiresAt: ZodEffects<ZodDate, Date, Date>;
+            scopes: ZodArray<ZodString, "many">;
+        }, "strip", ZodTypeAny, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }, {
+            accessToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        }>, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }, {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        }>;
+    }, "strip", ZodTypeAny, {
+        adminApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        partnersApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        storefrontRendererApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+    }, {
+        adminApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        partnersApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        storefrontRendererApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+    }>;
+}, "strip", ZodTypeAny, {
+    identity: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: Date;
+        scopes: string[];
+    };
+    applications: {
+        adminApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        partnersApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        storefrontRendererApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+    };
+}, {
+    identity: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: Date;
+        scopes: string[];
+    };
+    applications: {
+        adminApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        partnersApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+        storefrontRendererApi: {
+            [x: string]: {
+                accessToken: string;
+                expiresAt: Date;
+                scopes: string[];
+            };
+        };
+    };
+}>, {
+    [x: string]: {
+        identity: {
+            accessToken: string;
+            refreshToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        };
+        applications: {
+            adminApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+            partnersApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+            storefrontRendererApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+        };
+    };
+}, {
+    [x: string]: {
+        identity: {
+            accessToken: string;
+            refreshToken: string;
+            expiresAt: Date;
+            scopes: string[];
+        };
+        applications: {
+            adminApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+            partnersApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+            storefrontRendererApi: {
+                [x: string]: {
+                    accessToken: string;
+                    expiresAt: Date;
+                    scopes: string[];
+                };
+            };
+        };
+    };
+}>;
+declare type Session = TypeOf<typeof SessionSchema>;
+
+/**
+ * A scope supported by the Shopify Admin API.
+ */
+declare type AdminAPIScope = 'graphql' | 'themes' | 'collaborator' | string;
+/**
+ * It represents the options to authenticate against the Shopify Admin API.
+ */
+interface AdminAPIOAuthOptions {
+    /** List of scopes to request permissions for */
+    scopes: AdminAPIScope[];
+}
+/**
+ * A scope supported by the Partners API.
+ */
+declare type PartnersAPIScope = 'cli' | string;
+interface PartnersAPIOAuthOptions {
+    /** List of scopes to request permissions for */
+    scopes: PartnersAPIScope[];
+}
+/**
+ * A scope supported by the Storefront Renderer API.
+ */
+declare type StorefrontRendererScope = 'devtools' | string;
+interface StorefrontRendererAPIOAuthOptions {
+    /** List of scopes to request permissions for */
+    scopes: StorefrontRendererScope[];
+}
+interface ShopifyOAuthOptions {
+    storeFqdn?: string;
+    storefrontRendererApi?: StorefrontRendererAPIOAuthOptions;
+    adminApi?: AdminAPIOAuthOptions;
+}
+/**
+ * It represents the authentication requirements and
+ * is the input necessary to trigger the authentication
+ * flow.
+ */
+interface OAuthApplications {
+    shopify?: ShopifyOAuthOptions;
+    partnersApi?: PartnersAPIOAuthOptions;
+}
+/**
+ * This method ensures that we have a valid session to authenticate against the given applications using the provided scopes.
+ * @param options {OAuthApplications} An object containing the applications we need to be authenticated with.
+ * @returns {OAuthSession} An instance with the access tokens organized by application.
+ */
+declare function ensureAuthenticated(applications: OAuthApplications): Promise<Session>;
+
+declare const session_ensureAuthenticated: typeof ensureAuthenticated;
+declare namespace session {
+  export {
+    session_ensureAuthenticated as ensureAuthenticated,
+  };
+}
+
+declare function parse(input: string): object;
+
+declare const toml_parse: typeof parse;
+declare namespace toml {
+  export {
+    toml_parse as parse,
+  };
+}
+
+/**
+ * JSON Schema
+ *
+ * Documentation corresponds to the work-in-progress draft-07 of JSON Schema.
+ *
+ * The latest published drafts are:
+ * - draft-handrews-json-schema-01
+ * - draft-handrews-json-schema-validation-01
+ *
+ * For more information, visit: http://json-schema.org/.
+ *
+ * Draft date: March 19, 2018.
+ *
+ * @public
+ */
+interface JSONSchema {
+  /**
+   * This keyword is reserved for comments from schema authors to readers or
+   * maintainers of the schema. The value of this keyword MUST be a string.
+   * Implementations MUST NOT present this string to end users. Tools for
+   * editing schemas SHOULD support displaying and editing this keyword.
+   *
+   * The value of this keyword MAY be used in debug or error output which is
+   * intended for developers making use of schemas. Schema vocabularies SHOULD
+   * allow "$comment" within any object containing vocabulary keywords.
+   *
+   * Implementations MAY assume "$comment" is allowed unless the vocabulary
+   * specifically forbids it. Vocabularies MUST NOT specify any effect of
+   * "$comment" beyond what is described in this specification. Tools that
+   * translate other media types or programming languages to and from
+   * application/schema+json MAY choose to convert that media type or
+   * programming language's native comments to or from "$comment" values.
+   *
+   * The behavior of such translation when both native comments and "$comment"
+   * properties are present is implementation-dependent. Implementations SHOULD
+   * treat "$comment" identically to an unknown extension keyword.
+   *
+   * They MAY strip "$comment" values at any point during processing. In
+   * particular, this allows for shortening schemas when the size of deployed
+   * schemas is a concern. Implementations MUST NOT take any other action based
+   * on the presence, absence, or contents of "$comment" properties.
+   */
+  $comment?: string
+  /**
+   * The "$id" keyword defines a URI for the schema, and the base URI that other
+   * URI references within the schema are resolved against. A subschema's "$id"
+   * is resolved against the base URI of its parent schema. If no parent sets an
+   * explicit base with "$id", the base URI is that of the entire document, as
+   * determined per [RFC 3986 section 5][RFC3986].
+   *
+   * If present, the value for this keyword MUST be a string, and MUST represent
+   * a valid [URI-reference][RFC3986]. This value SHOULD be normalized, and
+   * SHOULD NOT be an empty fragment <#> or an empty string <>.
+   *
+   * [RFC3986]: http://json-schema.org/latest/json-schema-core.html#RFC3986
+   */
+  $id?: string
+  /**
+   * The "$ref" keyword is used to reference a schema, and provides the ability
+   * to validate recursive structures through self-reference.
+   *
+   * An object schema with a "$ref" property MUST be interpreted as a "$ref"
+   * reference. The value of the "$ref" property MUST be a URI Reference.
+   * Resolved against the current URI base, it identifies the URI of a schema to
+   * use. All other properties in a "$ref" object MUST be ignored.
+   *
+   * The URI is not a network locator, only an identifier. A schema need not be
+   * downloadable from the address if it is a network-addressable URL, and
+   * implementations SHOULD NOT assume they should perform a network operation
+   * when they encounter a network-addressable URI.
+   *
+   * A schema MUST NOT be run into an infinite loop against a schema. For
+   * example, if two schemas "#alice" and "#bob" both have an "allOf" property
+   * that refers to the other, a naive validator might get stuck in an infinite
+   * recursive loop trying to validate the instance. Schemas SHOULD NOT make use
+   * of infinite recursive nesting like this; the behavior is undefined.
+   */
+  $ref?: string
+  /**
+   * The "$schema" keyword is both used as a JSON Schema version identifier and
+   * the location of a resource which is itself a JSON Schema, which describes
+   * any schema written for this particular version.
+   *
+   * The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
+   * and this URI MUST be normalized. The current schema MUST be valid against
+   * the meta-schema identified by this URI.
+   *
+   * If this URI identifies a retrievable resource, that resource SHOULD be of
+   * media type "application/schema+json".
+   *
+   * The "$schema" keyword SHOULD be used in a root schema. It MUST NOT appear
+   * in subschemas.
+   *
+   * Values for this property are defined in other documents and by other
+   * parties. JSON Schema implementations SHOULD implement support for current
+   * and previous published drafts of JSON Schema vocabularies as deemed
+   * reasonable.
+   *
+   * [RFC3986]: http://json-schema.org/latest/json-schema-core.html#RFC3986
+   */
+  $schema?: string
+  /**
+   * The value of "additionalItems" MUST be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for arrays, and does
+   * not directly validate the immediate instance itself.
+   *
+   * If "items" is an array of schemas, validation succeeds if every instance
+   * element at a position greater than the size of "items" validates against
+   * "additionalItems".
+   *
+   * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
+   * (possibly the default value of an empty schema) is applied to all elements.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   */
+  additionalItems?: JSONSchema | boolean
+  /**
+   * The value of "additionalProperties" MUST be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and does
+   * not directly validate the immediate instance itself.
+   *
+   * Validation with "additionalProperties" applies only to the child values of
+   * instance names that do not match any names in "properties", and do not
+   * match any regular expression in "patternProperties".
+   *
+   * For all such properties, validation succeeds if the child instance
+   * validates against the "additionalProperties" schema.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   */
+  additionalProperties?: JSONSchema | boolean
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array MUST
+   * be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against all schemas defined by this keyword's value.
+   */
+  allOf?: (JSONSchema | boolean)[]
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array MUST
+   * be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against at least one schema defined by this keyword's value.
+   */
+  anyOf?: (JSONSchema | boolean)[]
+  /**
+   * The value of this keyword MAY be of any type, including null.
+   *
+   * An instance validates successfully against this keyword if its value is
+   * equal to the value of the keyword.
+   */
+  const?: any
+  /**
+   * The value of this keyword MUST be a valid JSON Schema.
+   *
+   * An array instance is valid against "contains" if at least one of its
+   * elements is valid against the given schema.
+   */
+  contains?: JSONSchema | boolean
+  /**
+   * If the instance value is a string, this property defines that the string
+   * SHOULD be interpreted as binary data and decoded using the encoding named
+   * by this property. [RFC 2045, Sec 6.1][RFC2045] lists the possible values for
+   * this property.
+   *
+   * The value of this property SHOULD be ignored if the instance described is
+   * not a string.
+   *
+   * [RFC2045]: https://tools.ietf.org/html/rfc2045#section-6.1
+   */
+  contentEncoding?: JSONSchemaContentEncodingName | JSONSchemaContentEncoding
+  /**
+   * The value of this property must be a media type, as defined by
+   * [RFC 2046][RFC2046]. This property defines the media type of instances
+   * which this schema defines.
+   *
+   * The value of this property SHOULD be ignored if the instance described is
+   * not a string.
+   *
+   * If the "contentEncoding" property is not present, but the instance value is
+   * a string, then the value of this property SHOULD specify a text document
+   * type, and the character set SHOULD be the character set into which the
+   * JSON string value was decoded (for which the default is Unicode).
+   *
+   * [RFC2046]: https://tools.ietf.org/html/rfc2046
+   */
+  contentMediaType?: string
+  /**
+   * There are no restrictions placed on the value of this keyword. When
+   * multiple occurrences of this keyword are applicable to a single
+   * sub-instance, implementations SHOULD remove duplicates.
+   *
+   * This keyword can be used to supply a default JSON value associated with a
+   * particular schema. It is RECOMMENDED that a default value be valid against
+   * the associated schema.
+   */
+  default?: any
+  /**
+   * The "definitions" keywords provides a standardized location for schema
+   * authors to inline re-usable JSON Schemas into a more general schema. The
+   * keyword does not directly affect the validation result.
+   *
+   * This keyword's value MUST be an object. Each member value of this object
+   * MUST be a valid JSON Schema.
+   */
+  definitions?: {
+    [key: string]: JSONSchema | boolean
+  }
+  /**
+   * This keyword specifies rules that are evaluated if the instance is an
+   * object and contains a certain property.
+   *
+   * This keyword's value MUST be an object. Each property specifies a
+   * dependency. Each dependency value MUST be an array or a valid JSON Schema.
+   *
+   * If the dependency value is a subschema, and the dependency key is a
+   * property in the instance, the entire instance must validate against the
+   * dependency value.
+   *
+   * If the dependency value is an array, each element in the array, if any,
+   * MUST be a string, and MUST be unique. If the dependency key is a property
+   * in the instance, each of the items in the dependency value must be a
+   * property that exists in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   */
+  dependencies?:
+    | {
+        [key: string]: JSONSchema | boolean | string[]
+      }
+    | string[]
+  /**
+   * Can be used to decorate a user interface with explanation or information
+   * about the data produced.
+   */
+  description?: string
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * When "if" is present, and the instance fails to validate against its
+   * subschema, then validation succeeds against this keyword if the instance
+   * successfully validates against this keyword's subschema.
+   *
+   * This keyword has no effect when "if" is absent, or when the instance
+   * successfully validates against its subschema. Implementations MUST NOT
+   * evaluate the instance against this keyword, for either validation or
+   * annotation collection purposes, in such cases.
+   */
+  else?: JSONSchema | boolean
+  /**
+   * The value of this keyword MUST be an array. This array SHOULD have at least
+   * one element. Elements in the array SHOULD be unique.
+   *
+   * An instance validates successfully against this keyword if its value is
+   * equal to one of the elements in this keyword's array value.
+   *
+   * Elements in the array might be of any value, including null.
+   */
+  enum?: any[]
+  /**
+   * The value of this keyword MUST be an array. There are no restrictions
+   * placed on the values within the array. When multiple occurrences of this
+   * keyword are applicable to a single sub-instance, implementations MUST
+   * provide a flat array of all values rather than an array of arrays.
+   *
+   * This keyword can be used to provide sample JSON values associated with a
+   * particular schema, for the purpose of illustrating usage. It is RECOMMENDED
+   * that these values be valid against the associated schema.
+   *
+   * Implementations MAY use the value(s) of "default", if present, as an
+   * additional example. If "examples" is absent, "default" MAY still be used in
+   * this manner.
+   */
+  examples?: any[]
+  /**
+   * The value of "exclusiveMaximum" MUST be number, representing an exclusive
+   * upper limit for a numeric instance.
+   *
+   * If the instance is a number, then the instance is valid only if it has a
+   * value strictly less than (not equal to) "exclusiveMaximum".
+   */
+  exclusiveMaximum?: number
+  /**
+   * The value of "exclusiveMinimum" MUST be number, representing an exclusive
+   * lower limit for a numeric instance.
+   *
+   * If the instance is a number, then the instance is valid only if it has a
+   * value strictly greater than (not equal to) "exclusiveMinimum".
+   */
+  exclusiveMinimum?: number
+  /**
+   * The "format" keyword functions as both an [annotation][annotation] and as
+   * an [assertion][assertion]. While no special effort is required to implement
+   * it as an annotation conveying semantic meaning, implementing validation is
+   * non-trivial.
+   *
+   * Implementations MAY support the "format" keyword as a validation assertion.
+   * Should they choose to do so:
+   *
+   *  - they SHOULD implement validation for attributes defined below;
+   *  - they SHOULD offer an option to disable validation for this keyword.
+   *
+   * Implementations MAY add custom format attributes. Save for agreement
+   * between parties, schema authors SHALL NOT expect a peer implementation to
+   * support this keyword and/or custom format attributes.
+   *
+   * [annotation]: http://json-schema.org/latest/json-schema-validation.html#annotations
+   * [assertion]: http://json-schema.org/latest/json-schema-validation.html#assertions
+   */
+  format?:
+    | JSONSchemaFormat
+    | 'date'
+    | 'date-time'
+    | 'email'
+    | 'full-date'
+    | 'full-time'
+    | 'hostname'
+    | 'idn-email'
+    | 'idn-hostname'
+    | 'ipv4'
+    | 'ipv6'
+    | 'iri'
+    | 'iri-reference'
+    | 'json-pointer'
+    | 'json-pointer-uri-fragment'
+    | 'regex'
+    | 'relative-json-pointer'
+    | 'time'
+    | 'uri'
+    | 'uri-reference'
+    | 'uri-template'
+    | 'uuid'
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * This validation outcome of this keyword's subschema has no direct effect on
+   * the overall validation result. Rather, it controls which of the "then" or
+   * "else" keywords are evaluated.
+   *
+   * Instances that successfully validate against this keyword's subschema MUST
+   * also be valid against the subschema value of the "then" keyword, if
+   * present.
+   *
+   * Instances that fail to validate against this keyword's subschema MUST also
+   * be valid against the subschema value of the "else" keyword, if present.
+   *
+   * If [annotations][annotations] are being collected, they are collected from
+   * this keyword's subschema in the usual way, including when the keyword is
+   * present without either "then" or "else".
+   *
+   * [annotations]: http://json-schema.org/latest/json-schema-validation.html#annotations
+   */
+  if?: JSONSchema | boolean
+  /**
+   * The value of "items" MUST be either a valid JSON Schema or an array of
+   * valid JSON Schemas.
+   *
+   * This keyword determines how child instances validate for arrays, and does
+   * not directly validate the immediate instance itself.
+   *
+   * If "items" is a schema, validation succeeds if all elements in the array
+   * successfully validate against that schema.
+   *
+   * If "items" is an array of schemas, validation succeeds if each element of
+   * the instance validates against the schema at the same position, if any.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   */
+  items?: JSONSchema | boolean | (JSONSchema | boolean)[]
+  /**
+   * The value of "maximum" MUST be a number, representing an inclusive upper
+   * limit for a numeric instance.
+   *
+   * If the instance is a number, then this keyword validates only if the
+   * instance is less than or exactly equal to "maximum".
+   */
+  maximum?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An array instance is valid against "maxItems" if its size is less than, or
+   * equal to, the value of this keyword.
+   */
+  maxItems?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * A string instance is valid against this keyword if its length is less than,
+   * or equal to, the value of this keyword.
+   *
+   * The length of a string instance is defined as the number of its characters
+   * as defined by [RFC 7159][RFC7159].
+   *
+   * [RFC7159]: http://json-schema.org/latest/json-schema-validation.html#RFC7159
+   */
+  maxLength?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An object instance is valid against "maxProperties" if its number of
+   * properties is less than, or equal to, the value of this keyword.
+   */
+  maxProperties?: number
+  /**
+   * The value of "minimum" MUST be a number, representing an inclusive lower
+   * limit for a numeric instance.
+   *
+   * If the instance is a number, then this keyword validates only if the
+   * instance is greater than or exactly equal to "minimum".
+   */
+  minimum?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * A string instance is valid against this keyword if its length is greater
+   * than, or equal to, the value of this keyword.
+   *
+   * The length of a string instance is defined as the number of its characters
+   * as defined by [RFC 7159][RFC7159].
+   *
+   * Omitting this keyword has the same behavior as a value of 0.
+   *
+   * [RFC7159]: http://json-schema.org/latest/json-schema-validation.html#RFC7159
+   */
+  minLength?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An array instance is valid against "minItems" if its size is greater than,
+   * or equal to, the value of this keyword.
+   *
+   * Omitting this keyword has the same behavior as a value of 0.
+   */
+  minItems?: number
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An object instance is valid against "minProperties" if its number of
+   * properties is greater than, or equal to, the value of this keyword.
+   *
+   * Omitting this keyword has the same behavior as a value of 0.
+   */
+  minProperties?: number
+  /**
+   * The value of "multipleOf" MUST be a number, strictly greater than 0.
+   *
+   * A numeric instance is valid only if division by this keyword's value
+   * results in an integer.
+   */
+  multipleOf?: number
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * An instance is valid against this keyword if it fails to validate
+   * successfully against the schema defined by this keyword.
+   */
+  not?: JSONSchema | boolean
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array MUST
+   * be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against exactly one schema defined by this keyword's value.
+   */
+  oneOf?: (JSONSchema | boolean)[]
+  /**
+   * The value of this keyword MUST be a string. This string SHOULD be a valid
+   * regular expression, according to the ECMA 262 regular expression dialect.
+   *
+   * A string instance is considered valid if the regular expression matches the
+   * instance successfully. Recall: regular expressions are not implicitly
+   * anchored.
+   */
+  pattern?: string
+  /**
+   * The value of "patternProperties" MUST be an object. Each property name of
+   * this object SHOULD be a valid regular expression, according to the ECMA 262
+   * regular expression dialect. Each property value of this object MUST be a
+   * valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and does
+   * not directly validate the immediate instance itself. Validation of the
+   * primitive instance type against this keyword always succeeds.
+   *
+   * Validation succeeds if, for each instance name that matches any regular
+   * expressions that appear as a property name in this keyword's value, the
+   * child instance for that name successfully validates against each schema
+   * that corresponds to a matching regular expression.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   */
+  patternProperties?: {
+    [key: string]: JSONSchema | boolean
+  }
+  /**
+   * The value of "properties" MUST be an object. Each value of this object MUST
+   * be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and does
+   * not directly validate the immediate instance itself.
+   *
+   * Validation succeeds if, for each name that appears in both the instance and
+   * as a name within this keyword's value, the child instance for that name
+   * successfully validates against the corresponding schema.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   */
+  properties?: {
+    [key: string]: JSONSchema | boolean
+  }
+  /**
+   * The value of "propertyNames" MUST be a valid JSON Schema.
+   *
+   * If the instance is an object, this keyword validates if every property name
+   * in the instance validates against the provided schema. Note the property
+   * name that the schema is testing will always be a string.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   */
+  propertyNames?: JSONSchema | boolean
+  /**
+   * The value of this keywords MUST be a boolean. When multiple occurrences of
+   * this keyword are applicable to a single sub-instance, the resulting value
+   * MUST be true if any occurrence specifies a true value, and MUST be false
+   * otherwise.
+   *
+   * If "readOnly" has a value of boolean true, it indicates that the value of
+   * the instance is managed exclusively by the owning authority, and attempts
+   * by an application to modify the value of this property are expected to be
+   * ignored or rejected by that owning authority.
+   *
+   * An instance document that is marked as "readOnly for the entire document
+   * MAY be ignored if sent to the owning authority, or MAY result in an error,
+   * at the authority's discretion.
+   *
+   * For example, "readOnly" would be used to mark a database-generated serial
+   * number as read-only.
+   *
+   * This keywords can be used to assist in user interface instance generation.
+   *
+   * @default false
+   */
+  readOnly?: boolean
+  /**
+   * The value of this keyword MUST be an array. Elements of this array, if any,
+   * MUST be strings, and MUST be unique.
+   *
+   * An object instance is valid against this keyword if every item in the array
+   * is the name of a property in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty array.
+   *
+   * @default []
+   */
+  required?: string[]
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * When "if" is present, and the instance successfully validates against its
+   * subschema, then validation succeeds against this keyword if the instance
+   * also successfully validates against this keyword's subschema.
+   *
+   * This keyword has no effect when "if" is absent, or when the instance fails
+   * to validate against its subschema. Implementations MUST NOT evaluate the
+   * instance against this keyword, for either validation or annotation
+   * collection purposes, in such cases.
+   */
+  then?: JSONSchema | boolean
+  /**
+   * Can be used to decorate a user interface with a short label about the data
+   * produced.
+   */
+  title?: string
+  /**
+   * The value of this keyword MUST be either a string or an array. If it is an
+   * array, elements of the array MUST be strings and MUST be unique.
+   *
+   * String values MUST be one of the six primitive types ("null", "boolean",
+   * "object", "array", "number", or "string"), or "integer" which matches any
+   * number with a zero fractional part.
+   *
+   * An instance validates if and only if the instance is in any of the sets
+   * listed for this keyword.
+   */
+  type?:
+    | JSONSchemaType
+    | JSONSchemaTypeName
+    | (JSONSchemaType | JSONSchemaTypeName)[]
+  /**
+   * The value of this keyword MUST be a boolean.
+   *
+   * If this keyword has boolean value false, the instance validates
+   * successfully. If it has boolean value true, the instance validates
+   * successfully if all of its elements are unique.
+   *
+   * Omitting this keyword has the same behavior as a value of false.
+   *
+   * @default false
+   */
+  uniqueItems?: boolean
+  /**
+   * The value of this keyword MUST be a boolean. When multiple occurrences of
+   * this keyword is applicable to a single sub-instance, the resulting value
+   * MUST be true if any occurrence specifies a true value, and MUST be false
+   * otherwise.
+   *
+   * If "writeOnly" has a value of boolean true, it indicates that the value is
+   * never present when the instance is retrieved from the owning authority. It
+   * can be present when sent to the owning authority to update or create the
+   * document (or the resource it represents), but it will not be included in
+   * any updated or newly created version of the instance.
+   *
+   * An instance document that is marked as "writeOnly" for the entire document
+   * MAY be returned as a blank document of some sort, or MAY produce an error
+   * upon retrieval, or have the retrieval request ignored, at the authority's
+   * discretion.
+   *
+   * For example, "writeOnly" would be used to mark a password input field.
+   *
+   * These keywords can be used to assist in user interface instance generation.
+   * In particular, an application MAY choose to use a widget that hides input
+   * values as they are typed for write-only fields.
+   *
+   * @default false
+   */
+  writeOnly?: boolean
+}
+/**
+ * String formats.
+ *
+ * @public
+ */
+declare enum JSONSchemaFormat {
+  /**
+   * A string instance is valid against this attribute if it is a valid
+   * representation according to the "full-date" production in
+   * [RFC 3339][RFC3339].
+   *
+   * [RFC3339]: http://json-schema.org/latest/json-schema-validation.html#RFC3339
+   */
+  Date = 'date',
+  /**
+   * A string instance is valid against this attribute if it is a valid
+   * representation according to the "date-time" production in
+   * [RFC 3339][RFC3339].
+   *
+   * [RFC3339]: http://json-schema.org/latest/json-schema-validation.html#RFC3339
+   */
+  DateTime = 'date-time',
+  /**
+   * A string instance is valid against these attributes if it is a valid
+   * Internet email address as defined by [RFC 5322, section 3.4.1][RFC5322].
+   *
+   * [RFC5322]: http://json-schema.org/latest/json-schema-validation.html#RFC5322
+   */
+  Email = 'email',
+  /**
+   * As defined by [RFC 1034, section 3.1][RFC1034], including host names
+   * produced using the Punycode algorithm specified in
+   * [RFC 5891, section 4.4][RFC5891].
+   *
+   * [RFC1034]: http://json-schema.org/latest/json-schema-validation.html#RFC1034
+   * [RFC5891]: http://json-schema.org/latest/json-schema-validation.html#RFC5891
+   */
+  Hostname = 'hostname',
+  /**
+   * A string instance is valid against these attributes if it is a valid
+   * Internet email address as defined by [RFC 6531][RFC6531].
+   *
+   * [RFC6531]: http://json-schema.org/latest/json-schema-validation.html#RFC6531
+   */
+  IDNEmail = 'idn-email',
+  /**
+   * As defined by either [RFC 1034, section 3.1][RFC1034] as for hostname, or
+   * an internationalized hostname as defined by
+   * [RFC 5890, section 2.3.2.3][RFC5890].
+   *
+   * [RFC1034]: http://json-schema.org/latest/json-schema-validation.html#RFC1034
+   * [RFC5890]: http://json-schema.org/latest/json-schema-validation.html#RFC5890
+   */
+  IDNHostname = 'idn-hostname',
+  /**
+   * An IPv4 address according to the "dotted-quad" ABNF syntax as defined in
+   * [RFC 2673, section 3.2][RFC2673].
+   *
+   * [RFC2673]: http://json-schema.org/latest/json-schema-validation.html#RFC2673
+   */
+  IPv4 = 'ipv4',
+  /**
+   * An IPv6 address as defined in [RFC 4291, section 2.2][RFC4291].
+   *
+   * [RFC4291]: http://json-schema.org/latest/json-schema-validation.html#RFC4291
+   */
+  IPv6 = 'ipv6',
+  /**
+   * A string instance is valid against this attribute if it is a valid IRI,
+   * according to [RFC3987][RFC3987].
+   *
+   * [RFC3987]: http://json-schema.org/latest/json-schema-validation.html#RFC3987
+   */
+  IRI = 'iri',
+  /**
+   * A string instance is valid against this attribute if it is a valid IRI
+   * Reference (either an IRI or a relative-reference), according to
+   * [RFC3987][RFC3987].
+   *
+   * [RFC3987]: http://json-schema.org/latest/json-schema-validation.html#RFC3987
+   */
+  IRIReference = 'iri-reference',
+  /**
+   * A string instance is valid against this attribute if it is a valid JSON
+   * string representation of a JSON Pointer, according to
+   * [RFC 6901, section 5][RFC6901].
+   *
+   * [RFC6901]: http://json-schema.org/latest/json-schema-validation.html#RFC6901
+   */
+  JSONPointer = 'json-pointer',
+  /**
+   * A string instance is valid against this attribute if it is a valid JSON
+   * string representation of a JSON Pointer fragment, according to
+   * [RFC 6901, section 5][RFC6901].
+   *
+   * [RFC6901]: http://json-schema.org/latest/json-schema-validation.html#RFC6901
+   */
+  JSONPointerURIFragment = 'json-pointer-uri-fragment',
+  /**
+   * This attribute applies to string instances.
+   *
+   * A regular expression, which SHOULD be valid according to the
+   * [ECMA 262][ecma262] regular expression dialect.
+   *
+   * Implementations that validate formats MUST accept at least the subset of
+   * [ECMA 262][ecma262] defined in the [Regular Expressions][regexInterop]
+   * section of this specification, and SHOULD accept all valid
+   * [ECMA 262][ecma262] expressions.
+   *
+   * [ecma262]: http://json-schema.org/latest/json-schema-validation.html#ecma262
+   * [regexInterop]: http://json-schema.org/latest/json-schema-validation.html#regexInterop
+   */
+  RegEx = 'regex',
+  /**
+   * A string instance is valid against this attribute if it is a valid
+   * [Relative JSON Pointer][relative-json-pointer].
+   *
+   * [relative-json-pointer]: http://json-schema.org/latest/json-schema-validation.html#relative-json-pointer
+   */
+  RelativeJSONPointer = 'relative-json-pointer',
+  /**
+   * A string instance is valid against this attribute if it is a valid
+   * representation according to the "time" production in [RFC 3339][RFC3339].
+   *
+   * [RFC3339]: http://json-schema.org/latest/json-schema-validation.html#RFC3339
+   */
+  Time = 'time',
+  /**
+   * A string instance is valid against this attribute if it is a valid URI,
+   * according to [RFC3986][RFC3986].
+   *
+   * [RFC3986]: http://json-schema.org/latest/json-schema-validation.html#RFC3986
+   */
+  URI = 'uri',
+  /**
+   * A string instance is valid against this attribute if it is a valid URI
+   * Reference (either a URI or a relative-reference), according to
+   * [RFC3986][RFC3986].
+   *
+   * [RFC3986]: http://json-schema.org/latest/json-schema-validation.html#RFC3986
+   */
+  URIReference = 'uri-reference',
+  /**
+   * A string instance is valid against this attribute if it is a valid URI
+   * Template (of any level), according to [RFC6570][RFC6570].
+   *
+   * Note that URI Templates may be used for IRIs; there is no separate IRI
+   * Template specification.
+   *
+   * [RFC6570]: http://json-schema.org/latest/json-schema-validation.html#RFC6570
+   */
+  URITemplate = 'uri-template',
+  /**
+   * UUID
+   */
+  UUID = 'uuid'
+}
+/**
+ * JSON Schema type.
+ *
+ * @public
+ */
+declare type JSONSchemaTypeName =
+  | 'array'
+  | 'boolean'
+  | 'integer'
+  | 'null'
+  | 'number'
+  | 'object'
+  | 'string'
+/**
+ * JSON Schema type.
+ *
+ * @public
+ */
+declare enum JSONSchemaType {
+  /**
+   * Array
+   */
+  Array = 'array',
+  /**
+   * Boolean
+   */
+  Boolean = 'boolean',
+  /**
+   * Integer
+   */
+  Integer = 'integer',
+  /**
+   * Null
+   */
+  Null = 'null',
+  /**
+   * Number
+   */
+  Number = 'number',
+  /**
+   * Object
+   */
+  Object = 'object',
+  /**
+   * String
+   */
+  String = 'string'
+}
+/**
+ * Content encoding name.
+ *
+ * @public
+ */
+declare type JSONSchemaContentEncodingName =
+  | '7bit'
+  | '8bit'
+  | 'binary'
+  | 'quoted-printable'
+  | 'base64'
+  | 'ietf-token'
+  | 'x-token'
+/**
+ * Content encoding strategy.
+ *
+ * @public
+ * {@link https://tools.ietf.org/html/rfc2045#section-6.1}
+ * {@link https://stackoverflow.com/questions/25710599/content-transfer-encoding-7bit-or-8-bit/28531705#28531705}
+ */
+declare enum JSONSchemaContentEncoding {
+  /**
+   * Only US-ASCII characters, which use the lower 7 bits for each character.
+   *
+   * Each line must be less than 1,000 characters.
+   */
+  '7bit' = '7bit',
+  /**
+   * Allow extended ASCII characters which can use the 8th (highest) bit to
+   * indicate special characters not available in 7bit.
+   *
+   * Each line must be less than 1,000 characters.
+   */
+  '8bit' = '8bit',
+  /**
+   * Same character set as 8bit, with no line length restriction.
+   */
+  Binary = 'binary',
+  /**
+   * Lines are limited to 76 characters, and line breaks are represented using
+   * special characters that are escaped.
+   */
+  QuotedPrintable = 'quoted-printable',
+  /**
+   * Useful for data that is mostly non-text.
+   */
+  Base64 = 'base64',
+  /**
+   * An extension token defined by a standards-track RFC and registered with
+   * IANA.
+   */
+  IETFToken = 'ietf-token',
+  /**
+   * The two characters "X-" or "x-" followed, with no intervening white space,
+   * by any token.
+   */
+  XToken = 'x-token'
+}
+
+interface Options<T> {
+    /**
+    Config used if there are no existing config.
+
+    **Note:** The values in `defaults` will overwrite the `default` key in the `schema` option.
+    */
+    defaults?: Readonly<T>;
+    /**
+    [JSON Schema](https://json-schema.org) to validate your config data.
+
+    Under the hood, the JSON Schema validator [ajv](https://github.com/epoberezkin/ajv) is used to validate your config. We use [JSON Schema draft-07](https://json-schema.org/latest/json-schema-validation.html) and support all [validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md) and [formats](https://github.com/epoberezkin/ajv#formats).
+
+    You should define your schema as an object where each key is the name of your data's property and each value is a JSON schema used to validate that property. See more [here](https://json-schema.org/understanding-json-schema/reference/object.html#properties).
+
+    @example
+    ```
+    import Conf = require('conf');
+
+    const schema = {
+        foo: {
+            type: 'number',
+            maximum: 100,
+            minimum: 1,
+            default: 50
+        },
+        bar: {
+            type: 'string',
+            format: 'url'
+        }
+    };
+
+    const config = new Conf({schema});
+
+    console.log(config.get('foo'));
+    //=> 50
+
+    config.set('foo', '1');
+    // [Error: Config schema violation: `foo` should be number]
+    ```
+
+    **Note:** The `default` value will be overwritten by the `defaults` option if set.
+    */
+    schema?: Schema<T>;
+    /**
+    Name of the config file (without extension).
+
+    Useful if you need multiple config files for your app or module. For example, different config files between two major versions.
+
+    @default 'config'
+    */
+    configName?: string;
+    /**
+    You only need to specify this if you don't have a package.json file in your project or if it doesn't have a name defined within it.
+
+    Default: The name field in the `package.json` closest to where `conf` is imported.
+    */
+    projectName?: string;
+    /**
+    You only need to specify this if you don't have a package.json file in your project or if it doesn't have a version defined within it.
+
+    Default: The name field in the `package.json` closest to where `conf` is imported.
+    */
+    projectVersion?: string;
+    /**
+    You can use migrations to perform operations to the store whenever a version is changed.
+
+    The `migrations` object should consist of a key-value pair of `'version': handler`. The `version` can also be a [semver range](https://github.com/npm/node-semver#ranges).
+
+    Note: The version the migrations use refers to the __project version__ by default. If you want to change this behavior, specify the `projectVersion` option.
+
+    @example
+    ```
+    import Conf = require('conf');
+
+    const store = new Conf({
+        migrations: {
+            '0.0.1': store => {
+                store.set('debugPhase', true);
+            },
+            '1.0.0': store => {
+                store.delete('debugPhase');
+                store.set('phase', '1.0.0');
+            },
+            '1.0.2': store => {
+                store.set('phase', '1.0.2');
+            },
+            '>=2.0.0': store => {
+                store.set('phase', '>=2.0.0');
+            }
+        }
+    });
+    ```
+    */
+    migrations?: Migrations<T>;
+    /**
+    __You most likely don't need this. Please don't use it unless you really have to.__
+
+    The only use-case I can think of is having the config located in the app directory or on some external storage. Default: System default user [config directory](https://github.com/sindresorhus/env-paths#pathsconfig).
+    */
+    cwd?: string;
+    /**
+    Note that this is __not intended for security purposes__, since the encryption key would be easily found inside a plain-text Node.js app.
+
+    Its main use is for obscurity. If a user looks through the config directory and finds the config file, since it's just a JSON file, they may be tempted to modify it. By providing an encryption key, the file will be obfuscated, which should hopefully deter any users from doing so.
+
+    It also has the added bonus of ensuring the config file's integrity. If the file is changed in any way, the decryption will not work, in which case the store will just reset back to its default state.
+
+    When specified, the store will be encrypted using the [`aes-256-cbc`](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation) encryption algorithm.
+    */
+    encryptionKey?: string | Buffer | NodeJS.TypedArray | DataView;
+    /**
+    Extension of the config file.
+
+    You would usually not need this, but could be useful if you want to interact with a file with a custom file extension that can be associated with your app. These might be simple save/export/preference files that are intended to be shareable or saved outside of the app.
+
+    @default 'json'
+    */
+    fileExtension?: string;
+    /**
+    The config is cleared if reading the config file causes a `SyntaxError`. This is a good behavior for unimportant data, as the config file is not intended to be hand-edited, so it usually means the config is corrupt and there's nothing the user can do about it anyway. However, if you let the user edit the config file directly, mistakes might happen and it could be more useful to throw an error when the config is invalid instead of clearing.
+
+    @default false
+    */
+    clearInvalidConfig?: boolean;
+    /**
+    Function to serialize the config object to a UTF-8 string when writing the config file.
+
+    You would usually not need this, but it could be useful if you want to use a format other than JSON.
+
+    @default value => JSON.stringify(value, null, '\t')
+    */
+    readonly serialize?: Serialize<T>;
+    /**
+    Function to deserialize the config object from a UTF-8 string when reading the config file.
+
+    You would usually not need this, but it could be useful if you want to use a format other than JSON.
+
+    @default JSON.parse
+    */
+    readonly deserialize?: Deserialize<T>;
+    /**
+    __You most likely don't need this. Please don't use it unless you really have to.__
+
+    Suffix appended to `projectName` during config file creation to avoid name conflicts with native apps.
+
+    You can pass an empty string to remove the suffix.
+
+    For example, on macOS, the config file will be stored in the `~/Library/Preferences/foo-nodejs` directory, where `foo` is the `projectName`.
+
+    @default 'nodejs'
+    */
+    readonly projectSuffix?: string;
+    /**
+    Access nested properties by dot notation.
+
+    @default true
+
+    @example
+    ```
+    const config = new Conf();
+
+    config.set({
+        foo: {
+            bar: {
+                foobar: '🦄'
+            }
+        }
+    });
+
+    console.log(config.get('foo.bar.foobar'));
+    //=> '🦄'
+    ```
+
+    Alternatively, you can set this option to `false` so the whole string would be treated as one key.
+
+    @example
+    ```
+    const config = new Conf({accessPropertiesByDotNotation: false});
+
+    config.set({
+        `foo.bar.foobar`: '🦄'
+    });
+
+    console.log(config.get('foo.bar.foobar'));
+    //=> '🦄'
+    ```
+
+    */
+    readonly accessPropertiesByDotNotation?: boolean;
+    /**
+    Watch for any changes in the config file and call the callback for `onDidChange` or `onDidAnyChange` if set. This is useful if there are multiple processes changing the same config file.
+
+    @default false
+    */
+    readonly watch?: boolean;
+    /**
+    The [mode](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation) that will be used for the config file.
+
+    You would usually not need this, but it could be useful if you want to restrict the permissions of the config file. Setting a permission such as `0o600` would result in a config file that can only be accessed by the user running the program.
+
+    Note that setting restrictive permissions can cause problems if different users need to read the file. A common problem is a user running your tool with and without `sudo` and then not being able to access the config the second time.
+
+    @default 0o666
+    */
+    readonly configFileMode?: number;
+}
+declare type Migrations<T> = Record<string, (store: Conf<T>) => void>;
+declare type Schema<T> = {
+    [Property in keyof T]: ValueSchema;
+};
+declare type ValueSchema = JSONSchema;
+declare type Serialize<T> = (value: T) => string;
+declare type Deserialize<T> = (text: string) => T;
+declare type OnDidChangeCallback<T> = (newValue?: T, oldValue?: T) => void;
+declare type OnDidAnyChangeCallback<T> = (newValue?: Readonly<T>, oldValue?: Readonly<T>) => void;
+declare type Unsubscribe = () => EventEmitter;
+
+declare class Conf<T extends Record<string, any> = Record<string, unknown>> implements Iterable<[keyof T, T[keyof T]]> {
+    #private;
+    readonly path: string;
+    readonly events: EventEmitter;
+    constructor(partialOptions?: Readonly<Partial<Options<T>>>);
+    /**
+    Get an item.
+
+    @param key - The key of the item to get.
+    @param defaultValue - The default value if the item does not exist.
+    */
+    get<Key extends keyof T>(key: Key): T[Key];
+    get<Key extends keyof T>(key: Key, defaultValue: Required<T>[Key]): Required<T>[Key];
+    get<Key extends string, Value = unknown>(key: Exclude<Key, keyof T>, defaultValue?: Value): Value;
+    /**
+    Set an item or multiple items at once.
+
+    @param {key|object} - You can use [dot-notation](https://github.com/sindresorhus/dot-prop) in a key to access nested properties. Or a hashmap of items to set at once.
+    @param value - Must be JSON serializable. Trying to set the type `undefined`, `function`, or `symbol` will result in a `TypeError`.
+    */
+    set<Key extends keyof T>(key: Key, value?: T[Key]): void;
+    set(key: string, value: unknown): void;
+    set(object: Partial<T>): void;
+    /**
+    Check if an item exists.
+
+    @param key - The key of the item to check.
+    */
+    has<Key extends keyof T>(key: Key | string): boolean;
+    /**
+    Reset items to their default values, as defined by the `defaults` or `schema` option.
+
+    @see `clear()` to reset all items.
+
+    @param keys - The keys of the items to reset.
+    */
+    reset<Key extends keyof T>(...keys: Key[]): void;
+    /**
+    Delete an item.
+
+    @param key - The key of the item to delete.
+    */
+    delete<Key extends keyof T>(key: Key): void;
+    /**
+    Delete all items.
+
+    This resets known items to their default values, if defined by the `defaults` or `schema` option.
+    */
+    clear(): void;
+    /**
+    Watches the given `key`, calling `callback` on any changes.
+
+    @param key - The key wo watch.
+    @param callback - A callback function that is called on any changes. When a `key` is first set `oldValue` will be `undefined`, and when a key is deleted `newValue` will be `undefined`.
+    @returns A function, that when called, will unsubscribe.
+    */
+    onDidChange<Key extends keyof T>(key: Key, callback: OnDidChangeCallback<T[Key]>): Unsubscribe;
+    /**
+    Watches the whole config object, calling `callback` on any changes.
+
+    @param callback - A callback function that is called on any changes. When a `key` is first set `oldValue` will be `undefined`, and when a key is deleted `newValue` will be `undefined`.
+    @returns A function, that when called, will unsubscribe.
+    */
+    onDidAnyChange(callback: OnDidAnyChangeCallback<T>): Unsubscribe;
+    get size(): number;
+    get store(): T;
+    set store(value: T);
+    [Symbol.iterator](): IterableIterator<[keyof T, T[keyof T]]>;
+    private _encryptData;
+    private _handleChange;
+    private readonly _deserialize;
+    private readonly _serialize;
+    private _validate;
+    private _ensureDirectory;
+    private _write;
+    private _watch;
+    private _migrate;
+    private _containsReservedKey;
+    private _isVersionInRangeFormat;
+    private _shouldPerformMigration;
+    private _get;
+    private _set;
+}
+
+declare const cliKit: Conf<any>;
+
+declare const store_cliKit: typeof cliKit;
+declare namespace store {
+  export {
+    store_cliKit as cliKit,
+  };
+}
+
+/** @type {typeof globalThis.Blob} */
+declare const Blob: typeof globalThis.Blob;
+
+/// <reference lib="dom" />
+
+
+type AbortSignal = {
+	readonly aborted: boolean;
+
+	addEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;
+	removeEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;
+};
+
+type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>;
+
+
+/**
+ * This Fetch API interface allows you to perform various actions on HTTP request and response headers.
+ * These actions include retrieving, setting, adding to, and removing.
+ * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
+ * You can add to this using methods like append() (see Examples.)
+ * In all methods of this interface, header names are matched by case-insensitive byte sequence.
+ * */
+declare class Headers {
+	constructor(init?: HeadersInit);
+
+	append(name: string, value: string): void;
+	delete(name: string): void;
+	get(name: string): string | null;
+	has(name: string): boolean;
+	set(name: string, value: string): void;
+	forEach(
+		callbackfn: (value: string, key: string, parent: Headers) => void,
+		thisArg?: any
+	): void;
+
+	[Symbol.iterator](): IterableIterator<[string, string]>;
+	/**
+	 * Returns an iterator allowing to go through all key/value pairs contained in this object.
+	 */
+	entries(): IterableIterator<[string, string]>;
+	/**
+	 * Returns an iterator allowing to go through all keys of the key/value pairs contained in this object.
+	 */
+	keys(): IterableIterator<string>;
+	/**
+	 * Returns an iterator allowing to go through all values of the key/value pairs contained in this object.
+	 */
+	values(): IterableIterator<string>;
+
+	/** Node-fetch extension */
+	raw(): Record<string, string[]>;
+}
+
+interface RequestInit {
+	/**
+	 * A BodyInit object or null to set request's body.
+	 */
+	body?: BodyInit | null;
+	/**
+	 * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
+	 */
+	headers?: HeadersInit;
+	/**
+	 * A string to set request's method.
+	 */
+	method?: string;
+	/**
+	 * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
+	 */
+	redirect?: RequestRedirect;
+	/**
+	 * An AbortSignal to set request's signal.
+	 */
+	signal?: AbortSignal | null;
+	/**
+	 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request’s referrer.
+	 */
+	referrer?: string;
+	/**
+	 * A referrer policy to set request’s referrerPolicy.
+	 */
+	referrerPolicy?: ReferrerPolicy;
+
+	// Node-fetch extensions to the whatwg/fetch spec
+	agent?: RequestOptions['agent'] | ((parsedUrl: URL) => RequestOptions['agent']);
+	compress?: boolean;
+	counter?: number;
+	follow?: number;
+	hostname?: string;
+	port?: number;
+	protocol?: string;
+	size?: number;
+	highWaterMark?: number;
+	insecureHTTPParser?: boolean;
+}
+
+interface ResponseInit {
+	headers?: HeadersInit;
+	status?: number;
+	statusText?: string;
+}
+
+type BodyInit =
+	| Blob
+	| Buffer
+	| URLSearchParams
+	| FormData
+	| NodeJS.ReadableStream
+	| string;
+declare class BodyMixin {
+	constructor(body?: BodyInit, options?: {size?: number});
+
+	readonly body: NodeJS.ReadableStream | null;
+	readonly bodyUsed: boolean;
+	readonly size: number;
+
+	/** @deprecated Use `body.arrayBuffer()` instead. */
+	buffer(): Promise<Buffer>;
+	arrayBuffer(): Promise<ArrayBuffer>;
+	formData(): Promise<FormData>;
+	blob(): Promise<Blob>;
+	json(): Promise<unknown>;
+	text(): Promise<string>;
+}
+
+type RequestRedirect = 'error' | 'follow' | 'manual';
+type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' | 'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+type RequestInfo = string | Request;
+declare class Request extends BodyMixin {
+	constructor(input: RequestInfo, init?: RequestInit);
+
+	/**
+	 * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
+	 */
+	readonly headers: Headers;
+	/**
+	 * Returns request's HTTP method, which is "GET" by default.
+	 */
+	readonly method: string;
+	/**
+	 * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
+	 */
+	readonly redirect: RequestRedirect;
+	/**
+	 * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
+	 */
+	readonly signal: AbortSignal;
+	/**
+	 * Returns the URL of request as a string.
+	 */
+	readonly url: string;
+	/**
+	 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request’s referrer.
+	 */
+	readonly referrer: string;
+	/**
+	 * A referrer policy to set request’s referrerPolicy.
+	 */
+	readonly referrerPolicy: ReferrerPolicy;
+	clone(): Request;
+}
+
+type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+
+declare class Response$1 extends BodyMixin {
+	constructor(body?: BodyInit | null, init?: ResponseInit);
+
+	readonly headers: Headers;
+	readonly ok: boolean;
+	readonly redirected: boolean;
+	readonly status: number;
+	readonly statusText: string;
+	readonly type: ResponseType;
+	readonly url: string;
+	clone(): Response$1;
+
+	static error(): Response$1;
+	static redirect(url: string, status?: number): Response$1;
+}
+declare function fetch$1(url: RequestInfo, init?: RequestInit): Promise<Response$1>;
+
+declare type Response = ReturnType<typeof fetch$1>;
+/**
+ * An interface that abstracts way node-fetch. When Node has built-in
+ * support for "fetch" in the standard library, we can drop the node-fetch
+ * dependency from here.
+ * Note that we are exposing types from "node-fetch". The reason being is that
+ * they are consistent with the Web API so if we drop node-fetch in the future
+ * it won't require changes from the callers.
+ * @param url {RequestInfo} This defines the resource that you wish to fetch.
+ * @param init {RequestInit} An object containing any custom settings that you want to apply to the request
+ * @returns A promise that resolves with the response.
+ */
+declare function fetch(url: RequestInfo, init?: RequestInit): Response;
+
+declare const http_fetch: typeof fetch;
+declare namespace http {
+  export {
+    http_fetch as fetch,
+  };
+}
+
+declare const constants: {
+    environmentVariables: {
+        debug: string;
+        runAsUser: string;
+        partnersEnv: string;
+        shopifyEnv: string;
+        identityEnv: string;
+        spin: string;
+        spinInstance: string;
+        spinWorkspace: string;
+        spinNamespace: string;
+        spinHost: string;
+    };
+    paths: {
+        executables: {
+            dev: string;
+        };
+    };
+    /**
+     * Versions are resolved at build time by Rollup's JSON plugin.
+     */
+    versions: {
+        cliKit: string;
+        /**
+         * cli-kit can resolve the version of cli at build time because
+         * the version of both packages is tied. If it wasn't, wen'd need
+         * to resolve the version at build time.
+         * Check out the linked configuration in .changeset/config.json
+         */
+        cli: string;
+    };
+    keychain: {
+        service: string;
+    };
+};
+
+export { constants, dependency, environment, error$1 as error, file, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
+//# sourceMappingURL=index.d.ts.map