Brunobkr/llama.cpp_AlgMor24_github

1/// <reference types="node" />2import * as net from "net";3import * as tls from "tls";4import * as http from "http";5import { OutgoingHttpHeaders, RequestOptions } from "http";6 7//#region node_modules/https-proxy-agent/dist/index.d.ts8type Protocol<T> = T extends `${infer Protocol}:${infer _}` ? Protocol : never;9type ConnectOptsMap = {10  http: Omit<net.TcpNetConnectOpts, 'host' | 'port'>;11  https: Omit<tls.ConnectionOptions, 'host' | 'port'>;12};13type ConnectOpts<T> = { [P in keyof ConnectOptsMap]: Protocol<T> extends P ? ConnectOptsMap[P] : never }[keyof ConnectOptsMap];14type HttpsProxyAgentOptions<T> = ConnectOpts<T> & http.AgentOptions & {15  headers?: OutgoingHttpHeaders | (() => OutgoingHttpHeaders);16};17//#endregion18//#region node_modules/formdata-polyfill/esm.min.d.ts19declare const FormData: {20  new (): FormData;21  prototype: FormData;22};23//#endregion24//#region node_modules/fetch-blob/index.d.ts25/** @type {typeof globalThis.Blob} */26declare const Blob$1: typeof globalThis.Blob;27//#endregion28//#region node_modules/node-fetch/@types/index.d.ts29type AbortSignal$1 = {30  readonly aborted: boolean;31  addEventListener: (type: 'abort', listener: (this: AbortSignal$1) => void) => void;32  removeEventListener: (type: 'abort', listener: (this: AbortSignal$1) => void) => void;33};34type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>;35/**36 * This Fetch API interface allows you to perform various actions on HTTP request and response headers.37 * These actions include retrieving, setting, adding to, and removing.38 * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.39 * You can add to this using methods like append() (see Examples.)40 * In all methods of this interface, header names are matched by case-insensitive byte sequence.41 * */42declare class Headers {43  constructor(init?: HeadersInit);44  append(name: string, value: string): void;45  delete(name: string): void;46  get(name: string): string | null;47  has(name: string): boolean;48  set(name: string, value: string): void;49  forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;50  [Symbol.iterator](): IterableIterator<[string, string]>;51  /**52   * Returns an iterator allowing to go through all key/value pairs contained in this object.53   */54  entries(): IterableIterator<[string, string]>;55  /**56   * Returns an iterator allowing to go through all keys of the key/value pairs contained in this object.57   */58  keys(): IterableIterator<string>;59  /**60   * Returns an iterator allowing to go through all values of the key/value pairs contained in this object.61   */62  values(): IterableIterator<string>;63  /** Node-fetch extension */64  raw(): Record<string, string[]>;65}66interface RequestInit {67  /**68   * A BodyInit object or null to set request's body.69   */70  body?: BodyInit | null;71  /**72   * A Headers object, an object literal, or an array of two-item arrays to set request's headers.73   */74  headers?: HeadersInit;75  /**76   * A string to set request's method.77   */78  method?: string;79  /**80   * 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.81   */82  redirect?: RequestRedirect;83  /**84   * An AbortSignal to set request's signal.85   */86  signal?: AbortSignal$1 | null;87  /**88   * A string whose value is a same-origin URL, "about:client", or the empty string, to set request’s referrer.89   */90  referrer?: string;91  /**92   * A referrer policy to set request’s referrerPolicy.93   */94  referrerPolicy?: ReferrerPolicy; // Node-fetch extensions to the whatwg/fetch spec95  agent?: RequestOptions['agent'] | ((parsedUrl: URL) => RequestOptions['agent']);96  compress?: boolean;97  counter?: number;98  follow?: number;99  hostname?: string;100  port?: number;101  protocol?: string;102  size?: number;103  highWaterMark?: number;104  insecureHTTPParser?: boolean;105}106interface ResponseInit {107  headers?: HeadersInit;108  status?: number;109  statusText?: string;110}111type BodyInit = Blob$1 | Buffer | URLSearchParams | FormData | NodeJS.ReadableStream | string;112declare class BodyMixin {113  constructor(body?: BodyInit, options?: {114    size?: number;115  });116  readonly body: NodeJS.ReadableStream | null;117  readonly bodyUsed: boolean;118  readonly size: number;119  /** @deprecated Use `body.arrayBuffer()` instead. */120  buffer(): Promise<Buffer>;121  arrayBuffer(): Promise<ArrayBuffer>;122  formData(): Promise<FormData>;123  blob(): Promise<Blob$1>;124  json(): Promise<unknown>;125  text(): Promise<string>;126} // `Body` must not be exported as a class since it's not exported from the JavaScript code.127type RequestRedirect = 'error' | 'follow' | 'manual';128type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' | 'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';129type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';130declare class Response extends BodyMixin {131  constructor(body?: BodyInit | null, init?: ResponseInit);132  readonly headers: Headers;133  readonly ok: boolean;134  readonly redirected: boolean;135  readonly status: number;136  readonly statusText: string;137  readonly type: ResponseType;138  readonly url: string;139  clone(): Response;140  static error(): Response;141  static redirect(url: string, status?: number): Response;142}143//#endregion144//#region node-src/io/httpClient.d.ts145interface HTTPClientOptions {146  headers?: Record<string, string>;147  retries?: number;148}149interface HTTPClientFetchOptions {150  noLogErrorBody?: boolean;151  proxy?: HttpsProxyAgentOptions<any>;152  retries?: number;153}154/**155 * A basic wrapper class for fetch with the ability to retry fetches156 */157declare class HTTPClient {158  env: Context['env'];159  log: Context['log'];160  headers: Record<string, string>;161  retries: number;162  constructor({163    env,164    log165  }: Pick<Context, 'env' | 'log'>, {166    headers,167    retries168  }?: HTTPClientOptions);169  fetch(url: string, options?: RequestInit, options_?: HTTPClientFetchOptions): Promise<Response>;170  fetchBuffer(url: any, options: any): Promise<Buffer<ArrayBufferLike>>;171}172//#endregion173//#region node-src/io/graphqlClient.d.ts174/**175 * Interact with a GraphQL server using fetch and retries.176 */177declare class GraphQLClient {178  endpoint: string;179  headers: Record<string, string>;180  client: HTTPClient;181  constructor(ctx: InitialContext, endpoint: string, httpClientOptions: HTTPClientOptions);182  setAuthorization(token: string): void;183  runQuery<T>(query: string, variables: Record<string, any>, {184    endpoint,185    headers,186    retries187  }?: {188    endpoint?: string | undefined;189    headers?: {} | undefined;190    retries?: number | undefined;191  }): Promise<T>;192}193//#endregion194//#region node-src/lib/analytics/events.d.ts195declare const AnalyticsEvent: {196  readonly CLI_STORYBOOK_BUILD_FAILED: "CLI_STORYBOOK_BUILD_FAILED";197};198type AnalyticsEvent = (typeof AnalyticsEvent)[keyof typeof AnalyticsEvent];199//#endregion200//#region node-src/lib/analytics/types.d.ts201interface AnalyticsClient {202  trackEvent(eventName: AnalyticsEvent, properties?: Record<string, unknown>): void;203  shutdown(): Promise<void>;204}205//#endregion206//#region node_modules/zod/v3/helpers/typeAliases.d.cts207type Primitive = string | number | symbol | bigint | boolean | null | undefined;208//#endregion209//#region node_modules/zod/v3/helpers/util.d.cts210declare namespace util {211  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;212  export type isAny<T> = 0 extends 1 & T ? true : false;213  export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;214  export function assertIs<T>(_arg: T): void;215  export function assertNever(_x: never): never;216  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;217  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;218  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;219  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;220  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };221  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };222  export const getValidEnumValues: (obj: any) => any[];223  export const objectValues: (obj: any) => any[];224  export const objectKeys: ObjectConstructor["keys"];225  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;226  export type identity<T> = objectUtil.identity<T>;227  export type flatten<T> = objectUtil.flatten<T>;228  export type noUndefined<T> = T extends undefined ? never : T;229  export const isInteger: NumberConstructor["isInteger"];230  export function joinValues<T extends any[]>(array: T, separator?: string): string;231  export const jsonStringifyReplacer: (_: string, value: any) => any;232  export {};233}234declare namespace objectUtil {235  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k] } & V;236  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never }[keyof T];237  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];238  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K] } & { [K in optionalKeys<T>]?: T[K] } & { [k in keyof T]?: unknown };239  export type identity<T> = T;240  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;241  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];242  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;243  export const mergeShapes: <U, T>(first: U, second: T) => T & U;244  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] };245  export {};246}247declare const ZodParsedType: {248  string: "string";249  nan: "nan";250  number: "number";251  integer: "integer";252  float: "float";253  boolean: "boolean";254  date: "date";255  bigint: "bigint";256  symbol: "symbol";257  function: "function";258  undefined: "undefined";259  null: "null";260  array: "array";261  object: "object";262  unknown: "unknown";263  promise: "promise";264  void: "void";265  never: "never";266  map: "map";267  set: "set";268};269type ZodParsedType = keyof typeof ZodParsedType;270//#endregion271//#region node_modules/zod/v3/ZodError.d.cts272type allKeys<T> = T extends any ? keyof T : never;273type typeToFlattenedError<T, U = string> = {274  formErrors: U[];275  fieldErrors: { [P in allKeys<T>]?: U[] };276};277declare const ZodIssueCode: {278  invalid_type: "invalid_type";279  invalid_literal: "invalid_literal";280  custom: "custom";281  invalid_union: "invalid_union";282  invalid_union_discriminator: "invalid_union_discriminator";283  invalid_enum_value: "invalid_enum_value";284  unrecognized_keys: "unrecognized_keys";285  invalid_arguments: "invalid_arguments";286  invalid_return_type: "invalid_return_type";287  invalid_date: "invalid_date";288  invalid_string: "invalid_string";289  too_small: "too_small";290  too_big: "too_big";291  invalid_intersection_types: "invalid_intersection_types";292  not_multiple_of: "not_multiple_of";293  not_finite: "not_finite";294};295type ZodIssueCode = keyof typeof ZodIssueCode;296type ZodIssueBase = {297  path: (string | number)[];298  message?: string | undefined;299};300interface ZodInvalidTypeIssue extends ZodIssueBase {301  code: typeof ZodIssueCode.invalid_type;302  expected: ZodParsedType;303  received: ZodParsedType;304}305interface ZodInvalidLiteralIssue extends ZodIssueBase {306  code: typeof ZodIssueCode.invalid_literal;307  expected: unknown;308  received: unknown;309}310interface ZodUnrecognizedKeysIssue extends ZodIssueBase {311  code: typeof ZodIssueCode.unrecognized_keys;312  keys: string[];313}314interface ZodInvalidUnionIssue extends ZodIssueBase {315  code: typeof ZodIssueCode.invalid_union;316  unionErrors: ZodError[];317}318interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {319  code: typeof ZodIssueCode.invalid_union_discriminator;320  options: Primitive[];321}322interface ZodInvalidEnumValueIssue extends ZodIssueBase {323  received: string | number;324  code: typeof ZodIssueCode.invalid_enum_value;325  options: (string | number)[];326}327interface ZodInvalidArgumentsIssue extends ZodIssueBase {328  code: typeof ZodIssueCode.invalid_arguments;329  argumentsError: ZodError;330}331interface ZodInvalidReturnTypeIssue extends ZodIssueBase {332  code: typeof ZodIssueCode.invalid_return_type;333  returnTypeError: ZodError;334}335interface ZodInvalidDateIssue extends ZodIssueBase {336  code: typeof ZodIssueCode.invalid_date;337}338type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {339  includes: string;340  position?: number | undefined;341} | {342  startsWith: string;343} | {344  endsWith: string;345};346interface ZodInvalidStringIssue extends ZodIssueBase {347  code: typeof ZodIssueCode.invalid_string;348  validation: StringValidation;349}350interface ZodTooSmallIssue extends ZodIssueBase {351  code: typeof ZodIssueCode.too_small;352  minimum: number | bigint;353  inclusive: boolean;354  exact?: boolean;355  type: "array" | "string" | "number" | "set" | "date" | "bigint";356}357interface ZodTooBigIssue extends ZodIssueBase {358  code: typeof ZodIssueCode.too_big;359  maximum: number | bigint;360  inclusive: boolean;361  exact?: boolean;362  type: "array" | "string" | "number" | "set" | "date" | "bigint";363}364interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {365  code: typeof ZodIssueCode.invalid_intersection_types;366}367interface ZodNotMultipleOfIssue extends ZodIssueBase {368  code: typeof ZodIssueCode.not_multiple_of;369  multipleOf: number | bigint;370}371interface ZodNotFiniteIssue extends ZodIssueBase {372  code: typeof ZodIssueCode.not_finite;373}374interface ZodCustomIssue extends ZodIssueBase {375  code: typeof ZodIssueCode.custom;376  params?: {377    [k: string]: any;378  };379}380type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;381type ZodIssue = ZodIssueOptionalMessage & {382  fatal?: boolean | undefined;383  message: string;384};385type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {386  [k: number]: ZodFormattedError<T[number]>;387} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;388type ZodFormattedError<T, U = string> = {389  _errors: U[];390} & recursiveZodFormattedError<NonNullable<T>>;391declare class ZodError<T = any> extends Error {392  issues: ZodIssue[];393  get errors(): ZodIssue[];394  constructor(issues: ZodIssue[]);395  format(): ZodFormattedError<T>;396  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;397  static create: (issues: ZodIssue[]) => ZodError<any>;398  static assert(value: unknown): asserts value is ZodError;399  toString(): string;400  get message(): string;401  get isEmpty(): boolean;402  addIssue: (sub: ZodIssue) => void;403  addIssues: (subs?: ZodIssue[]) => void;404  flatten(): typeToFlattenedError<T>;405  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;406  get formErrors(): typeToFlattenedError<T, string>;407}408type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;409type IssueData = stripPath<ZodIssueOptionalMessage> & {410  path?: (string | number)[];411  fatal?: boolean | undefined;412};413type ErrorMapCtx = {414  defaultError: string;415  data: any;416};417type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {418  message: string;419};420//#endregion421//#region node_modules/zod/v3/helpers/parseUtil.d.cts422type ParseParams = {423  path: (string | number)[];424  errorMap: ZodErrorMap;425  async: boolean;426};427type ParsePathComponent = string | number;428type ParsePath = ParsePathComponent[];429interface ParseContext {430  readonly common: {431    readonly issues: ZodIssue[];432    readonly contextualErrorMap?: ZodErrorMap | undefined;433    readonly async: boolean;434  };435  readonly path: ParsePath;436  readonly schemaErrorMap?: ZodErrorMap | undefined;437  readonly parent: ParseContext | null;438  readonly data: any;439  readonly parsedType: ZodParsedType;440}441type ParseInput = {442  data: any;443  path: (string | number)[];444  parent: ParseContext;445};446declare class ParseStatus {447  value: "aborted" | "dirty" | "valid";448  dirty(): void;449  abort(): void;450  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;451  static mergeObjectAsync(status: ParseStatus, pairs: {452    key: ParseReturnType<any>;453    value: ParseReturnType<any>;454  }[]): Promise<SyncParseReturnType<any>>;455  static mergeObjectSync(status: ParseStatus, pairs: {456    key: SyncParseReturnType<any>;457    value: SyncParseReturnType<any>;458    alwaysSet?: boolean;459  }[]): SyncParseReturnType;460}461type INVALID = {462  status: "aborted";463};464declare const INVALID: INVALID;465type DIRTY<T> = {466  status: "dirty";467  value: T;468};469declare const DIRTY: <T>(value: T) => DIRTY<T>;470type OK<T> = {471  status: "valid";472  value: T;473};474declare const OK: <T>(value: T) => OK<T>;475type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;476type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;477type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;478//#endregion479//#region node_modules/zod/v3/helpers/enumUtil.d.cts480declare namespace enumUtil {481  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;482  type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;483  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;484  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;485  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;486  export {};487}488//#endregion489//#region node_modules/zod/v3/helpers/errorUtil.d.cts490declare namespace errorUtil {491  type ErrMessage = string | {492    message?: string | undefined;493  };494  const errToObj: (message?: ErrMessage) => {495    message?: string | undefined;496  };497  const toString: (message?: ErrMessage) => string | undefined;498}499//#endregion500//#region node_modules/zod/v3/helpers/partialUtil.d.cts501declare namespace partialUtil {502  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;503}504//#endregion505//#region node_modules/zod/v3/standard-schema.d.cts506/**507 * The Standard Schema interface.508 */509type StandardSchemaV1<Input = unknown, Output = Input> = {510  /**511   * The Standard Schema properties.512   */513  readonly "~standard": StandardSchemaV1.Props<Input, Output>;514};515declare namespace StandardSchemaV1 {516  /**517   * The Standard Schema properties interface.518   */519  export interface Props<Input = unknown, Output = Input> {520    /**521     * The version number of the standard.522     */523    readonly version: 1;524    /**525     * The vendor name of the schema library.526     */527    readonly vendor: string;528    /**529     * Validates unknown input values.530     */531    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;532    /**533     * Inferred types associated with the schema.534     */535    readonly types?: Types<Input, Output> | undefined;536  }537  /**538   * The result interface of the validate function.539   */540  export type Result<Output> = SuccessResult<Output> | FailureResult;541  /**542   * The result interface if validation succeeds.543   */544  export interface SuccessResult<Output> {545    /**546     * The typed output value.547     */548    readonly value: Output;549    /**550     * The non-existent issues.551     */552    readonly issues?: undefined;553  }554  /**555   * The result interface if validation fails.556   */557  export interface FailureResult {558    /**559     * The issues of failed validation.560     */561    readonly issues: ReadonlyArray<Issue>;562  }563  /**564   * The issue interface of the failure output.565   */566  export interface Issue {567    /**568     * The error message of the issue.569     */570    readonly message: string;571    /**572     * The path of the issue, if any.573     */574    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;575  }576  /**577   * The path segment interface of the issue.578   */579  export interface PathSegment {580    /**581     * The key representing a path segment.582     */583    readonly key: PropertyKey;584  }585  /**586   * The Standard Schema types interface.587   */588  export interface Types<Input = unknown, Output = Input> {589    /**590     * The input type of the schema.591     */592    readonly input: Input;593    /**594     * The output type of the schema.595     */596    readonly output: Output;597  }598  /**599   * Infers the input type of a Standard Schema.600   */601  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];602  /**603   * Infers the output type of a Standard Schema.604   */605  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];606  export {};607}608//#endregion609//#region node_modules/zod/v3/types.d.cts610interface RefinementCtx {611  addIssue: (arg: IssueData) => void;612  path: (string | number)[];613}614type ZodRawShape = {615  [k: string]: ZodTypeAny;616};617type ZodTypeAny = ZodType<any, any, any>;618type TypeOf<T extends ZodType<any, any, any>> = T["_output"];619type input<T extends ZodType<any, any, any>> = T["_input"];620type output<T extends ZodType<any, any, any>> = T["_output"];621type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;622interface ZodTypeDef {623  errorMap?: ZodErrorMap | undefined;624  description?: string | undefined;625}626type RawCreateParams = {627  errorMap?: ZodErrorMap | undefined;628  invalid_type_error?: string | undefined;629  required_error?: string | undefined;630  message?: string | undefined;631  description?: string | undefined;632} | undefined;633type SafeParseSuccess<Output> = {634  success: true;635  data: Output;636  error?: never;637};638type SafeParseError<Input> = {639  success: false;640  error: ZodError<Input>;641  data?: never;642};643type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;644declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {645  readonly _type: Output;646  readonly _output: Output;647  readonly _input: Input;648  readonly _def: Def;649  get description(): string | undefined;650  "~standard": StandardSchemaV1.Props<Input, Output>;651  abstract _parse(input: ParseInput): ParseReturnType<Output>;652  _getType(input: ParseInput): string;653  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;654  _processInputParams(input: ParseInput): {655    status: ParseStatus;656    ctx: ParseContext;657  };658  _parseSync(input: ParseInput): SyncParseReturnType<Output>;659  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;660  parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;661  safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;662  "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;663  parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;664  safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;665  /** Alias of safeParseAsync */666  spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;667  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;668  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;669  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;670  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;671  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;672  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;673  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;674  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;675  constructor(def: Def);676  optional(): ZodOptional<this>;677  nullable(): ZodNullable<this>;678  nullish(): ZodOptional<ZodNullable<this>>;679  array(): ZodArray<this>;680  promise(): ZodPromise<this>;681  or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;682  and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;683  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;684  default(def: util.noUndefined<Input>): ZodDefault<this>;685  default(def: () => util.noUndefined<Input>): ZodDefault<this>;686  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;687  catch(def: Output): ZodCatch<this>;688  catch(def: (ctx: {689    error: ZodError;690    input: Input;691  }) => Output): ZodCatch<this>;692  describe(description: string): this;693  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;694  readonly(): ZodReadonly<this>;695  isOptional(): boolean;696  isNullable(): boolean;697}698type IpVersion = "v4" | "v6";699type ZodStringCheck = {700  kind: "min";701  value: number;702  message?: string | undefined;703} | {704  kind: "max";705  value: number;706  message?: string | undefined;707} | {708  kind: "length";709  value: number;710  message?: string | undefined;711} | {712  kind: "email";713  message?: string | undefined;714} | {715  kind: "url";716  message?: string | undefined;717} | {718  kind: "emoji";719  message?: string | undefined;720} | {721  kind: "uuid";722  message?: string | undefined;723} | {724  kind: "nanoid";725  message?: string | undefined;726} | {727  kind: "cuid";728  message?: string | undefined;729} | {730  kind: "includes";731  value: string;732  position?: number | undefined;733  message?: string | undefined;734} | {735  kind: "cuid2";736  message?: string | undefined;737} | {738  kind: "ulid";739  message?: string | undefined;740} | {741  kind: "startsWith";742  value: string;743  message?: string | undefined;744} | {745  kind: "endsWith";746  value: string;747  message?: string | undefined;748} | {749  kind: "regex";750  regex: RegExp;751  message?: string | undefined;752} | {753  kind: "trim";754  message?: string | undefined;755} | {756  kind: "toLowerCase";757  message?: string | undefined;758} | {759  kind: "toUpperCase";760  message?: string | undefined;761} | {762  kind: "jwt";763  alg?: string;764  message?: string | undefined;765} | {766  kind: "datetime";767  offset: boolean;768  local: boolean;769  precision: number | null;770  message?: string | undefined;771} | {772  kind: "date";773  message?: string | undefined;774} | {775  kind: "time";776  precision: number | null;777  message?: string | undefined;778} | {779  kind: "duration";780  message?: string | undefined;781} | {782  kind: "ip";783  version?: IpVersion | undefined;784  message?: string | undefined;785} | {786  kind: "cidr";787  version?: IpVersion | undefined;788  message?: string | undefined;789} | {790  kind: "base64";791  message?: string | undefined;792} | {793  kind: "base64url";794  message?: string | undefined;795};796interface ZodStringDef extends ZodTypeDef {797  checks: ZodStringCheck[];798  typeName: ZodFirstPartyTypeKind.ZodString;799  coerce: boolean;800}801declare class ZodString extends ZodType<string, ZodStringDef, string> {802  _parse(input: ParseInput): ParseReturnType<string>;803  protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;804  _addCheck(check: ZodStringCheck): ZodString;805  email(message?: errorUtil.ErrMessage): ZodString;806  url(message?: errorUtil.ErrMessage): ZodString;807  emoji(message?: errorUtil.ErrMessage): ZodString;808  uuid(message?: errorUtil.ErrMessage): ZodString;809  nanoid(message?: errorUtil.ErrMessage): ZodString;810  cuid(message?: errorUtil.ErrMessage): ZodString;811  cuid2(message?: errorUtil.ErrMessage): ZodString;812  ulid(message?: errorUtil.ErrMessage): ZodString;813  base64(message?: errorUtil.ErrMessage): ZodString;814  base64url(message?: errorUtil.ErrMessage): ZodString;815  jwt(options?: {816    alg?: string;817    message?: string | undefined;818  }): ZodString;819  ip(options?: string | {820    version?: IpVersion;821    message?: string | undefined;822  }): ZodString;823  cidr(options?: string | {824    version?: IpVersion;825    message?: string | undefined;826  }): ZodString;827  datetime(options?: string | {828    message?: string | undefined;829    precision?: number | null;830    offset?: boolean;831    local?: boolean;832  }): ZodString;833  date(message?: string): ZodString;834  time(options?: string | {835    message?: string | undefined;836    precision?: number | null;837  }): ZodString;838  duration(message?: errorUtil.ErrMessage): ZodString;839  regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;840  includes(value: string, options?: {841    message?: string;842    position?: number;843  }): ZodString;844  startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;845  endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;846  min(minLength: number, message?: errorUtil.ErrMessage): ZodString;847  max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;848  length(len: number, message?: errorUtil.ErrMessage): ZodString;849  /**850   * Equivalent to `.min(1)`851   */852  nonempty(message?: errorUtil.ErrMessage): ZodString;853  trim(): ZodString;854  toLowerCase(): ZodString;855  toUpperCase(): ZodString;856  get isDatetime(): boolean;857  get isDate(): boolean;858  get isTime(): boolean;859  get isDuration(): boolean;860  get isEmail(): boolean;861  get isURL(): boolean;862  get isEmoji(): boolean;863  get isUUID(): boolean;864  get isNANOID(): boolean;865  get isCUID(): boolean;866  get isCUID2(): boolean;867  get isULID(): boolean;868  get isIP(): boolean;869  get isCIDR(): boolean;870  get isBase64(): boolean;871  get isBase64url(): boolean;872  get minLength(): number | null;873  get maxLength(): number | null;874  static create: (params?: RawCreateParams & {875    coerce?: true;876  }) => ZodString;877}878interface ZodBooleanDef extends ZodTypeDef {879  typeName: ZodFirstPartyTypeKind.ZodBoolean;880  coerce: boolean;881}882declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {883  _parse(input: ParseInput): ParseReturnType<boolean>;884  static create: (params?: RawCreateParams & {885    coerce?: boolean;886  }) => ZodBoolean;887}888interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {889  type: T;890  typeName: ZodFirstPartyTypeKind.ZodArray;891  exactLength: {892    value: number;893    message?: string | undefined;894  } | null;895  minLength: {896    value: number;897    message?: string | undefined;898  } | null;899  maxLength: {900    value: number;901    message?: string | undefined;902  } | null;903}904type ArrayCardinality = "many" | "atleastone";905type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];906declare 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"][]> {907  _parse(input: ParseInput): ParseReturnType<this["_output"]>;908  get element(): T;909  min(minLength: number, message?: errorUtil.ErrMessage): this;910  max(maxLength: number, message?: errorUtil.ErrMessage): this;911  length(len: number, message?: errorUtil.ErrMessage): this;912  nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;913  static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;914}915type UnknownKeysParam = "passthrough" | "strict" | "strip";916interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {917  typeName: ZodFirstPartyTypeKind.ZodObject;918  shape: () => T;919  catchall: Catchall;920  unknownKeys: UnknownKeys;921}922type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;923type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"] };924type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;925type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"] }>;926type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {927  [k: string]: T["_output"];928};929type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {930  [k: string]: T["_input"];931};932type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {933  [k: string]: unknown;934} : unknown;935type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;936declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {937  private _cached;938  _getCached(): {939    shape: T;940    keys: string[];941  };942  _parse(input: ParseInput): ParseReturnType<this["_output"]>;943  get shape(): T;944  strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;945  strip(): ZodObject<T, "strip", Catchall>;946  passthrough(): ZodObject<T, "passthrough", Catchall>;947  /**948   * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.949   * If you want to pass through unknown properties, use `.passthrough()` instead.950   */951  nonstrict: () => ZodObject<T, "passthrough", Catchall>;952  extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;953  /**954   * @deprecated Use `.extend` instead955   *  */956  augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;957  /**958   * Prior to zod@1.0.12 there was a bug in the959   * inferred type of merged objects. Please960   * upgrade if you are experiencing issues.961   */962  merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;963  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall>;964  catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;965  pick<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;966  omit<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;967  /**968   * @deprecated969   */970  deepPartial(): partialUtil.DeepPartial<this>;971  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]> }, UnknownKeys, Catchall>;972  partial<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;973  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]> }, UnknownKeys, Catchall>;974  required<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;975  keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;976  static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;977  static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;978  static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;979}980type AnyZodObject = ZodObject<any, any, any>;981type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;982interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {983  options: T;984  typeName: ZodFirstPartyTypeKind.ZodUnion;985}986declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {987  _parse(input: ParseInput): ParseReturnType<this["_output"]>;988  get options(): T;989  static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;990}991interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {992  left: T;993  right: U;994  typeName: ZodFirstPartyTypeKind.ZodIntersection;995}996declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {997  _parse(input: ParseInput): ParseReturnType<this["_output"]>;998  static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;999}1000type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];1001type AssertArray<T> = T extends any[] ? T : never;1002type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never }>;1003type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;1004type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never }>;1005type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;1006interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {1007  items: T;1008  rest: Rest;1009  typeName: ZodFirstPartyTypeKind.ZodTuple;1010}1011declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {1012  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1013  get items(): T;1014  rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;1015  static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;1016}1017type EnumValues<T extends string = string> = readonly [T, ...T[]];1018type Values<T extends EnumValues> = { [k in T[number]]: k };1019interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {1020  values: T;1021  typeName: ZodFirstPartyTypeKind.ZodEnum;1022}1023type Writeable<T> = { -readonly [P in keyof T]: T[P] };1024type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;1025type typecast<A, T> = A extends T ? A : never;1026declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;1027declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;1028declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {1029  _cache: Set<T[number]> | undefined;1030  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1031  get options(): T;1032  get enum(): Values<T>;1033  get Values(): Values<T>;1034  get Enum(): Values<T>;1035  extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;1036  exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;1037  static create: typeof createZodEnum;1038}1039interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1040  type: T;1041  typeName: ZodFirstPartyTypeKind.ZodPromise;1042}1043declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {1044  unwrap(): T;1045  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1046  static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;1047}1048type RefinementEffect<T> = {1049  type: "refinement";1050  refinement: (arg: T, ctx: RefinementCtx) => any;1051};1052type TransformEffect<T> = {1053  type: "transform";1054  transform: (arg: T, ctx: RefinementCtx) => any;1055};1056type PreprocessEffect<T> = {1057  type: "preprocess";1058  transform: (arg: T, ctx: RefinementCtx) => any;1059};1060type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;1061interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1062  schema: T;1063  typeName: ZodFirstPartyTypeKind.ZodEffects;1064  effect: Effect<any>;1065}1066declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {1067  innerType(): T;1068  sourceType(): T;1069  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1070  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;1071  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;1072}1073interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1074  innerType: T;1075  typeName: ZodFirstPartyTypeKind.ZodOptional;1076}1077declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {1078  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1079  unwrap(): T;1080  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;1081}1082interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1083  innerType: T;1084  typeName: ZodFirstPartyTypeKind.ZodNullable;1085}1086declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {1087  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1088  unwrap(): T;1089  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;1090}1091interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1092  innerType: T;1093  defaultValue: () => util.noUndefined<T["_input"]>;1094  typeName: ZodFirstPartyTypeKind.ZodDefault;1095}1096declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {1097  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1098  removeDefault(): T;1099  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {1100    default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);1101  }) => ZodDefault<Inner>;1102}1103interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1104  innerType: T;1105  catchValue: (ctx: {1106    error: ZodError;1107    input: unknown;1108  }) => T["_input"];1109  typeName: ZodFirstPartyTypeKind.ZodCatch;1110}1111declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {1112  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1113  removeCatch(): T;1114  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {1115    catch: Inner["_output"] | (() => Inner["_output"]);1116  }) => ZodCatch<Inner>;1117}1118interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {1119  type: T;1120  typeName: ZodFirstPartyTypeKind.ZodBranded;1121}1122declare const BRAND: unique symbol;1123type BRAND<T extends string | number | symbol> = {1124  [BRAND]: { [k in T]: true };1125};1126declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {1127  _parse(input: ParseInput): ParseReturnType<any>;1128  unwrap(): T;1129}1130interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {1131  in: A;1132  out: B;1133  typeName: ZodFirstPartyTypeKind.ZodPipeline;1134}1135declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {1136  _parse(input: ParseInput): ParseReturnType<any>;1137  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;1138}1139type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {1140  readonly [Symbol.toStringTag]: string;1141} | Date | Error | Generator | Promise<unknown> | RegExp;1142type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;1143interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {1144  innerType: T;1145  typeName: ZodFirstPartyTypeKind.ZodReadonly;1146}1147declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {1148  _parse(input: ParseInput): ParseReturnType<this["_output"]>;1149  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;1150  unwrap(): T;1151}1152declare enum ZodFirstPartyTypeKind {1153  ZodString = "ZodString",1154  ZodNumber = "ZodNumber",1155  ZodNaN = "ZodNaN",1156  ZodBigInt = "ZodBigInt",1157  ZodBoolean = "ZodBoolean",1158  ZodDate = "ZodDate",1159  ZodSymbol = "ZodSymbol",1160  ZodUndefined = "ZodUndefined",1161  ZodNull = "ZodNull",1162  ZodAny = "ZodAny",1163  ZodUnknown = "ZodUnknown",1164  ZodNever = "ZodNever",1165  ZodVoid = "ZodVoid",1166  ZodArray = "ZodArray",1167  ZodObject = "ZodObject",1168  ZodUnion = "ZodUnion",1169  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",1170  ZodIntersection = "ZodIntersection",1171  ZodTuple = "ZodTuple",1172  ZodRecord = "ZodRecord",1173  ZodMap = "ZodMap",1174  ZodSet = "ZodSet",1175  ZodFunction = "ZodFunction",1176  ZodLazy = "ZodLazy",1177  ZodLiteral = "ZodLiteral",1178  ZodEnum = "ZodEnum",1179  ZodEffects = "ZodEffects",1180  ZodNativeEnum = "ZodNativeEnum",1181  ZodOptional = "ZodOptional",1182  ZodNullable = "ZodNullable",1183  ZodDefault = "ZodDefault",1184  ZodCatch = "ZodCatch",1185  ZodPromise = "ZodPromise",1186  ZodBranded = "ZodBranded",1187  ZodPipeline = "ZodPipeline",1188  ZodReadonly = "ZodReadonly"1189}1190//#endregion1191//#region node-src/lib/getConfiguration.d.ts1192declare const configurationSchema: ZodObject<{1193  $schema: ZodOptional<ZodString>;1194  projectId: ZodOptional<ZodString>;1195  projectToken: ZodOptional<ZodString>;1196  onlyChanged: ZodOptional<ZodUnion<[ZodString, ZodBoolean]>>;1197  onlyStoryFiles: ZodOptional<ZodArray<ZodString, "many">>;1198  onlyStoryNames: ZodOptional<ZodArray<ZodString, "many">>;1199  traceChanged: ZodOptional<ZodUnion<[ZodString, ZodBoolean]>>;1200  untraced: ZodOptional<ZodArray<ZodString, "many">>;

Showing the first 1,200 of 1889 lines. Download the file for the rest.