When I delete the computed properties, type inference works. When I add them back the store become type any.

[rkfiv]

import { useVuelidate } from "@vuelidate/core";
import { cloneDeep, toNumber } from "lodash";
import { getNestedObjectValue, setNestedObjectValue } from "./helpers";
export const useApplicationStore = defineStore(
  "application",
  () => {
    // ? Questionnaire Definitions

    let questionnaires = reactive([
      {
        id: "petitionPartOne",
        label: "Petition Part One",
        progress: {
          completed: false,
          percentage: 0,
        },
        navigation: {
          history: [],
        },
        questionCategories: petitionPartOneCategories(),
      },
    ]);

    //#region Data Definitions

    // function dynamicProperty(path) {
    //   return computed({
    //     get: () => getNestedObjectValue($customerData, path),
    //     set: (value) => setNestedObjectValue($customerData, path, value),
    //   });
    // }
    let $settings = reactive({
      startingQuestionnaireId: "petitionPartOne",
    });

    let $data = reactive({
      activeQuestionnaireID: "",
      activeQuestionnaireCategoryID: "",
      activeQuestionID: "",
    });

    let $customerData = reactive({
      sponsor: {
        fullName: {
          first: "",
          middle: "",
          last: "",
        },
      },
      beneficiary: {
        fullName: {
          first: "",
          middle: "",
          last: "",
        },
      },
    });
    //#endregion Data Definitions

    //#region Computed Getters
    let questionCompletionStatusInjection = (questionId) => {
      return activeQuestionnaire.value!.questionCategories;
    };

    const activeQuestionnaire = computed(() => {
      return questionnaires.find(
        (questionnaire) => questionnaire.id === $data.activeQuestionnaireID
      );
    });
    const activeQuestionnaireQuestionCategories = computed(() => {
      if (!activeQuestionnaire.value) {
        return "Active Questionnaire Is Unset";
      }
      return activeQuestionnaire.value.questionCategories;
    });
    const activeQuestionnaireProgress = computed(() => {
      if (!activeQuestionnaire.value) {
        return "Active Questionnaire Is Unset";
      }
      return activeQuestionnaire.value.progress;
    });
    const activeQuestionnaireCategory = computed(() => {
      if (!activeQuestionnaire.value) {
        return "Active Questionnaire Is Unset";
      } else if (activeQuestionnaire.value) {
        return activeQuestionnaire.value.questionCategories.find(
          (category) => category.id === $data.activeQuestionnaireCategoryID
        );
      }
    });
    const activeQuestionnaireCategoryIndex = computed(() => {
      if (!activeQuestionnaire.value) {
        return "Active Questionnaire Is Unset";
      } else if (activeQuestionnaire.value) {
        return activeQuestionnaire.value.questionCategories.findIndex(
          (category) => category.id === $data.activeQuestionnaireCategoryID
        );
      }
    });
    const onFinalQuestionnaireCategory = computed(() => {
      if (!activeQuestionnaire.value) {
        return "Active Questionnaire Is Unset";
      } else if (activeQuestionnaire.value) {
        return (
          activeQuestionnaireCategoryIndex.value ===
          activeQuestionnaire.value.questionCategories.length - 1
        );
      }
    });
    const activeQuestion = computed(() => {
      if (typeof activeQuestionnaireCategory.value !== "string") {
        return activeQuestionnaireCategory.value!.questions.find(
          (question) => question.id === $data.activeQuestionID
        );
      } else {
        return "Active Questionnaire Category Is Unset";
      }
    });
    const nextQuestion = computed(() => {
      if (typeof activeQuestionnaireCategory.value !== "string") {
        let nextQuestionIndex =
          activeQuestionnaireCategory.value!.questions.findIndex(
            (question) => question.id === $data.activeQuestionID
          );
        if (
          activeQuestionnaireCategory.value!.questions.length ===
          nextQuestionIndex + 1
        ) {
          return "End of Questionnaire";
        }
        return activeQuestionnaireCategory.value!.questions[
          nextQuestionIndex + 1
        ];
      } else {
        return "Active Questionnaire Category Is Unset";
      }
    });
    //#endregion Computed Getters

    //#region Actions

    let setActiveQuestionnaire = (questionnaireId) => {
      $data.activeQuestionnaireID = questionnaireId;
    };
    let setActiveQuestionnaireCategoryToFirstCategoryInQuestionnaire = () => {
      if (typeof activeQuestionnaireQuestionCategories.value[0] !== "string") {
        $data.activeQuestionnaireCategoryID =
          activeQuestionnaireQuestionCategories.value[0].id;
      }
    };
    let setActiveQuestionnaireCategoryToNextCategoryInQuestionnaire = () => {
      if (typeof activeQuestionnaireQuestionCategories.value[0] !== "string") {
        $data.activeQuestionnaireCategoryID =
          activeQuestionnaireQuestionCategories.value[
            toNumber(activeQuestionnaireCategoryIndex.value!) + 1
          ].id;
      }
    };
    let setActiveQuestionIDToFirstQuestionInActiveQuestionnaireCategory =
      () => {
        if (
          typeof activeQuestionnaireCategory.value !== "string" &&
          typeof activeQuestionnaireCategory.value !== "undefined"
        ) {
          $data.activeQuestionID =
            activeQuestionnaireCategory.value.questions[0].id;
        } else {
          console.error("Active Questionnaire Category is undefined");
        }
      };
    let setActiveQuestion = (questionId) => {
      $data.activeQuestionID = questionId;
    };

    let navigateToNextQuestion = () => {
      if (nextQuestion.value === "Active Questionnaire Category Is Unset") {
        console.error("Next Question is undefined");
        return;
      }
      // @ts-ignore
      if (nextQuestion.value == "End of Questionnaire") {
        // TODO - We need to check if there is other categories in the questionnaire
        // TODO - If there is, set the activeQuestionnaireCategory to the first one
        if (!onFinalQuestionnaireCategory.value) {
          setActiveQuestionnaireCategoryToNextCategoryInQuestionnaire();
          setActiveQuestionIDToFirstQuestionInActiveQuestionnaireCategory();
        }
      } else {
        setActiveQuestion(activeQuestion.value!.nextQuestion());
      }
    };

    let initialize = () => {
      // ! If none in memory, set active questionnaire to starting questionnaire
      // ! If there is one in memory, set active questionnaire to that one
      if (!$data.activeQuestionnaireID) {
        setActiveQuestionnaire($settings.startingQuestionnaireId);
        // TODO - Now we need to get the activeQuestionnaire so we can explore its questionCategories
        // ? You can get the active questionnaire by calling activeQuestionnaire.value
        // TODO - Of the categories lets get the first one then set that as the activeQuestionnaireCategory by its id
        setActiveQuestionnaireCategoryToFirstCategoryInQuestionnaire();
        // TODO - Now we need to set the activeQuestion to the first question in the activeQuestionnaireCategory
        setActiveQuestionIDToFirstQuestionInActiveQuestionnaireCategory();
      }
    };
    //#endregion Actions

    // initialize();

    //#region Return Object
    return {
      $settings,
      $data,
      $customerData,
      activeQuestionnaireProgress,
      activeQuestionnaireQuestionCategories,
      activeQuestionnaire,
      activeQuestion,
      questionnaires,

      activeQuestionnaireCategory,
      nextQuestion,
      activeQuestionnaireCategoryIndex,
      onFinalQuestionnaireCategory,

      setActiveQuestionnaire,
      setActiveQuestionnaireCategoryToFirstCategoryInQuestionnaire,
      setActiveQuestionIDToFirstQuestionInActiveQuestionnaireCategory,
      // ? Questionnaire Navigation Actions
      navigateToNextQuestion,
      initialize,
    };
    //#endregion Return Object
  },
  {
    persist: true,
  }
);
if (import.meta.hot) {
  import.meta.hot.accept(acceptHMRUpdate(useApplicationStore, import.meta.hot));
}