Ts.Assert.parameter3.not.exact

Import

NamespaceBarrel

typescript

import { Ts } from '@wollybeard/kit'

// Access via namespace
Ts.Assert.parameter3.not.exact

typescript

import { exact } from '@wollybeard/kit/ts'

Functions

`[F]` `ofAs`

typescript

<$Type>(): DispatchAfterInput<State.SetExpectedType<State.SetRelator<State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>, ExactKind>, $Type>>

Constants

`[C]` `any`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowAny<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
        ExactKind
      >
    >,
    any
  >
>

`[C]` `bigint`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    bigint
  >
>

`[C]` `boolean`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    boolean
  >
>

`[C]` `Date`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    Date
  >
>

`[C]` `Error`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    Error
  >
>

`[C]` `never`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowNever<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
        ExactKind
      >
    >,
    never
  >
>

`[C]` `noExcess`

typescript

never

`[C]` `null`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    null
  >
>

`[C]` `number`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    number
  >
>

`[C]` `of`

typescript

InputExpectedAsValueNarrow<
  State.SetRelator<
    State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
    ExactKind
  >
>

`[C]` `RegExp`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    RegExp
  >
>

`[C]` `string`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    string
  >
>

`[C]` `symbol`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    symbol
  >
>

`[C]` `undefined`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
      ExactKind
    >,
    undefined
  >
>

`[C]` `unknown`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowUnknown<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, Parameter3>>,
        ExactKind
      >
    >,
    unknown
  >
>

Types

`[T]` `any`

typescript

type any_<$Actual> = Kind.Apply<
  ExactKind,
  [any, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for any. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.any
<(arg
: any) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.any
<(arg
: string) => any>

`[T]` `bigint`

typescript

type bigint_<$Actual> = Kind.Apply<
  ExactKind,
  [bigint, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for bigint. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.bigint
<(arg
: bigint) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.bigint
<(arg
: string) => any>

`[T]` `boolean`

typescript

type boolean_<$Actual> = Kind.Apply<
  ExactKind,
  [boolean, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for boolean. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.boolean
<(arg
: boolean) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.boolean
<(arg
: string) => any>

`[T]` `Date`

typescript

type Date_<$Actual> = Kind.Apply<
  ExactKind,
  [Date, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for Date. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.Date
<(arg
: Date) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.Date
<(arg
: string) => any>

`[T]` `Error`

typescript

type Error_<$Actual> = Kind.Apply<
  ExactKind,
  [Error, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for Error. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.Error
<(arg
: Error) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.Error
<(arg
: string) => any>

`[T]` `never`

typescript

type never_<$Actual> = Kind.Apply<
  ExactKind,
  [never, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for never. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.never
<(arg
: never) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.never
<(arg
: string) => any>

`[T]` `noExcess`

typescript

type noExcess_ = never

`[T]` `null`

typescript

type null_<$Actual> = Kind.Apply<
  ExactKind,
  [null, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for null. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.null
<(arg
: null) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.null
<(arg
: string) => any>

`[T]` `number`

typescript

type number_<$Actual> = Kind.Apply<
  ExactKind,
  [number, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for number. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.number
<(arg
: number) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.number
<(arg
: string) => any>

`[T]` `of`

typescript

type of_<$Expected, $Actual> = Kind.Apply<
  ExactKind,
  [$Expected, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

parameter3 + exact relation matchers.

Extraction: extracts the third parameter type from a function Relation: exact structural equality

`[T]` `RegExp`

typescript

type RegExp_<$Actual> = Kind.Apply<
  ExactKind,
  [RegExp, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for RegExp. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.RegExp
<(arg
: RegExp) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.RegExp
<(arg
: string) => any>

`[T]` `string`

typescript

type string_<$Actual> = Kind.Apply<
  ExactKind,
  [string, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for string. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.string
<(arg
: string) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.string
<(arg
: number) => any>

`[T]` `symbol`

typescript

type symbol_<$Actual> = Kind.Apply<
  ExactKind,
  [symbol, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for symbol. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.symbol
<(arg
: symbol) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.symbol
<(arg
: string) => any>

`[T]` `undefined`

typescript

type undefined_<$Actual> = Kind.Apply<
  ExactKind,
  [undefined, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for undefined. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.undefined
<(arg
: undefined) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.undefined
<(arg
: string) => any>

`[T]` `unknown`

typescript

type unknown_<$Actual> = Kind.Apply<
  ExactKind,
  [unknown, Kind.Apply<Path.Parameter3, [$Actual]>, true]
>

Pre-curried matcher for unknown. Extraction chain: (p1: any, p2: any, p3: T, ...) = any → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.parameter3.exact.unknown
<(arg
: unknown) => any>

// ✗ Fail
type _
 = Assert.parameter3.exact.unknown
<(arg
: string) => any>

Obj

Str

Ts

Ts.Assert.parameter3.not.exact

Import

Functions

`[F]` `ofAs`

Constants

`[C]` `any`

`[C]` `bigint`

`[C]` `boolean`

`[C]` `Date`

`[C]` `Error`

`[C]` `never`

`[C]` `noExcess`

`[C]` `null`

`[C]` `number`

`[C]` `of`

`[C]` `RegExp`

`[C]` `string`

`[C]` `symbol`

`[C]` `undefined`

`[C]` `unknown`

Types

`[T]` `any`

`[T]` `bigint`

`[T]` `boolean`

`[T]` `Date`

`[T]` `Error`

`[T]` `never`

`[T]` `noExcess`

`[T]` `null`

`[T]` `number`

`[T]` `of`

`[T]` `RegExp`

`[T]` `string`

`[T]` `symbol`

`[T]` `undefined`

`[T]` `unknown`

Ts.Assert.parameter3.not.exact ​

Import ​

Functions ​

[F] ofAs ​

Constants ​

[C] any ​

[C] bigint ​

[C] boolean ​

[C] Date ​

[C] Error ​

[C] never ​

[C] noExcess ​

[C] null ​

[C] number ​

[C] of ​

[C] RegExp ​

[C] string ​

[C] symbol ​

[C] undefined ​

[C] unknown ​

Types ​

[T] any ​

[T] bigint ​

[T] boolean ​

[T] Date ​

[T] Error ​

[T] never ​

[T] noExcess ​

[T] null ​

[T] number ​

[T] of ​

[T] RegExp ​

[T] string ​

[T] symbol ​

[T] undefined ​

[T] unknown ​

Ts.Assert.parameter3.not.exact

Import

Functions

`[F]` `ofAs`

Constants

`[C]` `any`

`[C]` `bigint`

`[C]` `boolean`

`[C]` `Date`

`[C]` `Error`

`[C]` `never`

`[C]` `noExcess`

`[C]` `null`

`[C]` `number`

`[C]` `of`

`[C]` `RegExp`

`[C]` `string`

`[C]` `symbol`

`[C]` `undefined`

`[C]` `unknown`

Types

`[T]` `any`

`[T]` `bigint`

`[T]` `boolean`

`[T]` `Date`

`[T]` `Error`

`[T]` `never`

`[T]` `noExcess`

`[T]` `null`

`[T]` `number`

`[T]` `of`

`[T]` `RegExp`

`[T]` `string`

`[T]` `symbol`

`[T]` `undefined`

`[T]` `unknown`