import type { Condition, Copy, Debug, Fn, NonEmptyArr, Option, State } from '../../../mod.js';
import type { CaseInfo } from './type.js';
export declare class Matcher<T, R = never> implements Copy, Debug {
    private cases;
    private match_value;
    private type_check;
    constructor(match_value: NonNullable<T>, cases?: Array<[Condition<T> | Array<Condition<T>>, R, CaseInfo]>, type_check?: Option<boolean>);
    /** ### `check` : 对匹配数据进行类型检查
    如果无法通过类型检查,则直接指执行`done`方法
    @param validate : 检查函数,返回boolean用于表示是否通过类型检查
    @example Usage
    ```ts
    const val: string | number = Date.now() % 2 === 0 ? 5 : 'jiojio'
  
    const res = match(val)
      .check(zod.validate(zod.number())) // val被缩紧为number类型;如果不是number类型,则直接执行done方法
      .case('jiojio' as any, 'no pass')
      .case(5, 'number')
      .done('string')
  
    assert(res == 'string' || res == 'number')
    ```
     */
    check<X = T>(validate: (val: X) => val is X): Matcher<X, R>;
    /** @matching */
    /** ### `is` : 类型条件匹配
    + 使用zod进行类型匹配,相当于`match.case(zod.validate(typer), value)
    @example Usage
    ```ts
    const match_value = 'AT1-X'
    const RET = match(match_value).is(zod.number(), 'number').is(zod.string(), 'string').done('none')
    assertEquals(RET, 'string')
    ```
    */
    is<V>(typer: Zod.Schema, value: NonNullable<V>): Matcher<T, V | R>;
    /** ### `case` : 条件匹配
    @param condition : 匹配条件
    能作为pattern的条件有四种:
    1. 全等 : 直接`===`比较
    2. 函数 : 函数返回值为`true`时匹配
    3. 实现了PartialEq的数据结构 : 调用`eq`方法进行比较
    4. 实现了Equal的数据结构 : 调用`equals`方法进行比较
    @param value : 匹配结果,直接返回
    @example Usage
    ```ts
    const res =
      match(match_value)
        .case(functor`${$0.name}==='jiojio'`, 'dio')
        .done()
        .unwrap_or('jiojio') === 'dio'
    assert(res)
    ```
     */
    case<V>(condition: Condition<T>, value: NonNullable<V>): Matcher<T, V | R>;
    /** ### `case_equal` : 深比较条件匹配
    调用{@link equal}函数进行深度比较,以此作为匹配条件
    @example 复杂类型的模式匹配
    ```ts
    match(info)
      .case(JSON.parse(JSON.stringify(info)), false) // 做 === 比较失败
      .case_equal(JSON.parse(JSON.stringify(info)), true) // 做深度比较成功
      .done()
      .match(assert, assert.unreachable)
    ```
    @example 可实现TypeClass类型的解构匹配
    ```ts
    match(Some(info))
      .case(Some(JSON.parse(JSON.stringify(info))), false)
      .case_equal(Some(JSON.parse(JSON.stringify(info))), true)
      .done()
      .match(assert, assert.unreachable)
    ```
     */
    case_equal<V = R>(condition: T, value: NonNullable<V>): Matcher<T, V | R>;
    /** ### `when` : 函数执行条件匹配
    + 用于解决返回值是函数的情况,能直接执行函数
    @param condition : 匹配条件
    @param call_back : 执行函数,函数返回值即为匹配结果值 - 为了匹配能正确获取结果,**函数必须返回一个值**;如果实在没有需要返回的值,使用{@link Default.default()}包装表示此匹配无返回值
    @throws 如果返回的类型不是函数,会抛出异常{@link TypeError}
    @example
    ```ts
    const result = match('JioJio')
      .case('dio', false)
      .when('diojio', functor<boolean>`false`)
      .when('JioJio', () => true)
      .done()
      .unwrap()
    assert(result)
    ```
     */
    when<U>(condition: Condition<T>, call_back: Fn<T, NonNullable<U>>): Matcher<T, U | R>;
    /** ### `when_state` : 解包条件匹配,当匹配类型是{@link State}类型的时候,会自动进行解包匹配
    @description 此方法主要用于解决when方法匹配函数分的入参通常不是匹配条件的情况
    @param condition : 匹配条件,使用`Main`端类型进行匹配
    @param call_back : 执行函数,使用`Effect`端类型作为函数的入参,函数返回值即为匹配结果值 - 为了匹配能正确获取结果,函数必须返回一个值;如果实在没有需要返回的值,使用{@link Default.default()}包装表示此匹配无返回值
    @throws 如果匹配的类型不是{@link State}类型,会抛出异常{@link TypeError}
    @throws 如果返回的类型不是函数,会抛出异常{@link TypeError}
    @example Usage
    ```ts
    const { name, row } = { name: '编辑', row: { name: 'jiojio', age: 18, address: '翻斗花园' } }
  
    const state = State(name, row)
  
    const { age } = match(state)
      .when_state('删除', delete_row)
      .when_state('编辑', functor<typeof row>`{...${$0},age:19}`)
      .done()
      .unwrap()
  
    assert(age === 19)
  
    function delete_row(_row: typeof row) {
      unreachable()
      return _row
    }
    ```
     */
    when_state<U>(condition: Condition<T extends State<infer M, unknown> ? M : never>, call_back: Fn<T extends State<unknown, infer S> ? S : never, NonNullable<U>>): Matcher<T, U | R>;
    /** ### `some` : 多个条件,只要满足一项即匹配结果
    @param conditions : 匹配条件
    @param value
    @example
    ```ts
    const pattern1 = zod.number().min(0).max(10)
    const pattern2 = zod.number().min(-10).max(-2)
  
    const res = match(10)
      .some([zod.validate(pattern1), zod.validate(pattern2)], true)
      .done(false)
  
    assert(res)
    ```
    */
    some<V>(conditions: [Condition<T>, ...Array<Condition<T>>], value: NonNullable<V>): Matcher<T, V | R>;
    /** ### `every` : 多个条件,需要同时具备才能匹配结果
    @example Usage
    ```ts
    assertThrows(() => {
      //@ts-ignore : every必须传入一个有内容的数组,否则会报错
      match('jiojio').every([], true)
    })
  
    const res = match('jiojio')
      .every(
        [
          reversal<String, 'startsWith'>('startsWith', 'jio'),
          reversal<String, 'endsWith'>('endsWith', 'dio'),
        ],
        'jiodio'
      )
      .every(
        [
          reversal<String, 'startsWith'>('startsWith', 'jio'),
          reversal<String, 'endsWith'>('endsWith', 'jio'),
        ],
        'jiojio'
      )
      .done()
      .unwrap()
    ```
    */
    every<V>(conditions: NonEmptyArr<Condition<T>>, value: NonNullable<V>): Matcher<T, V | R>;
    /** @result */
    /** ### `rematch` : 获取match的值,并使用获取的match值立刻进行匹配
    + 用于解决多分支匹配问题
    @example Usage
    ```ts
    const match_str = 'jiojio-dio-is-a-dog'
  
    //functional expression
    const resfp = match(match_str)
      .when(
        (v) => v.startsWith('jiojio'),
        (v) => v?.replace('jiojio', '')
      )
      .when(
        (v) => v.startsWith('dio'),
        (v) => v?.replace('dio', '')
      )
      .rematch() // 结果进行重新匹配
      .when(reversal('as', 'boolean'), (v) => v?.unwrap().replace('-dio-is-a-', ''))
      .done()
      .unwrap()
  
    // procedural
    let respd = ''
    if (match_str.startsWith('jiojio')) {
      respd = match_str.replace('jiojio', '')
    } else if (match_str.startsWith('dio')) {
      respd = match_str.replace('dio', '')
    }
    if (respd !== '') {
      respd = respd.replace('-dio-is-a-', '')
    }
  
    assertEquals(resfp, respd)
    ```
    */
    rematch<V = undefined>(def?: V): Matcher<V extends undefined | null ? Option<R> : R | V>;
    /** ### `done_else` : 获取结果,如果没有结果使用`fn(match_value)`替代
    @tips 如果进行匹配的结果是`underfind`或`null`,也会直接返回`fn(match_value)`的结果
    ```ts
    const name = 'jiojio'
    const v = match(name as string)
      .case('unkonw', false)
      .when('dio', () => false)
      .when('dijio', () => false)
      .done_else(() => true)
    assert(v)
    ```
    */
    done_else<RR>(fn: Fn<T, RR>): R | RR;
    /** ### `done` : 获取match结果
    @param def : 默认值,如果不传递默认值,则返回`Option<R>`,否则返回`R|V`
    @tips 如果进行匹配的值是`underfind`或`null`,会直接返回`None`/`def`
    @example Usage
    ```ts
    const A : Options<number> = match(1).case(2,2).done() //不传递默认值
    const B : number = match(1).case(2,2).done(3) // 传递默认值
    const C : None = match(underfind).done() // 返回None同时ts编译器报错
    const D : number = match(null).done(3) // 返回3同时ts编译器报错
    ```
    */
    done<V = undefined>(def?: V): V extends undefined | null ? Option<R> : R | V;
    /** @implacement */
    /** ### `clone` : 实现{@link Copy}接口,创建一个新的匹配模式
    ```ts
    const cola = match('jiojio').case('dio', 'isdio')
  
    // New Matcher
    const colb = cola.clone().case('jiojio', 'isjiojio').done().unwrap()
    assert(colb === 'isjiojio')
  
    // Original Matcher
    assert(cola.done().unwrap_or(true))
    ```
    */
    clone(): Matcher<T, R>;
    /** ### `debug` : 实现{@link Debug}接口,用于输出匹配信息 */
    log: () => void;
}
//# sourceMappingURL=class.d.ts.map