Deep Analysis and Solutions for 'Argument of type 'unknown' is not assignable to parameter of type '{}'' in TypeScript

Problem Background and Error Analysis

During TypeScript development, when using the fetch API to retrieve remote data, developers often encounter inaccurate type inference issues. Specifically, the Res.json() method returns a value of type any, and when Object.values() processes an input of type any, it returns an array of type unknown[]. With strictNullChecks enabled, the TypeScript compiler prevents assignment of unknown type values to parameters expecting type {}.

Core Solution: Type Definitions and Assertions

To resolve this issue, precise definition of API response data structure is essential. Creating accurate interfaces to describe data shapes significantly improves code type safety. Below is a complete data type definition example:

interface ResObj {
  Mens: {
    Hat: Clothing[];
    Jacket: Clothing[];
    Pants: Clothing[];
    Shoes: Clothing[];
    Suit: Clothing[];
  };
  New: Clothing[];
}

interface Clothing {
  agility: boolean[];
  alt: string;
  color: string[][];
  id: string;
  location?: string;
  Location?: string;
  material: string;
  price: string[][];
  prodState: string;
  saiz: string[][];
  shipping: string;
  sold: string;
  src: string[][];
  title: string;
  to: string;
}

After defining precise type interfaces, type assertions can be applied during data acquisition:

const Res = await fetch(`https://foo0022.firebaseio.com/.json`);
const ResObj: ResObj | undefined = await Res.json();
if (!Res.ok || !ResObj) {
  throw new Error("Page Not Found 404");
}

Advanced Type Utility Function Design

Since the standard library type definitions for Object.values() and Array.prototype.flat() methods cannot meet complex data processing requirements, we can create custom type-safe utility functions:

function vals<T extends object>(
  arr: T
): Array<T extends Array<infer U> ? U : T[keyof T]> {
  return Object.values(arr);
}

function flat<T>(
  arr: Array<T>
): Array<Extract<T, any[]>[number] | Exclude<T, any[]>> {
  return arr.flat();
}

These functions leverage TypeScript's advanced type features:

• The vals function uses conditional types to distinguish between array and non-array inputs
• The flat function employs Extract and Exclude utility types to handle nested arrays
• Generic parameters ensure type information is preserved throughout the processing chain

Complete Data Processing Workflow

Combining type definitions with utility functions, the original data processing code can be refactored:

const ResArr = flat(vals(ResObj).map(v => flat(vals(v)))).filter(
  ({ title }) => title.includes(Search)
);

This implementation offers several advantages:

• Complete type safety, with the compiler correctly inferring ResArr as type Clothing[]
• Clear type inference paths for easier debugging and maintenance
• Reusable utility functions applicable to similar scenarios

Related Technical Extensions

In the broader TypeScript ecosystem, similar type compatibility issues appear in other libraries. For example, when using Zod validation library's pipe method to combine different validators, input type mismatch problems also occur:

z.string().pipe(z.coerce.number())
// Error: Argument of type 'ZodCoercedNumber' is not assignable to parameter of type '$ZodType<any, string>'

The root cause of such problems lies in the type system's strict requirement for precise matching between input and output types. Solutions typically involve explicit type conversions or using intermediate transformation layers to unify type representations.

Best Practice Recommendations

Based on the above analysis, we summarize the following TypeScript development best practices:

• Always define precise type interfaces for remote API responses
• Avoid using any type, prefer more specific types or unknown
• Create type-safe utility functions for complex data processing operations
• Fully utilize TypeScript's conditional types and generic features
• Establish unified type definition standards in team development

By following these practices, developers can significantly improve TypeScript code quality, maintainability, and type safety while reducing the probability of runtime errors.