<think>
Okay, I need to implement the clause_order function. Let's see the requirements. The function takes two strings, a and b, which are clause marks. Each mark is a dot-separated sequence of numbers. The goal is to compare them and return -1, 1, or 0 based on their order.

First, I need to parse each string into a list of integers. For example, "3.2.11" becomes [3, 2, 11]. But there are some validation steps. The input must be a string, not empty, and each part must be a valid number. Also, no leading zeros, and each part must be a decimal integer.

So the first step is to split the input strings into parts. For each string, split by dots. Then check if each part is a valid number. If any part is invalid, raise a ValueError.

Wait, the problem says to reject a mark that is not a string, empty, or has invalid parts. So for each input a and b, I need to validate them first.

So the steps for each input string:

1. Check if it's a string. If not, raise error. But the function's parameters are str, so maybe that's already handled. But the problem says to reject if the input is not a string. Wait, the function's interface is def clause_order(a: str, b: str) -> int. So the parameters are expected to be strings. So the function will check if a and b are strings. But the problem says to reject if the input is not a string. So in the code, I need to check if a and b are strings. If not, raise ValueError.

But the function is supposed to take a and b as strings. So maybe the code should check if a and b are strings. For example, if a is not a string, then raise ValueError.

Then, check if the string is empty. If it's empty, raise error.

Then, split the string into parts. For example, "3.2.11" becomes ["3", "2", "11"].

Then, for each part, check if it's a valid number. The part must not be empty, and must not have leading zeros unless it's exactly "0". Also, each part must consist of digits only, and no other characters.

So for each part in the split list:

- Check that the part is not empty.
- Check that the part is a valid integer. For example, "0" is allowed, but "01" is not.
- Check that the part does not have leading zeros unless it's exactly "0".

So, for each part, we can process it as follows:

- If the part is "0", it's valid.
- If the part has length > 1, check that the first character is not '0'.

Then, convert each part to an integer.

Once both a and b are parsed into lists of integers, compare them.

The comparison is done element-wise. Start from the first element. If at any position, one is larger than the other, return 1 or -1 accordingly. If all elements are equal up to the shorter length, then the longer one is considered larger.

For example, [3, 2] vs [3, 2, 1]. The first is shorter, so the second is longer. So the second comes after the first.

So, the steps for comparing a and b:

- Compare each element in the parsed lists. For each index, compare the elements. If one is longer, then the longer one is considered larger.

So, for the lists a_list and b_list:

Loop through the minimum of the two lengths