Class TmuxParseError

A tmux output line did not match the expected schema. Two sub-cases under one tag (same caller recovery; differing fields are diagnostic only):

field-count mismatch: { line, message, expected, got }
schema decode failure: { line, message, cause }

Hierarchy

{
    _tag: "TmuxParseError";
    cause?: unknown;
    expected?: number;
    got?: number;
    line: string;
    message: string;
} & YieldableError<this>
- TmuxParseError

Constructors

constructor

new TmuxParseError(
    ...args: [
        props: {
            _tag?: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        options?: MakeOptions,
    ],
): TmuxParseError
Parameters
- ...args: [
      props: {
          _tag?: "TmuxParseError";
          cause?: unknown;
          expected?: number;
          got?: number;
          line: string;
          message: string;
      },
      options?: MakeOptions,
  ]
Returns TmuxParseError
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).constructor
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:9273

Properties

`Readonly`_tag

_tag: "TmuxParseError"

`Readonly`~effect/Effect

"~effect/Effect": Variance<never, TmuxParseError, never>

`Optional` `Readonly`~effect/ErrorReporter/attributes

"~effect/ErrorReporter/attributes"?: ReadonlyRecord<string, unknown>

`Optional` `Readonly`~effect/ErrorReporter/ignore

"~effect/ErrorReporter/ignore"?: boolean

`Optional` `Readonly`~effect/ErrorReporter/severity

"~effect/ErrorReporter/severity"?: Severity

`Optional` `Readonly`~effect/Runtime/errorExitCode

"~effect/Runtime/errorExitCode"?: number

`Optional` `Readonly`~effect/Runtime/errorReported

"~effect/Runtime/errorReported"?: boolean

`Optional`cause

cause?: unknown = ...

`Optional` `Readonly`expected

expected?: number = ...

`Optional` `Readonly`got

got?: number = ...

`Readonly`line

line: string = Schema.String

message

message: string = Schema.String

name

name: string

`Optional`stack

stack?: string

`Static` `Readonly`~effect/Schema/Schema

"~effect/Schema/Schema": "~effect/Schema/Schema"

`Static` `Readonly`~encoded.mutability

"~encoded.mutability": "readonly"

`Static` `Readonly`~encoded.optionality

"~encoded.optionality": "required"

`Static` `Readonly`~type.constructor.default

"~type.constructor.default": "no-default"

`Static` `Readonly`~type.make

"~type.make": TmuxParseError

`Static` `Readonly`~type.make.in

"~type.make.in": {
    _tag?: "TmuxParseError";
    cause?: unknown;
    expected?: number;
    got?: number;
    line: string;
    message: string;
}

`Static` `Readonly`~type.mutability

"~type.mutability": "readonly"

`Static` `Readonly`~type.optionality

"~type.optionality": "required"

`Static` `Readonly`~type.parameters

"~type.parameters": readonly [
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
]

`Static` `Readonly`ast

ast: Declaration

`Static` `Readonly`DecodingServices

DecodingServices: never

`Static` `Readonly`Encoded

Encoded: {
    _tag: "TmuxParseError";
    cause?: Json;
    expected?: number;
    got?: number;
    line: string;
    message: string;
}

`Static` `Readonly`EncodingServices

EncodingServices: never

`Static` `Readonly`fields

fields: {
    _tag: tag<"TmuxParseError">;
    cause: optional<Defect>;
    expected: optional<Number>;
    got: optional<Number>;
    line: String;
    message: String;
}

`Static` `Readonly`identifier

identifier: string

`Static` `Readonly`Iso

Iso: {
    _tag: "TmuxParseError";
    cause?: unknown;
    expected?: number;
    got?: number;
    line: string;
    message: string;
}

`Static`Rebuild

Rebuild: decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>

`Static` `Readonly`Type

Type: TmuxParseError

Methods

[iterator]

"[iterator]"(): EffectIterator<Effect<never, TmuxParseError, never>>
Returns EffectIterator<Effect<never, TmuxParseError, never>>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).[iterator]
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Cause.d.ts:1223

[NodeInspectSymbol]

"[NodeInspectSymbol]"(): unknown
Returns unknown
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).[NodeInspectSymbol]
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Inspectable.d.ts:112

pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:44
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:45
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:46
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:47
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:48
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:49
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:50
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:51
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:52
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:53
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:54
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:55
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:56
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:57
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:58
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:59
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:60
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:61
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:62
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:63
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:64
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:65

toJSON

toJSON(): unknown
Returns unknown
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).toJSON
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Inspectable.d.ts:111

toString

toString(): string
Returns string
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).toString
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Inspectable.d.ts:110

`Static`annotate

annotate(
    annotations: Bottom<
        TmuxParseError,
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
    >,
): decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Parameters
- annotations: Bottom<
      TmuxParseError,
      readonly [
          TaggedStruct<
              "TmuxParseError",
              {
                  cause: optional<Defect>;
                  expected: optional<Number>;
                  got: optional<Number>;
                  line: String;
                  message: String;
              },
          >,
      ],
  >
Returns decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).annotate
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:131

`Static`annotateKey

annotateKey(
    annotations: Key<TmuxParseError>,
): decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Parameters
- annotations: Key<TmuxParseError>
Returns decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).annotateKey
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:132

`Static`check

check(
    ...checks: readonly [Check<TmuxParseError>, Check<TmuxParseError>],
): decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Parameters
- ...checks: readonly [Check<TmuxParseError>, Check<TmuxParseError>]
Returns decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).check
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:133

`Static`extend

extend<Extended = never, Static = {}, Brand = {}>(
    identifier: string,
): {
    <NewFields extends Fields>(
        fields: NewFields,
        annotations?: Declaration<
            Extended,
            readonly [
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
            ],
        >,
    ): [Extended] extends [never]
        ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`"
        : InheritStaticMembers<
            Class<
                Extended,
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
                TmuxParseError & Brand,
            >,
            Static,
        >;
    <Extension extends Struct<Fields>>(
        schema: Extension,
        annotations?: Declaration<
            Extended,
            readonly [
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
            ],
        >,
    ): [Extended] extends [never]
        ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`"
        : InheritStaticMembers<
            Class<
                Extended,
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
                TmuxParseError & Brand,
            >,
            Static,
        >;
}
Returns a function that creates a schema-backed subclass with this class's fields plus additional fields.

When to use

Use when you need a subclass whose constructor validates both inherited fields and newly added fields.

Details

The returned function accepts either a field map or a Struct. When you pass a Struct, checks attached to that extension schema are preserved and combined with checks from the base class schema.

Gotchas

Checks from a Struct argument are evaluated against the full subclass value after inherited and extension fields are merged. Object-wide checks such as isMaxProperties count inherited fields too.
Type Parameters
- Extended = never
- Static = {}
- Brand = {}
Parameters
- identifier: string
Returns {
    <NewFields extends Fields>(
        fields: NewFields,
        annotations?: Declaration<
            Extended,
            readonly [
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
            ],
        >,
    ): [Extended] extends [never]
        ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`"
        : InheritStaticMembers<
            Class<
                Extended,
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
                TmuxParseError & Brand,
            >,
            Static,
        >;
    <Extension extends Struct<Fields>>(
        schema: Extension,
        annotations?: Declaration<
            Extended,
            readonly [
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
            ],
        >,
    ): [Extended] extends [never]
        ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`"
        : InheritStaticMembers<
            Class<
                Extended,
                Struct<
                    {
                        [K in string
                        | number
                        | symbol]: {
                            [K in string | number | symbol]: (
                                ((...) & (...)) extends never ? (...) & (...) : (...) & (...)
                            )[K]
                        }[K]
                    },
                >,
                TmuxParseError & Brand,
            >,
            Static,
        >;
}
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).extend
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:9316

`Static`make

make(
    input: {
        _tag?: "TmuxParseError";
        cause?: unknown;
        expected?: number;
        got?: number;
        line: string;
        message: string;
    },
    options?: MakeOptions,
): TmuxParseError
Constructs a value from the make input representation synchronously.

When to use

Use when constructor input is trusted or when validation failure should abort with a thrown Error.

Details

Applies constructor defaults and type-side validation according to MakeOptions.

Gotchas

Throws an Error with the schema issue in its cause when validation fails. Schema validation failures use the generic message "Schema validation failed"; format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed. Causes that contain defects, interruptions, or other non-schema reasons throw with the underlying Cause attached instead.
Parameters
- input: {
      _tag?: "TmuxParseError";
      cause?: unknown;
      expected?: number;
      got?: number;
      line: string;
      message: string;
  }
- Optionaloptions: MakeOptions
Returns TmuxParseError
See
- BottomWithoutNew.makeOption — construct synchronously and discard validation details
- BottomWithoutNew.makeEffect — construct through Effect when validation failure should stay in the error channel
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).make
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:160

`Static`makeEffect

makeEffect(
    input: {
        _tag?: "TmuxParseError";
        cause?: unknown;
        expected?: number;
        got?: number;
        line: string;
        message: string;
    },
    options?: MakeOptions,
): Effect<TmuxParseError, Issue>
Constructs a value from the make input representation, returning validation failures in the Effect error channel.

When to use

Use when constructor input may fail validation and you want to compose that failure with other Effect operations instead of throwing.

Details

Validation failures are returned directly as SchemaIssue.Issue values and are not wrapped in SchemaError.
Parameters
- input: {
      _tag?: "TmuxParseError";
      cause?: unknown;
      expected?: number;
      got?: number;
      line: string;
      message: string;
  }
- Optionaloptions: MakeOptions
Returns Effect<TmuxParseError, Issue>
See
- BottomWithoutNew.make — construct synchronously when validation failure should throw
- BottomWithoutNew.makeOption — construct synchronously and discard validation details
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).makeEffect
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:202

`Static`makeOption

makeOption(
    input: {
        _tag?: "TmuxParseError";
        cause?: unknown;
        expected?: number;
        got?: number;
        line: string;
        message: string;
    },
    options?: MakeOptions,
): Option<TmuxParseError>
Constructs a value from the make input representation, returning Option.none when validation fails.

When to use

Use when you only need to know whether construction succeeds and do not need validation details.

Details

Applies constructor defaults and type-side validation according to MakeOptions.

Gotchas

Only causes made entirely of schema issues are converted to None. Causes that contain defects, interruptions, or other non-schema reasons throw instead.
Parameters
- input: {
      _tag?: "TmuxParseError";
      cause?: unknown;
      expected?: number;
      got?: number;
      line: string;
      message: string;
  }
- Optionaloptions: MakeOptions
Returns Option<TmuxParseError>
See
- BottomWithoutNew.make — construct synchronously when validation failure should throw
- BottomWithoutNew.makeEffect — construct through Effect when validation details should stay in the error channel
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).makeOption
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:184

`Static`mapFields

mapFields<To extends Fields>(
    f: (
        fields: {
            _tag: tag<"TmuxParseError">;
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    ) => To,
    options?: { unsafePreserveChecks?: boolean },
): Struct<{ [K in string | number | symbol]: Readonly<To>[K] }>
Returns a new struct with the fields modified by the provided function.

Details

Options:
- unsafePreserveChecks - if true, keep any .check(...) constraints that were attached to the original struct. Defaults to false.
  
  Warning: This is an unsafe operation. Since mapFields transformations change the schema type, the original refinement functions may no longer be valid or safe to apply to the transformed schema. Only use this option if you have verified that your refinements remain correct after the transformation.
Type Parameters
- To extends Fields
Parameters
- f: (
      fields: {
          _tag: tag<"TmuxParseError">;
          cause: optional<Defect>;
          expected: optional<Number>;
          got: optional<Number>;
          line: String;
          message: String;
      },
  ) => To
- Optionaloptions: { unsafePreserveChecks?: boolean }
Returns Struct<{ [K in string | number | symbol]: Readonly<To>[K] }>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).mapFields
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:9292

`Static`pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:44
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:45
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:46
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:47
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:48
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:49
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:50
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:51
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:52
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:53
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:54
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:55
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:56
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:57
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:58
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:59
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:60
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:61
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:62
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:63
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:64
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).pipe
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Pipeable.d.ts:65

`Static`rebuild

rebuild(
    ast: Declaration,
): decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Parameters
- ast: Declaration
Returns decodeTo<
    declareConstructor<
        TmuxParseError,
        {
            _tag: "TmuxParseError";
            cause?: Json;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
        readonly [
            TaggedStruct<
                "TmuxParseError",
                {
                    cause: optional<Defect>;
                    expected: optional<Number>;
                    got: optional<Number>;
                    line: String;
                    message: String;
                },
            >,
        ],
        {
            _tag: "TmuxParseError";
            cause?: unknown;
            expected?: number;
            got?: number;
            line: string;
            message: string;
        },
    >,
    TaggedStruct<
        "TmuxParseError",
        {
            cause: optional<Defect>;
            expected: optional<Number>;
            got: optional<Number>;
            line: String;
            message: String;
        },
    >,
    never,
    never,
>
Inherited from Schema.TaggedError<TmuxParseError>()( "TmuxParseError", { line: Schema.String, message: Schema.String, expected: Schema.optional(Schema.Number), got: Schema.optional(Schema.Number), cause: Schema.optional(Schema.Defect()), }, ).rebuild
- Defined in node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.d.ts:134

Class TmuxParseError

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns TmuxParseError

Properties

Readonly_tag

Readonly~effect/Effect

Optional Readonly~effect/ErrorReporter/attributes

Optional Readonly~effect/ErrorReporter/ignore

Optional Readonly~effect/ErrorReporter/severity

Optional Readonly~effect/Runtime/errorExitCode

Optional Readonly~effect/Runtime/errorReported

Optionalcause

Optional Readonlyexpected

Optional Readonlygot

Readonlyline

message

name

Optionalstack

Static Readonly~effect/Schema/Schema

Static Readonly~encoded.mutability

Static Readonly~encoded.optionality

Static Readonly~type.constructor.default

Static Readonly~type.make

Static Readonly~type.make.in

Static Readonly~type.mutability

Static Readonly~type.optionality

Static Readonly~type.parameters

Static Readonlyast

Static ReadonlyDecodingServices

Static ReadonlyEncoded

Static ReadonlyEncodingServices

Static Readonlyfields

Static Readonlyidentifier

Static ReadonlyIso

StaticRebuild

Static ReadonlyType

Methods

[iterator]

Returns EffectIterator<Effect<never, TmuxParseError, never>>

[NodeInspectSymbol]

Returns unknown

pipe

Type Parameters

Parameters

Returns A

Type Parameters

Parameters

Returns B

Type Parameters

Parameters

Returns C

Type Parameters

Parameters

Returns D

Type Parameters

Parameters

Returns E

Type Parameters

Parameters

Returns F

Type Parameters

Parameters

Returns G

Type Parameters

Parameters

Returns H

Type Parameters

Parameters

Returns I

Type Parameters

Parameters

Returns J

Type Parameters

`Readonly`_tag

`Readonly`~effect/Effect

`Optional` `Readonly`~effect/ErrorReporter/attributes

`Optional` `Readonly`~effect/ErrorReporter/ignore

`Optional` `Readonly`~effect/ErrorReporter/severity

`Optional` `Readonly`~effect/Runtime/errorExitCode

`Optional` `Readonly`~effect/Runtime/errorReported

`Optional`cause

`Optional` `Readonly`expected

`Optional` `Readonly`got

`Readonly`line

`Optional`stack

`Static` `Readonly`~effect/Schema/Schema

`Static` `Readonly`~encoded.mutability

`Static` `Readonly`~encoded.optionality

`Static` `Readonly`~type.constructor.default

`Static` `Readonly`~type.make

`Static` `Readonly`~type.make.in

`Static` `Readonly`~type.mutability

`Static` `Readonly`~type.optionality

`Static` `Readonly`~type.parameters

`Static` `Readonly`ast

`Static` `Readonly`DecodingServices

`Static` `Readonly`Encoded

`Static` `Readonly`EncodingServices

`Static` `Readonly`fields

`Static` `Readonly`identifier

`Static` `Readonly`Iso

`Static`Rebuild

`Static` `Readonly`Type

`Static`annotate

`Static`annotateKey

`Static`check

`Static`extend

`Static`make

`Static`makeEffect

`Static`makeOption

`Static`mapFields

`Static`pipe