typescript/unknown-parameter

A parameter typed `unknown` (or a union containing it) on a function that is not the boundary parser or a type predicate's subject. Every caller already holds a typed value, and the function re-checks or asserts it — parse at the boundary and accept the domain type.

Read it in the terminal

The same facts, from the checkout you are already in — no browser, and no network.

$ npx redlinegate explain typescript/unknown-parameter

Where this came from

You are most likely here from a review comment. A finding names its rule and, when your repository has told Redline where the standard is published, its address:

Redline/HIGH [typescript/unknown-parameter]: …
  → …/r/typescript/unknown-parameter

That second line is written by redline init --docs-url and is empty until an organisation sets one — there is no default, because a link to somebody else's copy of the standard is worse than no link. See Onboard a repository.

In context

The TypeScript standard lists this rule with the rest of its stack, in the file a reviewer and an AI assistant both read.

Other HIGH rules in this stack

• typescript/unknown-returnAn explicit return type of `unknown`, `Promise<unknown>` or `PromiseLike<unknown>`. Every caller now has to parse or assert the result; parse it once inside the function and return the domain type.
• typescript/unknown-type-aliasA type alias that is `unknown` or a union containing it (`type Payload = unknown`). The name hides the top type, so readers and reviewers treat it as a contract it is not.
• typescript/open-dictionary-valueAn open dictionary whose value type is `unknown`, `any`, `object` or `{}` (`Record<string, unknown>`, `{ [key: string]: unknown }`). Every read needs an unchecked assertion. Not when it is a generic constraint (`T extends Record<string, unknown>`), a finite key set (`Record<Status, number>`), the subject of a type predicate or parser at the boundary (`value is Record<string, unknown>`), or a bag a specification defines as open (SARIF `properties`, GraphQL `variables`).
• typescript/object-parameterA parameter typed `object`. It accepts arrays, functions and class instances, and allows no property access without an assertion. Accept a named type, or a generic `<T extends object>`.
• typescript/known-value-wideningA literal or known-typed value assigned to an annotation that discards what is known: `const routes: Record<string, Handler> = { home, about }` makes `routes.contact` type-check as a `Handler` that is `undefined` at runtime. Drop the annotation, or use `satisfies`.
• typescript/reflect-dynamic-access`Reflect.apply` or `Reflect.get` in application code. Both take untyped arguments and return `any`, so the call and its result escape type checking. Use a typed call or property access; dynamic dispatch goes behind a named interface.