@ucanto/core
Version:
146 lines • 6.46 kB
TypeScript
export * from "./type.js";
/**
* @abstract
* @template [T=unknown]
* @template [I=unknown]
* @template [Settings=void]
* @extends {Schema.Base<T, I, Settings>}
* @implements {Schema.Schema<T, I>}
*/
export class API<T = unknown, I = unknown, Settings = void> implements Schema.Schema<T, I> {
/**
* @param {Settings} settings
*/
constructor(settings: Settings);
settings: Settings;
toString(): string;
/**
* @abstract
* @param {I} input
* @param {Settings} settings
* @returns {Schema.ReadResult<T>}
*/
readWith(input: I, settings: Settings): Schema.ReadResult<T>;
/**
* @param {I} input
* @returns {Schema.ReadResult<T>}
*/
read(input: I): Schema.ReadResult<T>;
/**
* @param {unknown} value
* @returns {value is T}
*/
is(value: unknown): value is T;
/**
* @param {unknown} value
* @return {T}
*/
from(value: unknown): T;
/**
* @returns {Schema.Schema<T|undefined, I>}
*/
optional(): Schema.Schema<T | undefined, I>;
/**
* @returns {Schema.Schema<T|null, I>}
*/
nullable(): Schema.Schema<T | null, I>;
/**
* @returns {Schema.Schema<T[], I>}
*/
array(): Schema.Schema<T[], I>;
/**
* @template U
* @param {Schema.Reader<U, I>} schema
* @returns {Schema.Schema<T | U, I>}
*/
or<U>(schema: Schema.Reader<U, I, Schema.Error>): Schema.Schema<T | U, I>;
/**
* @template U
* @param {Schema.Reader<U, I>} schema
* @returns {Schema.Schema<T & U, I>}
*/
and<U_1>(schema: Schema.Reader<U_1, I, Schema.Error>): Schema.Schema<T & U_1, I>;
/**
* @template {T} U
* @param {Schema.Reader<U, T>} schema
* @returns {Schema.Schema<U, I>}
*/
refine<U_2 extends T>(schema: Schema.Reader<U_2, T, Schema.Error>): Schema.Schema<U_2, I>;
/**
* @template {string} Kind
* @param {Kind} [kind]
* @returns {Schema.Schema<Schema.Branded<T, Kind>, I>}
*/
brand<Kind extends string>(kind?: Kind | undefined): Schema.Schema<Schema.Branded<T, Kind>, I>;
/**
* @param {Schema.NotUndefined<T>} value
* @returns {Schema.DefaultSchema<Schema.NotUndefined<T>, I>}
*/
default(value: Schema.NotUndefined<T>): Schema.DefaultSchema<Schema.NotUndefined<T>, I>;
}
export function never<I = unknown>(): Schema.Schema<never, I>;
export function unknown<I = unknown>(): Schema.Schema<unknown, I>;
export function nullable<O, I = unknown>(schema: Schema.Reader<O, I, Schema.Error>): Schema.Schema<O | null, I>;
export function optional<O, I = unknown>(schema: Schema.Reader<O, I, Schema.Error>): Schema.Schema<O | undefined, I>;
export function array<O, I = unknown>(schema: Schema.Reader<O, I, Schema.Error>): Schema.ArraySchema<O, I>;
export function tuple<T extends Schema.Reader<unknown, I, Schema.Error>, U extends [T, ...T[]], I = unknown>(shape: U): Schema.Schema<Schema.InferTuple<U>, I>;
export function dictionary<K extends string, V extends unknown, I = unknown>({ value, key }: {
value: Schema.Reader<V, I, Schema.Error>;
key?: Schema.Reader<K, string, Schema.Error> | undefined;
}): Schema.DictionarySchema<V, K, I>;
export function union<T extends Schema.Reader<unknown, I, Schema.Error>, U extends [T, ...T[]], I = unknown>(variants: U): Schema.Schema<Schema.Infer<U[number]>, I>;
export function or<T, U, I = unknown>(left: Schema.Reader<T, I, Schema.Error>, right: Schema.Reader<U, I, Schema.Error>): Schema.Schema<T | U, I>;
export function intersection<T extends Schema.Reader<unknown, I, Schema.Error>, U extends [T, ...T[]], I = unknown>(variants: U): Schema.Schema<Schema.InferIntersection<U>, I>;
export function and<T, U, I = unknown>(left: Schema.Reader<T, I, Schema.Error>, right: Schema.Reader<U, I, Schema.Error>): Schema.Schema<T & U, I>;
export function boolean(): Schema.Schema<boolean, unknown>;
export function number(): Schema.NumberSchema<number, unknown>;
export function lessThan<T extends number>(n: number): Schema.Schema<T, T>;
export function greaterThan<T extends number>(n: number): Schema.Schema<T, T>;
export function integer(): Schema.NumberSchema<number & import("multiformats").Phantom<{
typeof: "integer";
}>, unknown>;
export function uint64(): Schema.Schema<Schema.Uint64, unknown>;
export function float(): Schema.NumberSchema<number & import("multiformats").Phantom<{
typeof: "float";
}>, unknown>;
export function string(): Schema.StringSchema<string, unknown>;
/** @type {Schema.Schema<Uint8Array, unknown>} */
export const Bytes: Schema.Schema<Uint8Array, unknown>;
export function bytes(): Schema.Schema<Uint8Array, unknown>;
export function startsWith<Prefix extends string, Body_1 extends string>(prefix: Prefix): Schema.Schema<`${Prefix}${string}`, string>;
export function endsWith<Suffix extends string>(suffix: Suffix): Schema.Schema<`${string}${Suffix}`, string>;
export function refine<T, U extends T, I = unknown>(base: Schema.Reader<T, I, Schema.Error>, schema: Schema.Reader<U, T, Schema.Error>): Schema.Schema<U, I>;
export function literal<T extends string | number | boolean | null, I = unknown>(value: T): Schema.LiteralSchema<T, I>;
export function struct<T extends string | number | boolean | null, U extends {
[key: string]: Schema.Reader<any, any, Schema.Error> | T;
}, V extends { [K in keyof U]: U[K] extends Schema.Reader<any, any, Schema.Error> ? U[K] : Schema.LiteralSchema<U[K] & T, any>; }, I = unknown>(fields: U): Schema.StructSchema<V, I>;
export function variant<Choices extends Schema.VariantChoices, In = unknown>(variants: Choices): Schema.VariantSchema<Choices, In>;
export function error(message: string): {
error: Schema.Error;
ok?: undefined;
};
export function typeError(data: {
expect: string;
actual: unknown;
}): {
error: Schema.Error;
};
export function toString(value: unknown): unknown;
export function memberError({ at, cause }: {
at: string | number;
cause: Schema.Error;
}): {
error: Schema.Error;
};
import { ok } from '../result.js';
import * as Schema from './type.js';
/**
* @template {string} T
* @template {[T, ...T[]]} U
* @template [I=unknown]
* @param {U} variants
* @returns {Schema.Schema<U[number], I>}
*/
declare function createEnum<T extends string, U extends [T, ...T[]], I = unknown>(variants: U): Schema.Schema<U[number], I>;
export { ok, createEnum as enum, _enum as enum };
//# sourceMappingURL=schema.d.ts.map