如何处理无类型定义或类型定义过时的TypeScript库？

Great question! I’ve run into this exact headache so many times—working with a cool new JS library that either has zero TypeScript support, or its type definitions are stuck on an older version, throwing errors when I try to use the latest features. Here are the most practical, community-approved fixes I rely on:

Before building anything from scratch, do a quick check:

• Install the official community types via npm install @types/[package-name] --save-dev. If they’re outdated, head over to the DefinitelyTyped repo for that package—someone might have already opened a PR to update the types, or you can submit one yourself if you have time.
• Some libraries now ship with built-in type declarations (no need for @types!). Check the package’s README or package.json for a "types" or "typings" field—if it exists, you’re good to go, just make sure you’re on the latest version of the library.

If there are no existing types at all, or the existing ones are too far behind, roll your own .d.ts files:

• Create a types folder in your project root, then add a file like [package-name].d.ts.
• For example, if a library just released a newFeature() function that’s missing from types, you can declare it like this:

declare module '[package-name]' {
  export function newFeature(options: { foo: string; bar?: number }): Promise<void>;
  // Add other existing functions/properties you use too!
}

• Don’t forget to update your tsconfig.json to include this folder: add "types/**/*.d.ts" to the include array, or set typeRoots to include your types directory.

If only one or two new functions are causing issues, type assertions let you override TypeScript’s checks temporarily:

// Tell TypeScript exactly what the function signature should be
(library.newFeature as (opts: { foo: string }) => Promise<void>)({ foo: "hello" });

Just make sure you double-check the actual API docs—you’re bypassing TypeScript here, so you’re on the hook for making sure the types match the real implementation.

When you know your code is correct but the types are wrong, these comments let you suppress errors:

• // @ts-expect-error is better because it will throw an error if the types ever get fixed (reminding you to remove the comment later):

// @ts-expect-error: newFeature isn't included in the current @types package yet
library.newFeature({ foo: "test" });

• // @ts-ignore just suppresses the error entirely, so use it sparingly and always add a comment explaining why you need it.

If writing types from scratch feels overwhelming, use tools like dts-gen to auto-generate a basic set of type declarations:

npx dts-gen -m [package-name]

This will spit out a .d.ts file with inferred types based on the library’s runtime exports. You can then tweak and refine the generated code to match the actual API docs.

If the library already has types but is missing new features, you can extend the existing declarations instead of rewriting everything:

import * as library from '[package-name]';

declare module '[package-name]' {
  // Extend the existing export type
  interface LibraryCore {
    newFeature(options: { foo: string }): Promise<void>;
  }
}

This merges your new type definitions with the existing ones, so you get the best of both worlds.

If you’re in a pinch and need to unblock yourself immediately, you can cast the library to any:

const lib: any = require('[package-name]');
lib.newFeature({ foo: "test" });

But be warned—this turns off all TypeScript checks for that library, so it’s a temporary fix at best. Replace it with proper types as soon as you can.

Long-term, contributing to the DefinitelyTyped repo or opening a PR on the library itself to add/improve types is the most helpful thing you can do for the community—but for day-to-day work, these tricks will keep you moving without ditching TypeScript’s safety.

内容的提问来源于stack exchange，提问作者Clement