Using Zod for API response validation

[MobinAskari]

Hello, I hope all is well.
The API that I'm using in my project returns a response body which is shaped in either of these two shapes:

 {
  ok : true,
  data: {} // dynamic but right now it's always an object
 }
 
 {
  ok : false,
  error: "" // Currently it's a string and probably is going to stay like this
 }
 

The Zod schemas that I defined for validating these responses look like this:

import { z } from "zod"

type DataSchema<T> = z.ZodType<T>

export const successResponseSchema = <T>(
	dataSchema: DataSchema<T>
) =>
	z
		.object({
			ok: z.literal(true),
			data: dataSchema
		})
		.strict()

export const errorResponseSchema = z
	.object({
		ok: z.literal(false),
		error: z.string().min(1)
	})
	.strict()

export const apiResponseSchema = <T>(
	successDataSchema: DataSchema<T>
) =>
	z.discriminatedUnion("ok", [
		successResponseSchema(successDataSchema),
		errorResponseSchema
	])

As for my questions:
1- Is using z.ZodTypeAny valid? I understand I could use z.AnyZodObject since the data is currently an object but I want to future proof it
2- I tried this current implementation with different data and it's working as expected, but could there potentially be an edge case that I'm not aware of?

• A follow up:
  3- the data is typed as any, although the provided Zod schema for the data property is a Zod object; Is there a way to get the correct type inference when the dataSchema is provided by the user?

As in:

const schema = successResponseSchema(z.object({ url: z.string().url() }))
const result = schema.parse({ok: true, data: {url: "http://github.com"}})
// Be able to have type inference for `result.data.url` and not get `data?: any`

I was able to get the desired results by using generics, not sure if it's the correct approach