c177363a19
🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
86 lines
3.3 KiB
TypeScript
86 lines
3.3 KiB
TypeScript
export declare namespace util {
|
|
type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
|
|
export type isAny<T> = 0 extends 1 & T ? true : false;
|
|
export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
|
|
export function assertIs<T>(_arg: T): void;
|
|
export function assertNever(_x: never): never;
|
|
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
|
export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
|
|
export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
|
|
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
|
|
export type InexactPartial<T> = {
|
|
[k in keyof T]?: T[k] | undefined;
|
|
};
|
|
export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
|
|
export const getValidEnumValues: (obj: any) => any[];
|
|
export const objectValues: (obj: any) => any[];
|
|
export const objectKeys: ObjectConstructor["keys"];
|
|
export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
|
|
export type identity<T> = objectUtil.identity<T>;
|
|
export type flatten<T> = objectUtil.flatten<T>;
|
|
export type noUndefined<T> = T extends undefined ? never : T;
|
|
export const isInteger: NumberConstructor["isInteger"];
|
|
export function joinValues<T extends any[]>(array: T, separator?: string): string;
|
|
export const jsonStringifyReplacer: (_: string, value: any) => any;
|
|
export {};
|
|
}
|
|
export declare namespace objectUtil {
|
|
export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
|
|
[k in Exclude<keyof U, keyof V>]: U[k];
|
|
} & V;
|
|
type optionalKeys<T extends object> = {
|
|
[k in keyof T]: undefined extends T[k] ? k : never;
|
|
}[keyof T];
|
|
type requiredKeys<T extends object> = {
|
|
[k in keyof T]: undefined extends T[k] ? never : k;
|
|
}[keyof T];
|
|
export type addQuestionMarks<T extends object, _O = any> = {
|
|
[K in requiredKeys<T>]: T[K];
|
|
} & {
|
|
[K in optionalKeys<T>]?: T[K];
|
|
} & {
|
|
[k in keyof T]?: unknown;
|
|
};
|
|
export type identity<T> = T;
|
|
export type flatten<T> = identity<{
|
|
[k in keyof T]: T[k];
|
|
}>;
|
|
export type noNeverKeys<T> = {
|
|
[k in keyof T]: [T[k]] extends [never] ? never : k;
|
|
}[keyof T];
|
|
export type noNever<T> = identity<{
|
|
[k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
|
|
}>;
|
|
export const mergeShapes: <U, T>(first: U, second: T) => T & U;
|
|
export type extendShape<A 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];
|
|
};
|
|
export {};
|
|
}
|
|
export declare const ZodParsedType: {
|
|
string: "string";
|
|
nan: "nan";
|
|
number: "number";
|
|
integer: "integer";
|
|
float: "float";
|
|
boolean: "boolean";
|
|
date: "date";
|
|
bigint: "bigint";
|
|
symbol: "symbol";
|
|
function: "function";
|
|
undefined: "undefined";
|
|
null: "null";
|
|
array: "array";
|
|
object: "object";
|
|
unknown: "unknown";
|
|
promise: "promise";
|
|
void: "void";
|
|
never: "never";
|
|
map: "map";
|
|
set: "set";
|
|
};
|
|
export type ZodParsedType = keyof typeof ZodParsedType;
|
|
export declare const getParsedType: (data: any) => ZodParsedType;
|