<think>
Okay, I need to implement the stamp_build function according to the given specifications. Let me read the problem carefully again.

The function takes three integers: major, minor, and patch. The stamp is calculated as patch + (minor * 1000) + (major * 1000000). Then, I need to validate the inputs. The constraints are:

- Each component must be a whole number (so if any is not an integer, like a float or string, it's invalid).
- No negative values for major, minor, or patch.
- Minor and patch cannot be 1000 or more since they are three-digit fields.

Wait, the problem says "a negative component" is invalid. So all three components must be non-negative. Also, minor and patch must be less than 1000. Because each is stored in three digits. So if minor is 1000 or more, that's invalid. Same for patch.

So first, I need to check that all three inputs are integers. Then check that major >= 0, minor >=0, patch >=0. Then check that minor < 1000 and patch < 1000. If any of these checks fail, raise a ValueError with a short message.

So the steps are:

1. Validate that major, minor, patch are integers. How? Well, in Python, if the input is not an integer, like a string or float, then checking isinstance would fail. But the function parameters are typed as int, so the user is supposed to pass integers. However, the problem says to reject if any component is not a whole number. So, for example, if someone passes a float like 3.5, that's invalid. So in the code, I need to check that each of the three parameters is an instance of int. Otherwise, raise ValueError.

Wait, but the function is supposed to reject any non-integer components. So, for example, if major is a string, or a boolean, or a float, then it's invalid.

So in the code, first, check that major is an integer. Similarly for minor and patch.

But how to do that? Because in Python, if the function is called with, say, a string, then the parameters would be of type str, which is not int. So, in the code, I can check if each of the three parameters is an instance of int. If not, raise ValueError.

So, first, check that major is an int. Then minor, then patch.

Then check that major >=0, minor >=0, patch >=0.

Then check that minor < 1000 and patch < 1000.

If any of these conditions are not met, raise ValueError with a message.

Once all checks are passed, compute the stamp as (major * 1_000_000) + (minor * 1_000) + patch.

Wait, the problem says that the stamp is patch plus a thousand for every minor step, plus a million for every major step. So the formula is major * 1_000_000 + minor * 1_000 + patch.

Yes.

So the code would be:

def stamp_build(major: int, minor: int, patch: int) -> int:
    # Check if all are integers (but since the parameters are typed as int, maybe this is redundant? But the problem says to reject if any component is not a whole number. So even if the user passes a float, like 3.0, which is an instance of int? Wait, no. In Python, 3