Use precise null and undefined type checking that matches the actual usage context. Distinguish between checking if a type contains undefined (`undefined extends T`) versus checking if a type is exactly undefined (`Equal extends true`). For inferred return types, use the "contains undefined" check since the type may be a union. For direct values and top-level parameters, use exact equality checks. Additionally, ensure optional modifiers in type definitions match actual implementation requirements. Remove optional modifiers (`?`) when parameters are required in the implementation, and use precise typing to distinguish required parameters (`string`) from optional ones (`string | null | undefined`). Example of precise undefined checking: ```typescript // For inferred types - check if undefined is in the union type IsDefined = undefined extends T ? false : true; // For exact values - check if type is exactly undefined type IsExactlyUndefined = Equal extends true ? false : true; // Distinguish required vs optional parameters type PathParams = { [key in RequiredPathParam]: string; } & { [key in OptionalPathParam]?: string | null | undefined; }; // Remove optional modifier when parameter is actually required getFetcher(key: string): Fetcher; // not key?: string ``` This approach prevents type errors, ensures API contracts match implementations, and provides better developer experience through more accurate IntelliSense and compile-time checking.