import type { Fn, Result } from '../../mod.js';
import * as z from 'zod';
import { CheckingError, UnexpectedError } from '../../mod.js';
type VisT<T extends {
    _type: unknown;
}> = (value: T['_type']) => value is T extends z.Schema<infer R> ? R : never;
/**
## `checking` : 以科里化的方式进行zod类型校验,返回结果是`Result<T,CheckingError>`
+ 用于检查`value`是否符合`pattern`的类型
  相当于`zod.parse(pattern)`的类型安全版本
@example Usage
```ts
  const max_ten_add_ten = flow(
    zod.checking(zod.number().max(10)) // use zod.checking to chcek  ,
    monad_shunt,
    add(10),
    monad_shunt,
  )

  const pass = Number(max_ten_add_ten(9))
  assert(pass === 19)

  const no_pass = Number(max_ten_add_ten(11))
  assert(isNaN(no_pass))
```
@category Ext - zod
 */
export declare const checking: <T extends z.Schema<unknown>>(pattern: T) => Fn<unknown, Result<z.infer<T>, CheckingError>>;
/**
### `validate` : 以科里化的方式进行zod的类型校验
用于验证`value`是否符合`pattern`的类型
`zod.validate(pattern)`  相当于  `pattern.safeParse().success`
@example
```ts
const pattern = z.string()
const res = zod.validate(pattern)('jiojio') // res is string
assert(res)
```
@category Ext - zod
 */
export declare const validate: <T extends z.Schema<unknown>>(pattern: T) => VisT<T>;
/**
### `morphs` : 自定义类型转换
提供类型安全的自定义类型转换规则,用于将`input`类型转换为`output`类型,在转换过程中会进行类型检查
@example Usage
```ts
  const input = zod.result(zod.number(), zod.instanceof(AnyError<'Debug'>))
  const output = zod.option(zod.number())

  const res_to_opt = zod.morphs(input, (inp) => inp.into('option'), output)
  assert(res_to_opt(Ok(1)).unwrap().unwrap() == 1)
  assert(res_to_opt(MockError.err()).unwrap().is_none)

  const opt_to_res = zod.morphs(output, (oup) => oup.into('result'), input)
  assert(opt_to_res(Some(1)).unwrap().unwrap() == 1)
  assert(opt_to_res(None).unwrap().unwrap_err().instance_of(NoneError))

  const str_to_obj = zod.morphs(
    zod.string(),
    JSON.parse,
    zod.object({ name: zod.string() }),
  )
  //Mock Normal Exchange
  assert(str_to_obj(`{"name":"jiojio"}`).unwrap().name == 'jiojio')
  //Mock Checking Error
  assert(str_to_obj(`{"age":19}`).unwrap_err().instance_of(CheckingError))
  //Mock Exchange Error
  assert(str_to_obj(`{"age"`).unwrap_err().instance_of(UnexpectedError))
```
@error `CheckingError` - 当输入/出类型检查错误时
@error `UnexpectedError` - 当转换过程中抛出异常时
@category Ext - zod
*/
export declare const morphs: <I extends z.Schema<unknown>, O extends z.Schema<unknown>>(input: I, conver: Fn<z.infer<I>, z.infer<O>>, output: O) => Fn<z.infer<I>, Result<z.infer<O>, CheckingError | UnexpectedError>>;
export {};
//# sourceMappingURL=helper.d.ts.map