Build a discriminator but there is already another one!

[AnsBdran]

The existing schema:

import { FORM_FIELDS_MINIMUM_NUMBERS, formErrors } from '@/config/consts';
import { extensionTypeSchema,  } from '@/lib/zod-utilities';
import { z } from 'zod';
import {
  characterSchema,
  surahSchema,
  surahWithVerseSchema,
} from './extensions';
import { surahs } from '@/config/quran/surah';

const basePostSchema = z.object({
  id: z.number().int().positive().optional(),
  title: z
    .string()
    .trim()
    .min(
      FORM_FIELDS_MINIMUM_NUMBERS.postTitle,
      formErrors.MINIMUM_FIELD_CHARACTERS.message
    ),
  content: z
    .string({ required_error: formErrors.FIELD_IS_REQUIRED.message })
    .trim()
    .min(
      FORM_FIELDS_MINIMUM_NUMBERS.postContent,
      formErrors.MINIMUM_FIELD_CHARACTERS.message
    ),
  collectionId: z.number().min(1).int(),
});

export const postSchema = z
  .discriminatedUnion('extension', [
    basePostSchema.extend({
      extension: z.literal('BASE'),
    }),
    basePostSchema.merge(surahWithVerseSchema).extend({
      extension: z.literal('SURAH_WITH_VERSE'),
      title: basePostSchema.shape.title.optional(),
    }),
    basePostSchema.merge(characterSchema).extend({
      extension: z.literal('CHARACTER'),
    }),
    basePostSchema.merge(surahSchema).extend({
      extension: z.literal('SURAH'),
    }),
  ])
  .refine(
    (data) => {
      if (data.extension === 'SURAH_WITH_VERSE') {
        const surahVersesCount = surahs.find(
          (s) => s.id === data.surah
        )!.total_verses;

        return data.verse <= surahVersesCount;
      }
      return true;
    },
    {
      message: formErrors.INVALID_VERSE_NUMBER.message,
      path: ['verse'],
    }
  );

export type PostSchemaType = z.infer<typeof postSchema>;

the extensions.ts file:

import { formErrors } from '@/config/consts';
import { surahIds } from '@/config/quran/surah';
import { z } from 'zod';

export const verseSchema = z.object({
  verse: z
    .number({
      required_error: formErrors.FIELD_IS_REQUIRED.message,
    })
    .int()
    .min(1),
});

export const surahSchema = z.object({
  surah: z.enum(surahIds, {
    required_error: formErrors.FIELD_IS_REQUIRED.message,
  }),
});

export const surahWithVerseSchema = surahSchema.merge(verseSchema);

export const characterSchema = z.object({
  character: z
    .string({
      required_error: formErrors.FIELD_IS_REQUIRED.message,
    })
    .min(1),
});

export type SurahWithVerseSchemaType = z.infer<typeof surahWithVerseSchema>;

I want to achieve something like this:

import { FORM_FIELDS_MINIMUM_NUMBERS, formErrors } from '@/config/consts';
import { localeEnum, tagsSchema } from '@/lib';
import { z } from 'zod';

const baseFatwaSchema = z.object({
  question: z
    .string({
      required_error: formErrors.FIELD_IS_REQUIRED.message,
    })
    .trim()
    .min(
      FORM_FIELDS_MINIMUM_NUMBERS.fatwaQuestion,
      formErrors.MINIMUM_FIELD_CHARACTERS.message
    ),
  answer: z
    .string({ required_error: formErrors.FIELD_IS_REQUIRED.message })
    .trim()
    .min(
      FORM_FIELDS_MINIMUM_NUMBERS.fatwaAnswer,
      formErrors.MINIMUM_FIELD_CHARACTERS.message
    ),
});

const createFatwaSchema = baseFatwaSchema.merge(
  z.object({
    tags: tagsSchema,
    type: z.literal('CREATE'),
  })
);

const editFatwaSchema = createFatwaSchema.merge(
  z.object({
    id: z.number().int().positive(),
    tags: tagsSchema,
    type: z.literal('EDIT'),
  })
);

const translateFatwaSchema = baseFatwaSchema.merge(
  z.object({
    locale: localeEnum,
    type: z.literal('TRANSLATE'),
    id: z.number().int().positive()
  })
);

export const fatwaSchema = z.discriminatedUnion('type', [
  createFatwaSchema,
  editFatwaSchema,
  translateFatwaSchema,
]);

export type CreateFatwaSchemaType = z.infer<typeof createFatwaSchema>
export type EditFatwaSchemaType = z.infer<typeof editFatwaSchema>;
export type TranslateFatwaSchemaType = z.infer<typeof translateFatwaSchema>;

export type FatwaSchemaType = z.infer<typeof fatwaSchema>;

[AnsBdran]

in other words, I want two discriminators, type and extension