Your TypeScript reads like Python

The error you already know

You asked the model for a UserService class and it obliged. It read the request the way a Python developer would and handed back a class with a constructor and one method hanging off it. This is good Python. The compiler reads the same lines and stops on the parameter that carries no type.

user-service.ts

// You asked the model for a UserService
// class and it obliged.
// This is good Python. The compiler reads
// it the way TypeScript must.
class UserService {
  constructor(private db: Database) {}

  getUser(idParameter 'id' implicitly has an 'any' type.) {
    return this.db.find(id);
  }
}

In Python that bare parameter is normal and the program runs. In TypeScript it becomes an implicit any, which is the one shape the compiler is set up to reject. That red underline is a symptom of a bigger cost. You prompted for Python and the model gave you Python in TypeScript syntax, a class built to hold one method, and the runtime underneath wants something plainer.

user-service.ts(7,11) Parameter 'id' implicitly has an 'any' type.

Watch the habit become the idiom

The fix is less structure. A class that holds one method and a little state is a function waiting to be unwrapped, and the value it returns is a plain object whose shape you can name.

Step through it at your own pace. Each click is one move.

Step 1 of 4

Good Python. A service is a class, state lives in the constructor.

user_service.pyPython

class UserService:
    def __init__(self, name):
        self.name = name

    def create(self):
        return {"name": self.name,
                "active": True}class UserService {
  constructor(private name: string) {}

  create() {
    return {
      name: this.name,
      active: true,
    };
  }
}function createUser(name: string) {
  return { name, active: true };
}type User = {
  name: string;
  active: boolean;
};

function createUser(name: string): User {
  return { name, active: true };
}

Here's what each move does.

Start with good Python, a class with a constructor and one method.
Port it straight across and you get the same class in TypeScript, structure and all.
Drop the class. One method with no real state is just a function.
Name the object it hands back, and the return is a typed object the compiler checks at every call.

That last move is the one the class was hiding. A class promises state and identity, more than a single method needs. A function that returns a typed object promises only the shape of its answer, and the compiler holds it to exactly that. Now you're just describing a result.

Now make the compiler agree

The class below holds two fields and builds one object. Convert it into a function named createUser that returns the same object, typed as User. Drop the class keyword entirely and let the return shape do the work. The hidden checks read every field, so a near miss shows up as a type error rather than a pass.

type-checking…