Is it possible to change typescript required or optional depending on a parameter?

I'm trying to use the same function to query in a couple of different ways, and I would like to use typescript to enforce some parameters depending on what parameters they provide to the function.

E.g. If I pass a query, I also need you to pass these other params, but you don't have to pass the query.

Right now, I can check to see if they are passing all required parameters, but I would like to be able to enforce them as required if query is passed to the function

Example function
I would like query to be optional
but if query is passed, I want column and row to be required

// typescript

interface GoogleSheetsConfig {
    sheetId: string;
    query? string;
	column?: string;
	row?: string;
}

export const fetchGoogleSheet = async ({
	sheetId,
	query,
	column,
    row,
}: GoogleSheetsConfig) => {

// if query exists, include column and row
// else ignore query,
}

I found this answer that says it does what I'm trying to accomplish, but there is no explanation:
https://stackoverflow.com/questions/70522338/typescript-interface-property-want-to-change-optional-to-required-depending-on-o

You want GoogleSheetsConfig to either have all of query, column, and row present, or you want it to have query missing (and column and row can remain optional). That "either-or" sort of type is best represented in TypeScript by a union.

To write that, let's take your original GoogleSheetsConfig type and rename it out of the way to BaseGoogleSheetsConfig:

interface BaseGoogleSheetsConfig {
  sheetId: string;
  query?: string;
  column?: string;
  row?: string;
}

Now we can represent the two possibilities mentioned above as two separate types. If query is present, then so are column and row. So let's specify that a GoogleSheetsConfigWithQuery has all three present:

interface GoogleSheetsConfigWithQuery extends BaseGoogleSheetsConfig {
  query: string;
  column: string;
  row: string;
}

Otherwise, query is absent. We can't actually directly say that a property must be absent. Instead we can say that it is optional (so it may be absent) and that its value type is the impossible never type (so it essentially cannot be present with a defined value). Depending on your compiler settings it may allow undefined to be there. That's as close as we can get; in practice it is probably good enough. So let's define GoogleSheetsConfigWithoutQuery that way:

interface GoogleSheetsConfigWithoutQuery extends BaseGoogleSheetsConfig {
  query?: never; 
}

And so a GoogleSheetsConfig is either a GoogleSheetsConfigWithQuery or a GoogleSheetsConfigWithoutQuery:

type GoogleSheetsConfig =
  GoogleSheetsConfigWithQuery | GoogleSheetsConfigWithoutQuery;

Let's now look at the fetchGoogleSheet function:

export const fetchGoogleSheet = async ({
  sheetId,
  query,
  column,
  row,
}: GoogleSheetsConfig) => {    
  column.toUpperCase(); // error, might be undefined
  if (typeof query !== "undefined") {
    column.toUpperCase(); // known to be defined
    row.toUpperCase(); // known to be defined
  }
}

Here you can see that before we test query, the value of column might be undefined, while if query is known to be defined, then column and row are also known to be defined.

This works because GoogleSheetsConfig is not just a union, but a discriminated union, with query as the discriminant property, since query might be undefined, which is a "unit type" or a "literal type", and TypeScript supports using a field as a discriminant as long as it has a literal type in some member of the union.

And you're also lucky in that TypeScript supports control flow analysis for destructured discriminated unions. Before TypeScript 4.6 you'd have had to leave the function parameter as a single variable like arg and then check if (typeof arg.query !== "undefined") { arg.row.toUpperCase() }. But now you are able to destructure its properties into separate variables, and still have the compiler track the correlation between them.

Playground link to code