@solidstarters/solid-core-ui 1.1.74 → 1.1.75

package/dist/components/core/model/FieldMetaDataForm.tsx

@@ -1,3048 +0,0 @@
-'use client';
-import CodeEditor from "@/components/common/CodeEditor";
-import { SingleSelectAutoCompleteField } from "@/components/common/SingleSelectAutoCompleteField";
-import { getSingularAndPlural } from "@/helpers/helpers";
-import { useGetFieldDefaultMetaDataQuery } from "@/redux/api/fieldApi";
-import { useLazyGetMediaStorageProvidersQuery } from "@/redux/api/mediaStorageProviderApi";
-import { useLazyGetModelsQuery, useUpdateUserKeyMutation } from "@/redux/api/modelApi";
-import { useLazyGetmodulesQuery } from "@/redux/api/moduleApi";
-import { useFormik } from "formik";
-import { capitalize } from "lodash";
-import { usePathname } from "next/navigation";
-import { AutoComplete } from "primereact/autocomplete";
-import { Button } from "primereact/button";
-import { Calendar } from "primereact/calendar";
-import { Checkbox } from "primereact/checkbox";
-import { Dialog } from "primereact/dialog";
-import { Dropdown, DropdownChangeEvent } from "primereact/dropdown";
-import { InputNumber } from "primereact/inputnumber";
-import { InputText } from "primereact/inputtext";
-import { InputTextarea } from "primereact/inputtextarea";
-import { Message } from "primereact/message";
-import { MultiSelect } from "primereact/multiselect";
-import { RadioButton } from "primereact/radiobutton";
-import { SelectButton } from "primereact/selectbutton";
-import { TabPanel, TabView } from "primereact/tabview";
-import { Toast } from "primereact/toast";
-import { classNames } from "primereact/utils";
-import qs from "qs";
-import React, { useEffect, useRef, useState } from "react";
-import * as Yup from "yup";
-import FieldSelector from "./FieldSelector";
-
-
-
-enum SolidFieldType {
-  // numeric types
-  int = 'int',
-  bigint = 'bigint',
-  float = 'float',
-  // double = 'double',
-  decimal = 'decimal',
-
-  // text types
-  shortText = 'shortText',
-  longtext = 'longText',
-  richText = 'richText',
-  json = 'json',
-
-  // boolean types
-  boolean = 'boolean',
-
-  // date
-  date = 'date',
-  datetime = 'datetime',
-  time = 'time',
-
-  // relation
-  relation = 'relation',
-
-  // media
-  mediaSingle = 'mediaSingle',
-  mediaMultiple = 'mediaMultiple',
-
-  email = 'email',
-  password = 'password',
-
-  // selection
-  selectionStatic = 'selectionStatic',
-  selectionDynamic = 'selectionDynamic',
-
-  computed = 'computed',
-
-  uuid = 'uuid'
-}
-
-const SelectionStaticValues = ({ enumValue, onUpdate, onDelete, onAdd }: any) => {
-  const [value, display] = enumValue.split(":");
-
-  const handleValueChange = (newValue: string) => {
-    onUpdate(`${newValue}:${display || ""}`);
-  };
-
-  const handleDisplayChange = (newDisplay: string) => {
-    onUpdate(`${value || ""}:${newDisplay}`);
-  };
-
-  return (
-    <div className="flex align-items-center gap-2 mt-2">
-
-      {/* Input field for Value */}
-      <InputText
-        value={value || ""}
-        onChange={(e) => handleValueChange(e.target.value)}
-        placeholder="Value"
-        className="w-full"
-      />
-
-      {/* Input field for Display */}
-      <InputText
-        value={display || ""}
-        onChange={(e) => handleDisplayChange(e.target.value)}
-        placeholder="Display"
-        className="w-full"
-      />
-
-
-
-      {/* Plus Button to add a new row */}
-      <Button
-        icon="pi pi-plus"
-        size="small"
-        onClick={onAdd}
-        type="button"
-      />
-
-      {/* Trash Button to delete the row */}
-      <Button
-        icon="pi pi-trash"
-        size="small"
-        onClick={onDelete}
-        outlined
-        severity="danger"
-        type="button"
-      />
-    </div>
-  );
-
-}
-
-const fieldBasedPayloadFormating = (values: any, currentFields: string[], fieldMetaData: any) => {
-  // const booleanFields: string | any[] = [
-  //   "isSystem",
-  //   "defaultValue",
-  //   "required",
-  //   "unique",
-  //   "encrypt",
-  //   "index",
-  //   "private",
-  //   "relationCreateInverse"];
-  const transformedPayload = currentFields.reduce((acc: any, key: any) => {
-    acc[key] = values[key]; // Set key and its value as the same string
-    // if (booleanFields.includes(acc[key])) {
-    //   acc[key] = values[key] == "false" ? "" : true
-    // }
-    return acc;
-  }, {});
-  transformedPayload.displayName = transformedPayload.displayName.trim()
-
-  transformedPayload.identifier = fieldMetaData ? fieldMetaData.identifier : Date.now();
-  if (fieldMetaData?.id) {
-    transformedPayload.id = fieldMetaData.id
-  }
-  if (currentFields.includes("mediaStorageProviderId")) {
-    transformedPayload.mediaStorageProvider = values.mediaStorageProvider
-  }
-  if (currentFields.includes("selectionDynamicProviderCtxt")) {
-    const prettified = JSON.stringify(JSON.parse(values.selectionDynamicProviderCtxt), null, 2);
-
-    transformedPayload.selectionDynamicProviderCtxt = prettified
-  }
-
-  if (currentFields.includes("computedFieldValueProviderCtxt")) {
-    const prettified = JSON.stringify(JSON.parse(values.computedFieldValueProviderCtxt), null, 2);
-    transformedPayload.computedFieldValueProviderCtxt = prettified
-  }
-  if (currentFields.includes("relationCreateInverse")) {
-    transformedPayload.relationCreateInverse = values.relationCreateInverse == false ? false : true
-  }
-  if (transformedPayload.relationType == "many-to-one") {
-    transformedPayload.relationCascade = values.relationCascade;
-  }
-
-  if (transformedPayload.relationType == "many-to-many") {
-    transformedPayload.isRelationManyToManyOwner = true;
-  }
-  return transformedPayload
-
-}
-
-function fetchCurrentFields(solidFieldType: any, fieldDefaultMetaData: any) {
-
-  if (solidFieldType) {
-    const allowedFields = fieldDefaultMetaData?.data?.fieldTypes.filter((e: any) => e.fieldType === solidFieldType);
-    if (allowedFields.length > 0) {
-      return allowedFields[0].fields
-    }
-
-  }
-  return [
-    "name",
-    "displayName",
-    "type",
-    "ormType",
-    "required",
-    "unique",
-    "index",
-    "private",
-    "encrypt",
-    "isUserKey"
-  ];
-
-}
-
-const createValidationSchema = (currentFields: any, selectedType: any, allFields: any, fieldMetaData: any, encryptState: any) => {
-
-  let reservedNames;
-
-  if (fieldMetaData) {
-    reservedNames = allFields.length > 0 ? allFields.filter((i: any) => i.id !== fieldMetaData.id).map((f: any) => f.name) : [];
-  } else {
-
-    reservedNames = allFields.length > 0 ? allFields.map((f: any) => f.name) : [];
-  }
-
-
-
-  const schema = {
-    name: Yup.string()
-      // .matches(/^[a-z]+(-[a-z]+)*$/,"Invalid format. Use lowercase letters and hyphens only.")
-      .notOneOf(reservedNames, "Name Already in use. Please choose a different name.")
-      .required("Name is required."),
-    displayName: Yup.string().required("Display Name is required"),
-    description: Yup.string().nullable(),
-    type: Yup.string().required("Type is required"),
-    isSystem: Yup.boolean(),
-    // Conditionally add validation rules based on `currentFields`
-    ...(currentFields.includes("ormType") && {
-      ormType: Yup.string().required("Orm Type is required"),
-    }),
-    ...(currentFields.includes("length") && {
-      length: Yup.number().typeError("Length must be an integer").nullable(),
-    }),
-    // ...(currentFields.includes("defaultValue") && {
-    //   defaultValue: Yup.string().required("Default Value is required"),
-    // }),
-    // Conditionally validate defaultValue based on SolidFieldType
-    ...(currentFields.includes("defaultValue") && {
-      defaultValue: Yup.mixed().nullable().when("type", (type: any) => {
-        switch (selectedType.value) {
-          case "int":
-          case "bigint":
-            return Yup.number().nullable().typeError("Default value must be an integer")
-              .integer("Default value must be an integer");
-          case "float":
-          case "decimal":
-            return Yup.number().nullable().typeError("Default value must be an integer")
-          case "shortText":
-          case "longText":
-          case "richText":
-          case "json":
-            return Yup.string().nullable().typeError("Default value must be an String")
-          case "boolean":
-            return Yup.boolean().nullable().typeError("Default value must be a boolean")
-          case "date":
-          case "datetime":
-          case "time":
-            return Yup.date().nullable().typeError("Default value must be an Date")
-          default:
-            return Yup.mixed().nullable(); // Default fallback if no match
-        }
-      }),
-    }),
-
-    // Add more conditional fields as needed
-
-    ...(currentFields.includes("regexPattern") && {
-      regexPattern: Yup.string(),
-      regexPatternNotMatchingErrorMsg: Yup.string(),
-    }),
-    ...(currentFields.includes("required") && {
-      required: Yup.boolean(),
-    }),
-    ...(currentFields.includes("unique") && {
-      unique: Yup.boolean(),
-    }),
-    ...(currentFields.includes("encrypt") && {
-      encrypt: Yup.boolean(),
-    }),
-    ...(currentFields.includes("encryptionType") && encryptState == true && {
-      encryptionType: Yup.string().required(
-        "Encryption Type Value is required"
-      ),
-    }),
-    ...(currentFields.includes("decryptWhen") && encryptState == true && {
-
-      decryptWhen: Yup.string().required("Decrypt When Value is required"),
-    }),
-    ...(currentFields.includes("index") && {
-      index: Yup.boolean(),
-    }),
-    // ...(currentFields.includes("min") && {
-    //   min: Yup.number().required("Min is required"),
-    // }),
-    ...(currentFields.includes("min") && {
-      min: Yup.mixed().nullable()
-        .when("type", (type: any) => {
-          switch (selectedType.value) {
-            case "int":
-              return Yup.number().nullable().typeError("Min must be an integer")
-                .integer("Min must be an integer");
-            case "decimal":
-            case "shortText":
-            case "longText":
-            case "richText":
-            case "json":
-              return Yup.number().nullable().typeError("Min must be an integer");
-            default:
-              return Yup.mixed().nullable().nullable(); // Default fallback if no match
-          }
-        }),
-    }),
-    // ...(currentFields.includes("max") && {
-    //   max: Yup.number().required("Max is required"),
-    // }),
-    ...(currentFields.includes("max") && {
-      max: Yup.mixed()
-        .when("type", (type: any) => {
-          switch (selectedType.value) {
-            case "int":
-              return Yup.number().nullable().typeError("Max must be an integer")
-                .integer("Max must be an integer")
-                .test(
-                  "greater-than-min",
-                  "Max must be greater than Min",
-                  function (value) {
-                    const { min } = this.parent; // Access sibling field 'min'
-                    // if (min != null && value == null) {
-                    //   // Trigger error if Min is filled but Max is empty
-                    //   return this.createError({
-                    //     message: "Max is required if Min is specified",
-                    //   });
-                    // }
-                    return value == null || value > min; // Validate only if Max exists
-                  }
-                );
-
-
-            case "decimal":
-            case "shortText":
-            case "longText":
-            case "richText":
-            case "json":
-              return Yup.number().nullable().typeError("Max must be an integer")
-                .test(
-                  "greater-than-min",
-                  "Max must be greater than Min",
-                  function (value) {
-                    const { min } = this.parent; // Access sibling field 'min'
-                    // if (min != null && value == null) {
-                    //   // Trigger error if Min is filled but Max is empty
-                    //   return this.createError({
-                    //     message: "Max is required if Min is specified",
-                    //   });
-                    // }
-                    return value == null || value > min; // Validate only if Max exists
-                  }
-                );
-
-
-            default:
-              return Yup.mixed().nullable().nullable(); // Default fallback if no match
-          }
-        }),
-    }),
-    ...(currentFields.includes("private") && {
-      private: Yup.boolean(),
-    }),
-    ...(currentFields.includes("mediaTypes") && {
-      mediaTypes: Yup.mixed().required("Media Types must be an array").required("Media Types is required"),
-    }),
-
-    ...(currentFields.includes("mediaMaxSizeKb") && {
-      mediaMaxSizeKb: Yup.number().required("Media Max Size is required"),
-    }),
-    ...(currentFields.includes("mediaStorageProviderId") && {
-      mediaStorageProviderId: Yup.number().required(
-        "Media Storage Provider is required"
-      ),
-    }),
-    ...(currentFields.includes("mediaStorageProviderId") && {
-      mediaStorageProvider: Yup.object().required(
-        "Media Storage Provider is required"
-      ),
-    }),
-
-    ...(currentFields.includes("mediaEmbedded") && {
-      mediaEmbedded: Yup.boolean(),
-    }),
-    ...(currentFields.includes("relationType") && {
-      relationType: Yup.string().required("Relation Type is required"),
-    }),
-    ...(currentFields.includes("relationCoModelSingularName") && {
-      relationCoModelSingularName: Yup.string().required(
-        "Relation Model Singular Name is required"
-      ),
-    }),
-    ...(currentFields.includes("relationCoModelFieldName") && {
-      relationCoModelFieldName: Yup.string()
-      // .required(
-      //   "Relation Model Field Name is required"
-      // ),
-    }),
-    ...(currentFields.includes("relationCreateInverse") && {
-      relationCreateInverse: Yup.boolean(),
-    }),
-    ...(currentFields.includes("relationCoModelFieldName") && {
-      relationCoModelFieldName: Yup.string().when("relationCreateInverse", (relationCreateInverse: any, schema) => {
-        console.log("relationCreateInverse", relationCreateInverse);
-        if (relationCreateInverse.length > 0 && relationCreateInverse[0] == true) {
-          return schema.required("Relation Co Model Field Name is required")
-        } else {
-          return schema.notRequired();
-        }
-      }),
-    }),
-
-    // ...(currentFields.includes("relationCascade") && {
-    //   relationCascade: Yup.string().required(
-    //     "Relation Cascade Value is required"
-    //   ),
-    // }),
-
-    // Conditionally validate relationCascade based on relationType
-    ...(currentFields.includes("relation") && {
-      relationCascade: Yup.string().when("relationType", (relationType: any, schema) => {
-        return relationType === "one-to-one"
-          ? schema.required("Relation Cascade Value is required for one-to-one relationships")
-          : schema.notRequired();
-      }),
-    }),
-
-
-    ...(currentFields.includes("relationModelModuleName") && {
-      relationModelModuleName: Yup.string().required(
-        "Relation Model Module Name Value is required"
-      ),
-    }),
-
-    ...(currentFields.includes("relationFieldFixedFilter") && {
-      relationFieldFixedFilter: Yup.string().nullable(),
-    }),
-
-    ...(currentFields.includes("selectionDynamicProvider") && {
-      selectionDynamicProvider: Yup.string().required(
-        "Selection Dynamic Provider Value is required"
-      ),
-    }),
-    ...(currentFields.includes("selectionDynamicProviderCtxt") && {
-      selectionDynamicProviderCtxt: Yup.string().required(
-        "Selection Dynamic Provider Context Value is required"
-      ).test(
-        "is-valid-json",
-        "Computed Field Value Provider Context Value must be valid JSON",
-        (value) => {
-          if (!value) return false; // Ensure it's required
-          try {
-            JSON.parse(value); // Check if it's valid JSON
-            return true;
-          } catch {
-            return false;
-          }
-        }
-      ),
-    }),
-
-    ...(currentFields.includes("selectionStaticValues") && {
-      selectionStaticValues: Yup.array().of(
-        Yup.string().matches(/^[\w\s\d-]+:[\w\s-]+$/, "Label and Value are required.")
-      ),
-    }),
-    ...(currentFields.includes("computedFieldValueProvider") && {
-      computedFieldValueProvider: Yup.string().required(
-        "Computed Field Function Value is required"
-      ),
-    }),
-    ...(currentFields.includes("computedFieldValueProviderCtxt") && {
-      computedFieldValueProviderCtxt: Yup.string().required(
-        "Computed Field Value Provider Context Value is required"
-      ).test(
-        "is-valid-json",
-        "Computed Field Value Provider Context Value must be valid JSON",
-        (value) => {
-          if (!value) return false; // Ensure it's required
-          try {
-            JSON.parse(value); // Check if it's valid JSON
-            return true;
-          } catch {
-            return false;
-          }
-        }
-      ),
-
-    }),
-    ...(currentFields.includes("computedFieldValueType") && {
-      computedFieldValueType: Yup.string().required(
-        "Computed Field Value Type is required"
-      ),
-    }),
-
-    ...(currentFields.includes("columnName") && {
-      columnName: Yup.string().nullable().matches(
-        /^[a-z0-9_]+$/,
-        "Column name must be in snake_case (lowercase letters, numbers, and underscores only)."
-      ),
-    }),
-
-
-
-
-    // ...(currentFields.includes("externalIdProvider") && {
-    //   externalIdProvider: Yup.string().required(
-    //     "ExternalId Provider Value is required"
-    //   ),
-    // }),
-    // ...(currentFields.includes("externalIdProviderCtxt") && {
-    //   externalIdProviderCtxt: Yup.string().required(
-    //     "EexternalId Provider Context Value is required"
-    //   ),
-    // }),
-  };
-
-  return Yup.object(schema);
-};
-
-const FieldMetaDataForm = ({ setIsDirty, modelMetaData, fieldMetaData, setFieldMetaData, allFields, deleteModelFunction, setVisiblePopup, params, setIsRequiredPopUp, showToaster }: any) => {
-
-  const booleanOptions = ["false", "true"];
-  const [isBackPopupVisible, setIsBackPopupVisible] = useState(false);
-  const [showColumnName, setShowColumnName] = useState<any>(false);
-
-  const pathname = usePathname();
-
-  const toast = useRef<Toast>(null);
-  const { data: fieldDefaultMetaData, isLoading, error, refetch } = useGetFieldDefaultMetaDataQuery(null);
-  const [currentFields, setCurrentFields] = useState(
-    fetchCurrentFields(fieldMetaData && fieldMetaData.type, fieldDefaultMetaData)
-  );
-
-  const [triggerGetMediaStorageProvider, { data: MediaStorageProviderData, isFetching: isMediaStorageProviderFetching, error: MediaStorageProviderError }] = useLazyGetMediaStorageProvidersQuery();
-  const [triggerGetModules, { data: moduleData, isFetching: isModuleFetching, error: moduleError }] = useLazyGetmodulesQuery();
-  const [triggerGetModels, { data: modelData, isFetching: ismodelFetching, error: modelError }] = useLazyGetModelsQuery();
-  const [
-    updateUserKey,
-    { isLoading: isUpdateUserKeyLoading, isSuccess: isUpdateUserKeySuccess, isError: isUpdateUserKeyError, error: UpdateUserKeyError, data: newModel },
-  ] = useUpdateUserKeyMutation();
-
-
-  const [markdownText, setMarkdownText] = useState<string>();
-  const [encryptState, setEncryptState] = useState<any>(false);
-
-  const [showTypeFilter, setShowTypeFilter] = useState(fieldMetaData ? false : true);
-  const [selectedType, setSelectedType] = useState(fieldMetaData?.type && { label: fieldMetaData?.type, value: fieldMetaData?.type });
-  const [selectedComputedFieldValueType, setSelectedComputedFieldValueType] = useState(fieldMetaData?.computedFieldValueType && { label: fieldMetaData.computedFieldValueType, value: fieldMetaData.computedFieldValueType });
-  const [selectionDynamicProvider, setSelectionDynamicProvider] = useState(fieldMetaData?.selectionDynamicProvider && { label: fieldMetaData.selectionDynamicProvider, value: fieldMetaData.selectionDynamicProvider });
-  // const [externalIdProvider, setExternalIdProvider] = useState(fieldMetaData?.externalIdProvider && { label: fieldMetaData.externalIdProvider, value: fieldMetaData.externalIdProvider });
-  const [selectionStaticValues, setSelectionStaticValues] = useState(fieldMetaData && fieldMetaData.selectionStaticValues && fieldMetaData.selectionStaticValues.length > 0 && fieldMetaData?.selectionStaticValues.filter((line: any) => line.trim() !== "").join("\n"));
-  const [filteredComputedFieldValueTypes, setFilteredComputedFieldValueTypes] = useState([]);
-  const [
-    filteredSelectionDynamicProvider,
-    setFilteredSelectionDynamicProvider,
-  ] = useState([]);
-
-  const [ormTypeOptions, setOrmTypeOptions] = useState([]);
-  const [selectedOrmType, setSelectedOrmType] = useState<any>(fieldMetaData?.ormType);
-
-  const [isUserKeyFields, setUserKeyFields] = useState(false);
-  const [userKeyData, setUserKeyData] = useState([]);
-
-  const [
-    filteredExternalIdProvider,
-    setFilteredExternalIdProvider,
-  ] = useState([]);
-
-  const [filteredSelectionEncryptionType, setFilteredSelectionEncryptionType] = useState([]);
-
-  const [filteredSelectionDecryptWhen, setFilteredSelectionDecryptWhen] = useState([]);
-
-  const items = Array.from({ length: 100000 }).map((_, i) => ({
-    label: `Item #${i}`,
-    value: i,
-  }));
-
-  const validationSchema = React.useMemo(
-    () => createValidationSchema(currentFields, selectedType, allFields, fieldMetaData, encryptState),
-    [currentFields, encryptState]
-  );
-
-  const [typeSelected, setTypeSelected] = useState(false);
-
-
-  const searchMediaTypes = async (event: any) => {
-    const query = event.query;
-    try {
-      const suggestionData: any = fieldDefaultMetaData.data.mediaTypes.filter((t: any) => t.label.toLowerCase().startsWith(query.toLowerCase()));
-      return suggestionData;
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      return []
-    }
-  };
-
-  const searchMediaStorageProvIderId = async (event: any) => {
-    try {
-      const query = event.query;
-      const queryData = {
-        limit: 10,
-        offset: 0,
-        // filters: {
-        //   name: {
-        //     $containsi: query,
-        //   },
-        // },
-      };
-
-      const queryString = qs.stringify(queryData, {
-        encodeValuesOnly: true,
-      });
-
-      const result = await triggerGetMediaStorageProvider(queryString).unwrap();
-
-      if (result && result.records) {
-        const updatedSuggestion = [...result.records];
-        return updatedSuggestion
-      } else {
-        return []
-      }
-    } catch (error) {
-      return []
-    }
-  };
-
-
-  const searchModel = async (event: any) => {
-    const query = event.query;
-    const queryData = {
-      limit: 10,
-      offset: 0,
-      // filters: {
-      //   title: {
-      //     $containsi: query
-      //   }
-      // }
-    };
-
-    const queryString = qs.stringify(queryData, {
-      encodeValuesOnly: true
-    });
-
-    // Trigger the API call manually
-    const result = await triggerGetModels(queryString).unwrap(); // Unwrap to access the data
-
-    // Map the API response to AutoComplete format
-    if (result && result.records) {
-      const filteredMenu = result.records.map((m: any) => (
-        {
-          label: m.name,
-          value: m.id,
-          name: m.name,
-          id: m.id,
-        }
-      ));
-
-      // Update the suggestions in state
-      return filteredMenu
-    } else {
-      // Handle the case where no data is returned
-      return []
-    }
-  };
-
-
-
-
-  const searchOrmTypes = async (event: any) => {
-    const query = event.query;
-    try {
-
-      const ormType = fieldDefaultMetaData.data.ormType[modelMetaData?.dataSourceType];
-      const _filteredOrmType = ormType[formik.values.type].ormTypes.map((e: any) => ({ label: e, value: e }))
-
-      const suggestionData: any = _filteredOrmType.filter((t: any) => t.label.toLowerCase().startsWith(query.toLowerCase()));
-      return suggestionData
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      return []
-    }
-  };
-
-
-
-
-  const searchRelationModelModuleNames = async (event: any) => {
-    try {
-      const query = event.query;
-      const queryData = {
-        limit: 10,
-        offset: 0,
-        filters: {
-          name: {
-            $containsi: query,
-          },
-        },
-      };
-
-      const queryString = qs.stringify(queryData, {
-        encodeValuesOnly: true,
-      });
-
-      const result = await triggerGetModules(queryString).unwrap(); // Unwrap to access the data
-
-      if (result && result.records) {
-        const updatedSuggestion = [...result.records];
-        return updatedSuggestion
-      } else {
-        return []
-      }
-    } catch (error) {
-      return []
-    }
-  };
-
-  const searchrelationCoModelSingularNames = async (event: any) => {
-    try {
-      const query = event.query;
-      const queryData: any = {
-        limit: 10,
-        offset: 0,
-        filters: {
-          module: {
-            name: {
-              $containsi: formik.values.relationModelModuleName
-            }
-          }
-        }
-      };
-      if (query) {
-        queryData.filters.singularName = {
-          $containsi: query,
-        };
-      }
-      const queryString = qs.stringify(queryData, {
-        encodeValuesOnly: true,
-      });
-
-      const result = await triggerGetModels(queryString).unwrap(); // Unwrap to access the data
-
-      if (result && result.records) {
-        const updatedSuggestion = [...result.records];
-        return updatedSuggestion
-      } else {
-        return []
-      }
-    } catch (error) {
-      return []
-    }
-  };
-
-  const searchUserKeyField = () => {
-    return userKeyData;
-  }
-
-  const searchComputedFieldValueType = async (event: any) => {
-    const query = event.query;
-    try {
-
-      const _filteredTypes: any = fieldDefaultMetaData.data.computedFieldValueTypes.filter((t: any) => t.label.toLowerCase().startsWith(query.toLowerCase()));
-
-      setFilteredComputedFieldValueTypes(_filteredTypes);
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      setFilteredComputedFieldValueTypes([]);
-    }
-  };
-
-
-
-  const searchSelectionDynamicProvider = async (event: any) => {
-    const query = event.query;
-    try {
-      const filterredData: any = fieldDefaultMetaData.data.selectionDynamicProviders.filter((t: any) => t.provider.toLowerCase().startsWith(query.toLowerCase()));
-      const transformedData = filterredData.map((e: any) => ({ label: e.provider, value: e.provider, help: e.help }));
-      return transformedData
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      return []
-    }
-  };
-
-
-
-  const searchComputedProvider = async (event: any) => {
-    const query = event.query;
-    try {
-      const filterredData: any = fieldDefaultMetaData.data.computedProviders.filter((t: any) => t.provider.toLowerCase().startsWith(query.toLowerCase()));
-      const transformedData = filterredData.map((e: any) => ({ label: e.provider, value: e.provider, help: e.help }));
-      return transformedData
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      return []
-    }
-  };
-
-  const searchExternalIdProvider = async (event: any) => {
-    const query = event.query;
-    try {
-      const filterredData: any = fieldDefaultMetaData.data.externalIdProviders.filter((t: any) => t.provider.toLowerCase().startsWith(query.toLowerCase()));
-      const transformedData = filterredData.map((e: any) => ({ label: e.provider, value: e.provider, help: e.help }));
-      return transformedData
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      return []
-    }
-  };
-
-
-
-  const searchSelectionEncryptionType = async (event: any) => {
-    const query = event.query;
-    try {
-
-      const _filteredTypes: any = fieldDefaultMetaData.data.encryptionTypes.filter((t: any) => t.label.toLowerCase().startsWith(query.toLowerCase()));
-
-      setFilteredSelectionEncryptionType(_filteredTypes);
-      return _filteredTypes
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      setFilteredSelectionEncryptionType([]);
-      return []
-    }
-  };
-
-  const searchSelectionDecryptWhen = async (event: any) => {
-    const query = event.query;
-    try {
-
-      const _filteredTypes: any = fieldDefaultMetaData.data.decryptWhenTypes.filter((t: any) => t.label.toLowerCase().startsWith(query.toLowerCase()));
-
-      setFilteredSelectionDecryptWhen(_filteredTypes);
-      return _filteredTypes
-    } catch (error) {
-      console.error("Error fetching items:", error);
-      setFilteredSelectionDecryptWhen([]);
-      return []
-    }
-  };
-
-
-  const isFormFieldValid = (formik: any, fieldName: string) => {
-    return formik.touched[fieldName] && formik.errors[fieldName];
-  };
-
-
-  const mediaStorageProviderId = [
-    { label: "mediaStorageProviderId", value: "mediaStorageProviderId" },
-    { label: "id2", value: "2" },
-  ];
-
-  const selctionValueTypes = [
-    { label: "String", value: "string" },
-    { label: "Int", value: "int" },
-  ];
-
-
-  const relationCreateInverses = [
-    { label: "True", value: "true" },
-    { label: "False", value: "false" },
-  ];
-
-  const [selectedPasswordPolicy, setSelectedPasswordPolicy] = useState<any>(fieldMetaData?.regexPattern);
-  const passwordPolicyOptions = [
-    { label: 'Lowercase and Uppercase Alphabets Required', value: '^(?=.*[a-z])(?=.*[A-Z]).*$' },
-    { label: 'Lowercase and Uppercase Alphabets and Numbers Required', value: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).*$' },
-    { label: 'Lowercase and Uppercase Alphabets, Numbers, and Special Characters Required', value: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&]).*$' },
-    { label: 'custom', value: 'custom' },
-
-  ];
-
-  const mediaTypesOptions = [
-    { label: 'Image (Supports JPEG, PNG, WEBP, etc.)', value: 'image' },
-    { label: 'Audio (Supports MP3, WAV, AAC, etc.)', value: 'audio' },
-    { label: 'Video (Supports MP4, AVI, MKV, etc.)', value: 'video' },
-    { label: 'File (Supports PDF, DOCX, TXT, etc.)', value: 'file' }
-  ];
-
-
-  const initialValues = {
-    name: fieldMetaData ? fieldMetaData?.name : null,
-    displayName: fieldMetaData ? fieldMetaData?.displayName : null,
-    description: fieldMetaData ? fieldMetaData?.description : null,
-    type: fieldMetaData ? fieldMetaData?.type : null,
-    ormType: fieldMetaData ? fieldMetaData?.ormType : null,
-    length: fieldMetaData ? fieldMetaData?.length : null,
-    defaultValue: fieldMetaData ? fieldMetaData?.defaultValue : null,
-    regexPattern: fieldMetaData ? fieldMetaData?.regexPattern : null,
-    regexPatternNotMatchingErrorMsg: fieldMetaData ? fieldMetaData?.regexPatternNotMatchingErrorMsg : "",
-    required: fieldMetaData ? fieldMetaData?.required : false,
-    unique: fieldMetaData ? fieldMetaData?.unique : false,
-    encrypt: fieldMetaData ? fieldMetaData?.encrypt : false,
-    encryptionType: fieldMetaData ? fieldMetaData?.encryptionType : null,
-    decryptWhen: fieldMetaData ? fieldMetaData?.decryptWhen : null,
-    index: fieldMetaData ? fieldMetaData?.index : false,
-    min: fieldMetaData ? fieldMetaData?.min : null,
-    max: fieldMetaData ? fieldMetaData?.max : null,
-    private: fieldMetaData ? fieldMetaData?.private : false,
-    mediaTypes: fieldMetaData ? fieldMetaData?.mediaTypes : null,
-    mediaMaxSizeKb: fieldMetaData ? fieldMetaData?.mediaMaxSizeKb : null,
-    mediaStorageProviderId: fieldMetaData ? fieldMetaData?.mediaStorageProvider?.id : null,
-    mediaStorageProvider: fieldMetaData ? fieldMetaData?.mediaStorageProvider : null,
-    mediaEmbedded: fieldMetaData ? (fieldMetaData?.mediaEmbedded && fieldMetaData?.mediaEmbedded.toString()) : "true",
-    relationType: fieldMetaData ? fieldMetaData?.relationType : null,
-    relationCoModelSingularName: fieldMetaData ? fieldMetaData?.relationCoModelSingularName : null,
-    relationCoModelFieldName: fieldMetaData ? fieldMetaData?.relationCoModelFieldName : null,
-    relationCreateInverse: fieldMetaData ? fieldMetaData?.relationCreateInverse : false,
-    relationCascade: fieldMetaData ? fieldMetaData?.relationCascade : 'cascade',
-    relationModelModuleName: fieldMetaData ? fieldMetaData?.relationModelModuleName : modelMetaData?.module.name,
-    relationFieldFixedFilter: fieldMetaData ? fieldMetaData?.relationFieldFixedFilter : "",
-    selectionDynamicProvider: fieldMetaData ? fieldMetaData?.selectionDynamicProvider : null,
-    selectionDynamicProviderCtxt: fieldMetaData ? fieldMetaData?.selectionDynamicProviderCtxt : "",
-    selectionStaticValues: fieldMetaData ? fieldMetaData?.selectionStaticValues : [""],
-    selectionValueType: fieldMetaData ? fieldMetaData?.selectionValueType : null,
-    computedFieldValueProvider: fieldMetaData ? fieldMetaData?.computedFieldValueProvider : null,
-    computedFieldValueType: fieldMetaData ? fieldMetaData?.computedFieldValueType : null,
-    computedFieldValueProviderCtxt: fieldMetaData ? fieldMetaData?.computedFieldValueProviderCtxt : "",
-    // externalIdProvider: fieldMetaData ? fieldMetaData?.externalIdProvider : null,
-    // externalIdProviderCtxt: fieldMetaData ? fieldMetaData?.externalIdProviderCtxt : "",
-    isSystem: fieldMetaData ? fieldMetaData?.isSystem : false,
-    columnName: fieldMetaData ? fieldMetaData?.columnName : null,
-    isUserKey: fieldMetaData ? fieldMetaData?.isUserKey : false,
-    relationCoModelColumnName: fieldMetaData ? fieldMetaData?.relationCoModelColumnName : null,
-    relationJoinTableName: fieldMetaData ? fieldMetaData?.relationJoinTableName : null,
-    userKey: fieldMetaData ? fieldMetaData?.userKey : null
-  };
-
-
-  const formik = useFormik({
-    initialValues,
-    validationSchema,
-    enableReinitialize: true,
-    onSubmit: async (values) => {
-      try {
-        setFieldMetaData((prevItems: any) => {
-          const newFieldData = { ...values, isSystem: values.isSystem == true ? true : '' }
-          const formtatedFieldPayload = fieldBasedPayloadFormating(newFieldData, currentFields, fieldMetaData);
-          const existingIndex = prevItems.findIndex((item: any) => item.identifier === formtatedFieldPayload.identifier);
-          if (existingIndex !== -1) {
-            const updatedItems = [...prevItems];
-            updatedItems[existingIndex] = formtatedFieldPayload;
-            return updatedItems
-          }
-          else {
-            if (params?.id !== 'new' && formtatedFieldPayload?.required && !formtatedFieldPayload?.defaultValue) {
-              setIsRequiredPopUp(true);
-            }
-            return [...prevItems, formtatedFieldPayload]
-          }
-        });
-        if (values.userKey) {
-          const data = {
-            modelName: values.relationCoModelSingularName,
-            fieldName: values.userKey
-          }
-          updateUserKey(data);
-        }
-        // nextTab()
-        setVisiblePopup(false);
-
-      } catch (err) {
-        console.error("Failed to create Radix Model:", err);
-      }
-    },
-    validateOnBlur: false // Disable validation on blur
-
-
-
-  });
-
-  const showError = async () => {
-    const errors = await formik.validateForm(); // Trigger validation and get the updated errors
-    const errorMessages = Object.values(errors);
-
-
-    if (errorMessages.length > 0) {
-      toast?.current?.show({
-        severity: "error",
-        summary: "Can you send me the report?",
-        // sticky: true,
-        life: 3000,
-        //@ts-ignore
-        content: (props) => (
-          <div
-            className="flex flex-column align-items-left"
-            style={{ flex: "1" }}
-          >
-            {errorMessages.map((m, index) => (
-              <div className="flex align-items-center gap-2" key={index}>
-                <span className="font-bold text-900">{String(m)}</span>
-              </div>
-            ))}
-          </div>
-        ),
-      });
-    }
-  };
-
-  useEffect(() => {
-    if (isUpdateUserKeySuccess) {
-      showToaster([newModel?.data?.message], "success");
-    } if (isUpdateUserKeyError) {
-      showToaster(UpdateUserKeyError, 'error')
-    }
-  }, [isUpdateUserKeySuccess, isUpdateUserKeyError])
-
-  const handleTypeSelect = (e: any, label: string) => {
-
-    setShowTypeFilter(false);
-    setSelectedType({ label: label, value: e });
-    formik.setFieldValue("type", e);
-    if (e == "email") {
-      formik.setFieldValue("regexPattern", "^[a-zA-Z0-9. _%+-]+@[a-zA-Z0-9. -]+\\. [a-zA-Z]{2,}$");
-    } else {
-      formik.setFieldValue("regexPattern", "");
-    }
-    const ormType = fieldDefaultMetaData.data.ormType[modelMetaData?.dataSourceType];
-    const availableOrmTypes = ormType[e];
-    // setFilteredOrmTypes(availableOrmTypes.ormTypes.map((e: any) => ({
-    //   label: e,
-    //   value: e,
-    // })));
-    // setSelectedOrmType({ label: availableOrmTypes.ormTypes[0], value: availableOrmTypes.ormTypes[0] });
-    setOrmTypeOptions(availableOrmTypes.ormTypes)
-    formik.setFieldValue("ormType", availableOrmTypes.ormTypes[0].label);
-    setSelectedOrmType(availableOrmTypes.ormTypes[0].label)
-    setCurrentFields(
-      fetchCurrentFields(e, fieldDefaultMetaData)
-    );
-    // setTypeSelected(true);
-  }
-
-
-  useEffect((() => {
-    setOrmTypeOptions(fieldDefaultMetaData && formik.values.type && fieldDefaultMetaData.data.ormType[modelMetaData?.dataSourceType][formik.values.type].ormTypes);
-  }), [formik])
-
-
-  useEffect(() => {
-    if (fieldMetaData && fieldMetaData.columnName) {
-      setShowColumnName(true)
-    }
-  }, [fieldMetaData])
-
-  useEffect(() => {
-    const fetchFields = async () => {
-      const queryData: any = {
-        limit: 100,
-        offset: 0,
-        filters: {
-          singularName: {
-            $eq: formik.values.relationCoModelSingularName
-          }
-        },
-        populate: ['fields']
-      };
-      const queryString = qs.stringify(queryData, {
-        encodeValuesOnly: true,
-      });
-      const result = await triggerGetModels(queryString).unwrap();
-
-      if (result && result.records) {
-        if (!result?.records[0]?.userKeyField) {
-          setUserKeyFields(true);
-          const validUserKeyFields = result?.records[0]?.fields?.filter(
-            (field: any) => field?.unique === true && field?.type === 'shortText'
-          );
-          setUserKeyData(validUserKeyFields)
-        } else {
-          setUserKeyFields(false);
-          setUserKeyData([]);
-        }
-      }
-    }
-    if (formik.values.relationCoModelSingularName) {
-      fetchFields();
-    }
-  }, [formik.values.relationCoModelSingularName])
-
-  const updateEnumValues = (index: number, updatedString: string) => {
-    const updatedValues = formik.values.selectionStaticValues.map((enumValue: string, i: number) =>
-      i === index ? updatedString : enumValue
-    );
-    formik.setFieldValue("selectionStaticValues", updatedValues);
-  };
-
-  const addEnumValue = () => {
-    formik.setFieldValue("selectionStaticValues", [...formik.values.selectionStaticValues, ":"]);
-  };
-
-  const deleteEnumValue = (index: number) => {
-    if (formik.values.selectionStaticValues.length > 1) {
-      const updatedRows = formik.values.selectionStaticValues.filter((_: string, rowIndex: number) => rowIndex !== index);
-      formik.setFieldValue("selectionStaticValues", updatedRows);
-    } else {
-
-    }
-  };
-
-  useEffect(() => {
-    if (formik.dirty) {
-      setIsDirty(true);
-    }
-  }, [formik.dirty]);
-
-  return (
-    <div>
-      <Toast ref={toast} />
-      <div>
-        <form onSubmit={formik.handleSubmit}>
-          <div className="solid-field-metadata-form-header">
-            {pathname.includes('create') ?
-              <>
-                <div className="flex align-items-center gap-3">
-                  {showTypeFilter === false ?
-                    <>
-                      <Button
-                        text
-                        icon='pi pi-arrow-left'
-                        size="small"
-                        type="button"
-                        aria-label="Back"
-                        className='max-w-2rem bg-primary-reverse text-color'
-                        onClick={() => {
-                          if (!formik.values.displayName) {
-                            setShowTypeFilter(true)
-                          } else {
-                            setIsBackPopupVisible(true)
-                          }
-                        }
-                        }
-                      />
-                      <div className="form-wrapper-title text-base">{capitalize(modelMetaData?.displayName)}</div>
-                    </>
-                    :
-                    <div className="flex text-2xl font-bold align-items-center ml-4" style={{ color: '#000' }}>
-                      <div className="form-wrapper-title text-base">Model - {capitalize(modelMetaData?.displayName)}</div>
-                    </div>
-                  }
-                </div>
-                <div className="flex align-items-center gap-3 close-popup">
-                  <Button icon="pi pi-times" rounded text aria-label="Cancel" type="reset" size="small" onClick={() => setVisiblePopup(false)}
-                    className='max-w-2rem bg-primary-reverse text-color' />
-                </div>
-              </>
-              :
-              <>
-                <div className="flex align-items-center gap-3">
-                  {!fieldMetaData?.id &&
-                    <Button
-                      text
-                      icon='pi pi-arrow-left'
-                      size="small"
-                      type="button"
-                      aria-label="Back"
-                      className='max-w-2rem bg-primary-reverse text-color'
-                      onClick={() => {
-                        if (!formik.values.displayName) {
-                          setShowTypeFilter(true)
-                        } else {
-                          setIsBackPopupVisible(true)
-                        }
-                      }
-                      } />
-                  }
-                  {fieldMetaData ?
-
-                    <div className="form-wrapper-title text-base">Edit {capitalize(fieldMetaData?.displayName)}</div>
-                    :
-                    <div className="form-wrapper-title text-base">Add New {selectedType?.label && !showTypeFilter && capitalize(selectedType.label)} Field to {capitalize(modelMetaData?.displayName)}</div>
-                  }
-                </div>
-                <div className="flex align-items-center gap-3 close-popup">
-                  <Button icon="pi pi-times" text aria-label="Cancel" type="reset" size="small" onClick={() => setVisiblePopup(false)}
-                    className='max-w-2rem bg-primary-reverse text-color'
-                  />
-                </div>
-              </>
-            }
-          </div>
-          {showTypeFilter === true ?
-            <FieldSelector
-              handleTypeSelect={handleTypeSelect}
-              modelMetaData={modelMetaData}
-            ></FieldSelector>
-            :
-            <div className="p-4" style={{ maxHeight: '80vh', overflowY: 'auto', overflowX: 'hidden' }}>
-              <div className="p-d-flex p-jc-center creat-field-for form-dem">
-                <div className="p-fluid" style={{ position: 'relative' }}>
-                  {/* <div className="mb-3">
-                    <div className="form-wrapper-title">{fieldMetaData ? `Edit ${capitalize(selectedType.label)} Field` : `Add a new ${capitalize(selectedType.label)} Field`}</div>
-                  </div> */}
-                  <TabView panelContainerClassName="px-0">
-                    <TabPanel
-                      header="Basic Info"
-                      className={(formik.touched.hasOwnProperty("name") && formik.errors.hasOwnProperty("name")) || (formik.touched.hasOwnProperty("displayName") && formik.errors.hasOwnProperty("displayName")) || (formik.touched.hasOwnProperty("displayName") && formik.errors.hasOwnProperty("ormType")) ? "tab-error-heading" : ""}
-                    // rightIcon="pi pi-info-circle ml-2"
-                    >
-                      <div className="formgrid grid">
-                        {currentFields.includes("displayName") && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-2">
-                            <label htmlFor="displayName" className="form-field-label">
-                              Display Name
-                            </label>
-                            <InputText
-                              type="text"
-                              disabled={fieldMetaData?.id}
-                              id="displayName"
-                              name="displayName"
-                              onChange={(e) => {
-                                formik.setFieldValue("displayName", e.target.value);
-                                const { toCamelCase, toSnakeCase, toPluralCamelCase } = getSingularAndPlural(e.target.value);
-                                formik.setFieldValue("name", toCamelCase);
-                                if (showColumnName) {
-                                  formik.setFieldValue("columnName", toSnakeCase);
-                                }
-
-                              }}
-                              value={formik.values.displayName}
-                              className={classNames("", {
-                                "p-invalid": isFormFieldValid(
-                                  formik,
-                                  "displayName"
-                                ),
-                              })}
-                            />
-                            {isFormFieldValid(formik, "displayName") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.displayName?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-
-
-                        {currentFields.includes("name") && (
-                          <div className="field col-6 flex-flex-column gap-2">
-                            <label htmlFor="name" className="form-field-label">
-                              Name
-                            </label>
-                            <InputText
-                              disabled={fieldMetaData?.id}
-                              type="text"
-                              id="name"
-                              name="name"
-                              onChange={formik.handleChange}
-                              value={formik.values.name}
-                              className={classNames("", {
-                                "p-invalid": isFormFieldValid(formik, "name"),
-                              })}
-                            />
-                            {isFormFieldValid(formik, "name") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.name?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {currentFields.includes("description") && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-4">
-                            <label htmlFor="description" className="form-field-label">
-                              Description
-                            </label>
-                            <InputTextarea
-                              aria-describedby="Description of your field"
-                              id="description"
-                              name="description"
-                              onChange={formik.handleChange}
-                              value={formik.values.description}
-                              rows={5}
-                              cols={30}
-                              className={classNames("", {
-                                "p-invalid": isFormFieldValid(
-                                  formik,
-                                  "description"
-                                ),
-                              })}
-                            />
-                            {isFormFieldValid(formik, "description") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.description?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-
-                        {currentFields.includes("columnName") && (
-                          <div className="field col-6 mt-4">
-                            <div className="flex align-items-center gap-2">
-                              <Checkbox onChange={e => {
-                                setShowColumnName(e.checked);
-                                if (e.checked === true) {
-                                  const { toCamelCase, toSnakeCase, toPluralCamelCase } = getSingularAndPlural(formik.values.displayName);
-                                  if (pathname.includes('create')) {
-                                    formik.setFieldValue("columnName", toSnakeCase);
-                                  }
-                                } else {
-                                  formik.setFieldValue("columnName", null);
-                                }
-
-                              }} checked={showColumnName} disabled={fieldMetaData?.id}></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label">
-                                Set Column Name
-                              </label>
-                            </div>
-                            {showColumnName &&
-                              <div className="field col-12 flex-flex-column gap-2 mt-4">
-                                <label htmlFor="columnName" className="form-field-label">
-                                  Column Name
-                                </label>
-                                <InputText
-                                  disabled={fieldMetaData?.id}
-                                  type="text"
-                                  id="columnName"
-                                  name="columnName"
-                                  onChange={formik.handleChange}
-                                  value={formik.values.columnName}
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(formik, "columnName"),
-                                  })}
-                                />
-                                {isFormFieldValid(formik, "columnName") && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.columnName?.toString()}
-                                  />
-                                )}
-                              </div>
-                            }
-                          </div>
-                        )}
-
-
-                        {/* {currentFields.includes("type") && (
-                          <div className="md:col-6 sm:col-12">
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label htmlFor="type" className="form-field-label">
-                                Type
-                              </label>
-                              <AutoComplete
-                                value={selectedType}
-                                suggestions={filteredTypes}
-                                invalid={isFormFieldValid(formik, "type")}
-                                completeMethod={searchTypes}
-                                virtualScrollerOptions={{ itemSize: 38 }}
-                                field="label"
-                                className="small-input"
-                                dropdown
-                                onChange={(e) => {
-                                  formik.setFieldTouched('type', true); // Manually mark as touched
-                                  setSelectedType(e.value);
-                                  formik.setFieldValue("type", e.value.value);
-                                  if (e.value.value == "email") {
-                                    formik.setFieldValue("regexPattern", "/^[a-zA-Z0-9. _%+-]+@[a-zA-Z0-9. -]+\\. [a-zA-Z]{2,}$/");
-                                  } else {
-                                    formik.setFieldValue("regexPattern", "");
-                                  }
-                                  const _filteredOrmType: any = fieldDefaultMetaData.data.ormType.filter((t: any) => t.solidType == e.value.value);
-                                  setSelectedOrmType(_filteredOrmType[0].value)
-                                  formik.setFieldValue("ormType", _filteredOrmType[0].value);
-
-                                  setCurrentFields(
-                                    fetchCurrentFields(e.value.value, fieldDefaultMetaData)
-                                  );
-                                }}
-
-
-                              />
-
-                              {isFormFieldValid(formik, "type") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.type?.toString()}
-                                />
-                              )}
-                            </div>
-                          </div>
-                        )} */}
-
-                      </div>
-
-                    </TabPanel>
-
-                    <TabPanel header="Advance Config"
-
-                    //  rightIcon="pi pi-cog ml-2"
-                    >
-                      {formik?.values?.type?.length > 0 && (
-                        <div className="formgrid grid">
-                          {currentFields.includes("length") && (
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label htmlFor="length" className="form-field-label">
-                                Length
-                              </label>
-                              <InputNumber
-                                // type="text"
-                                id="length"
-                                name="length"
-                                onValueChange={formik.handleChange}
-                                value={formik.values.length}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "length"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "length") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.length?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-                          {currentFields.includes("defaultValue") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="defaultValue"
-                                className="form-field-label"
-                              >
-                                Default Value
-                              </label>
-                              {/* <InputText
-                                type="text"
-                                id="defaultValue"
-                                name="defaultValue"
-                                onChange={formik.handleChange}
-                                value={formik.values.defaultValue}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "defaultValue"
-                                  ),
-                                })}
-                              /> */}
-                              {(selectedType.value === "shortText" || selectedType.value === "longText" || selectedType.value === "richText" || selectedType.value === "json" || selectedType.value === "password" || selectedType.value === "selectionStatic") &&
-                                <InputText
-                                  type="text"
-                                  id="defaultValue"
-                                  name="defaultValue"
-                                  onChange={formik.handleChange}
-                                  value={formik.values.defaultValue}
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(
-                                      formik,
-                                      "defaultValue"
-                                    ),
-                                  })}
-                                />
-                              }
-                              {(selectedType.value === "float" || selectedType.value === "decimal") &&
-                                <InputNumber
-                                  id="defaultValue"
-                                  name="defaultValue"
-                                  minFractionDigits={2}
-                                  maxFractionDigits={5}
-                                  value={formik.values.defaultValue}
-                                  onValueChange={(e) => formik.setFieldValue("defaultValue", e.value)}  // Ensure correct value change handling
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(formik, "defaultValue"),
-                                  })}
-                                />
-                              }
-                              {(selectedType.value === "int" || selectedType.value === "bigint") &&
-                                <InputNumber
-                                  id="defaultValue"
-                                  name="defaultValue"
-                                  value={formik.values.defaultValue}
-                                  onValueChange={(e) => formik.setFieldValue("defaultValue", e.value)}  // Ensure correct value change handling
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(formik, "defaultValue"),
-                                  })}
-                                />
-                              }
-                              {selectedType.value === "boolean" &&
-                                <SelectButton
-                                  value={formik.values.defaultValue ? formik.values.defaultValue : "false"}
-                                  onChange={(e) => formik.setFieldValue("defaultValue", e.value)} // Custom handling for boolean input
-                                  options={booleanOptions}
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(formik, "defaultValue"),
-                                  })}
-                                />
-                              }
-                              {(selectedType.value === "date" || selectedType.value === "datetime" || selectedType.value === "time") &&
-                                <Calendar
-                                  id="defaultValue"
-                                  name="defaultValue"
-                                  value={formik.values.defaultValue ? new Date(formik.values.defaultValue) : null}
-                                  onChange={(e) => formik.setFieldValue("defaultValue", e.value)} // Use setFieldValue for proper handling
-                                  showTime={formik.values.type === "datetime"}  // Show time picker for datetime
-                                  timeOnly={formik.values.type === "time"}      // Time-only for time
-                                  dateFormat="yy-mm-dd"
-                                  hourFormat="24"                             // 24-hour format for time
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(formik, "defaultValue"),
-                                  })}
-                                />
-                              }
-                              {isFormFieldValid(formik, "defaultValue") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.defaultValue?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("mediaTypes") && (
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label
-                                htmlFor="mediaTypes"
-                                className="form-field-label"
-                              >
-                                Media Type
-                              </label>
-                              {/* <MultipleSelectAutoCompleteField
-                                  key="mediaTypes"
-                                  formik={formik}
-                                  isFormFieldValid={isFormFieldValid}
-                                  fieldName="mediaTypes"
-                                  fieldNameId="mediaTypes"
-                                  labelKey="label"
-                                  valueKey="value"
-                                  searchData={searchMediaTypes}
-                                  existingData={formik.values.mediaTypes}
-                                /> */}
-
-                              {/* {selectedType.value === "mediaSingle" &&
-                                  <SingleSelectAutoCompleteField
-                                    key="mediaTypes"
-                                    formik={formik}
-                                    isFormFieldValid={isFormFieldValid}
-                                    fieldName="mediaTypes"
-                                    fieldNameId="mediaTypes"
-                                    labelKey="label"
-                                    valueKey="value"
-                                    searchData={searchMediaTypes}
-                                    existingData={formik.values.mediaTypes}
-                                  />
-                                } */}
-
-                              {isFormFieldValid(formik, "mediaTypes") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.mediaTypes?.toString()}
-                                />
-                              )}
-                              <MultiSelect value={formik.values.mediaTypes} onChange={(e) => formik.setFieldValue("mediaTypes", e.value)} options={mediaTypesOptions} optionLabel="label"
-                                placeholder="Select Media Types" maxSelectedLabels={3} display="chip" className="" />
-
-
-                              {/* <Dropdown
-                                  id="mediaTypes"
-                                  name="mediaTypes"
-                                  multiple
-                                  value={formik.values.mediaTypes}
-                                  options={fieldDefaultMetaData.data.mediaTypes}
-                                  onChange={(e) =>
-                                    formik.setFieldValue("mediaTypes", e.value)
-                                  }
-                                  placeholder="Select a Media Type"
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(
-                                      formik,
-                                      "mediaTypes"
-                                    ),
-                                  })}
-                                /> */}
-
-
-                            </div>
-                          )}
-                          {currentFields.includes("mediaMaxSizeKb") && (
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label
-                                htmlFor="mediaMaxSizeKb"
-                                className="form-field-label"
-                              >
-                                Media Max Size (Mb)
-                              </label>
-                              <InputNumber
-                                id="mediaMaxSizeKb"
-                                name="mediaMaxSizeKb"
-                                onValueChange={formik.handleChange}
-                                value={formik.values.mediaMaxSizeKb}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "mediaMaxSizeKb"
-                                  ),
-                                })}
-                              />
-
-                              {isFormFieldValid(formik, "mediaMaxSizeKb") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.mediaMaxSizeKb?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-                          {currentFields.includes("mediaStorageProviderId") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="mediaStorageProviderId"
-                                className="form-field-label"
-                              >
-                                Media  Storage Provider
-                              </label>
-
-                              <SingleSelectAutoCompleteField
-                                key="mediaStorageProviderId"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                relationField={true}
-                                fieldName="mediaStorageProvider"
-                                fieldNameId="mediaStorageProviderId"
-                                labelKey="name"
-                                valueKey="value"
-                                searchData={searchMediaStorageProvIderId}
-                                existingData={formik.values.mediaStorageProvider}
-                              />
-
-                              {isFormFieldValid(
-                                formik,
-                                "mediaStorageProvider"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.mediaStorageProviderId?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("mediaEmbedded") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="mediaEmbedded"
-                                className="form-field-label"
-                              >
-                                Media Embedded
-                              </label>
-                              {/* <InputText
-                                type="text"
-                                id="mediaEmbedded"
-                                name="mediaEmbedded"
-                                onChange={formik.handleChange}
-                                value={formik.values.mediaEmbedded}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "mediaEmbedded"
-                                  ),
-                                })}
-                              /> */}
-                              <SelectButton
-                                value={formik.values.mediaEmbedded}
-                                // onChange={formik.handleChange}
-                                onChange={(e) => {
-                                  formik.setFieldValue("mediaEmbedded", e.value);
-                                }}
-                                options={booleanOptions}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "mediaEmbedded"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "mediaEmbedded") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.mediaEmbedded?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-                          {currentFields.includes("relationType") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              {/* <label
-                                  htmlFor="relationType"
-                                  className="form-field-label"
-                                >
-                                  Relation Type
-                                </label>
-                                <Dropdown
-                                  id="relationType"
-                                  name="relationType"
-                                  value={formik.values.relationType}
-                                  options={fieldDefaultMetaData.data.relationTypes}
-                                  onChange={(e) =>
-                                    formik.setFieldValue("relationType", e.value)
-                                  }
-                                  placeholder="Select a Data Source"
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(
-                                      formik,
-                                      "relationType"
-                                    ),
-                                  })}
-                                /> */}
-
-                              <label
-                                htmlFor="relationType"
-                                className="form-field-label "
-                              >
-                                Relation Type
-                              </label>
-                              <SelectButton
-                                value={formik.values.relationType}
-                                options={fieldDefaultMetaData.data.relationTypes}
-                                onChange={(e) => {
-                                  formik.setFieldValue("relationType", e.value);
-                                  if (e.value === "one-to-many") {
-                                    formik.setFieldValue("relationCreateInverse", true);
-                                  }
-                                }
-                                }
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(formik, "relationType"),
-                                })}
-                                optionLabel="label"
-                              />
-
-                              {/* <div className="align-items-center">
-                                  <div className="flex mt-3">
-                                    {fieldDefaultMetaData?.data?.relationTypes.map((i: any) => (
-                                      <div key={i.value} className="mr-3">
-                                        <RadioButton
-                                          inputId="ingredient1"
-                                          name="pizza"
-                                          value={i.value}
-                                          onChange={(e) => formik.setFieldValue("relationType", e.value)}
-                                          checked={formik.values.relationType === i.value}
-                                        />
-                                        <label htmlFor="ingredient1" className="form-field-label ml-2">{i.value}</label>
-                                      </div>
-                                    ))}
-                                  </div>
-                                </div> */}
-
-                              {isFormFieldValid(formik, "relationType") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.relationType?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-                          {currentFields.includes("relationType") && formik.values.relationType === "many-to-one" && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="relationCascade"
-                                className="form-field-label"
-                              >
-                                Relation Cascade
-                              </label>
-                              <Dropdown
-                                id="relationCascade"
-                                name="relationCascade"
-                                value={formik.values.relationCascade}
-                                options={fieldDefaultMetaData.data.cascadeTypes}
-                                onChange={(e) =>
-                                  formik.setFieldValue(
-                                    "relationCascade",
-                                    e.value
-                                  )
-                                }
-                                placeholder="Cascade"
-                                className={classNames("w-full", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "relationCascade"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "relationCascade") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.relationCascade?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("relationModelModuleName") && (
-                            <div className="field col-6 flex-flex-column gap-2  mt-3">
-                              <label
-                                htmlFor="relationModelModuleName"
-                                className="form-field-label"
-                              >
-                                Co-Module Name
-                              </label>
-
-                              <SingleSelectAutoCompleteField
-                                key="relationModelModuleName"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                fieldName="relationModelModuleName"
-                                fieldNameId="relationModelModuleName"
-                                labelKey="name"
-                                valueKey="name"
-                                searchData={searchRelationModelModuleNames}
-                                existingData={formik.values.relationModelModuleName}
-                                additionalAction={(e: any) => {
-                                  formik.setFieldValue("relationCoModelSingularName", "");
-                                  formik.setFieldValue("relationCoModelColumnName", "");
-                                  formik.setFieldValue("relationJoinTableName", "");
-                                }}
-                              />
-
-                              {/* <AutoComplete
-                                  value={selectedRelationModelModuleName}
-                                  suggestions={filteredRelationModelModuleNames}
-                                  invalid={isFormFieldValid(
-                                    formik,
-                                    "relationModelModuleName"
-                                  )}
-                                  completeMethod={searchRelationModelModuleNames}
-                                  virtualScrollerOptions={{ itemSize: 38 }}
-                                  field="label"
-                                  className="small-input"
-                                  dropdown
-                                  onChange={(e) => {
-                                    setSelectedRelationModelModuleName(e.value);
-                                    formik.setFieldValue(
-                                      "relationModelModuleName",
-                                      e.value
-                                    );
-                                  }}
-                                /> */}
-
-                              {isFormFieldValid(
-                                formik,
-                                "relationModelModuleName"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.relationModelModuleName?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-
-                          {currentFields.includes(
-                            "relationCoModelSingularName"
-                          ) && (
-                              <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                <label
-                                  htmlFor="relationCoModelSingularName"
-                                  className="form-field-label"
-                                >
-                                  Co-Model Name
-                                </label>
-
-
-                                <SingleSelectAutoCompleteField
-                                  key="relationCoModelSingularName"
-                                  formik={formik}
-                                  isFormFieldValid={isFormFieldValid}
-                                  fieldName="relationCoModelSingularName"
-                                  fieldNameId="relationCoModelSingularName"
-                                  labelKey="displayName"
-                                  valueKey="singularName"
-                                  searchData={searchrelationCoModelSingularNames}
-                                  existingData={formik.values.relationCoModelSingularName}
-                                />
-                                {isFormFieldValid(
-                                  formik,
-                                  "relationCoModelSingularName"
-                                ) && (
-                                    <Message
-                                      severity="error"
-                                      text={formik?.errors?.relationCoModelSingularName?.toString()}
-                                    />
-                                  )}
-                              </div>
-                            )}
-
-                          {currentFields.includes(
-                            "relationFieldFixedFilter"
-                          ) && (
-                              <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                <label
-                                  htmlFor="relationFieldFixedFilter"
-                                  className="form-field-label"
-                                >
-                                  Relation Field Fixed Filter
-                                </label>
-
-                                <InputTextarea
-                                  aria-describedby="Fixed Filter"
-                                  id="relationFieldFixedFilter"
-                                  name="relationFieldFixedFilter"
-                                  onChange={formik.handleChange}
-                                  value={formik.values.relationFieldFixedFilter}
-                                  rows={5}
-                                  cols={30}
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(
-                                      formik,
-                                      "relationFieldFixedFilter"
-                                    ),
-                                  })}
-                                />
-                                {/* 
-                                <InputText
-                                  type="text"
-                                  id="relationFieldFixedFilter"
-                                  name="relationFieldFixedFilter"
-                                  onChange={formik.handleChange}
-                                  disabled={fieldMetaData?.id}
-                                  value={formik.values.relationFieldFixedFilter}
-                                  className={classNames("", {
-                                    "p-invalid": isFormFieldValid(
-                                      formik,
-                                      "relationFieldFixedFilter"
-                                    ),
-                                  })}
-                                /> */}
-                                {isFormFieldValid(formik, "relationFieldFixedFilter") && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.relationFieldFixedFilter?.toString()}
-                                  />
-                                )}
-
-                              </div>
-                            )}
-                          {isUserKeyFields && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="userKey"
-                                className="form-field-label"
-                              >
-                                Set User Key
-                              </label>
-
-
-                              <SingleSelectAutoCompleteField
-                                key="userKey"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                fieldName="userKey"
-                                fieldNameId="userKey"
-                                labelKey="displayName"
-                                valueKey="name"
-                                searchData={searchUserKeyField}
-                                existingData={formik.values.userKey}
-                              />
-                              {isFormFieldValid(
-                                formik,
-                                "userKey"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.userKey?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("relationCreateInverse") && (
-                            <div className="field col-6 flex flex-column gap-2 mt-3">
-                              <label htmlFor="relationCreateInverse" className="form-field-label">
-                                Relation Create Inverse
-                              </label>
-                              <div className="flex align-items-center">
-                                <Checkbox
-                                  inputId="relationCreateInverse"
-                                  name="relationCreateInverse"
-                                  checked={formik.values.relationCreateInverse}
-                                  disabled={formik.values.relationType === "one-to-many" ? true : false}
-                                  onChange={(e) => formik.setFieldValue("relationCreateInverse", e.checked)}
-                                />
-                                <label htmlFor="relationCreateInverse" className="ml-2">Create Inverse</label>
-                              </div>
-                              {isFormFieldValid(formik, "relationCreateInverse") && (
-                                <Message severity="error" text={formik?.errors?.relationCreateInverse?.toString()} />
-                              )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("relationCoModelFieldName") && formik.values.relationCreateInverse  && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="relationCoModelFieldName"
-                                className="form-field-label"
-                              >
-                                Relation Co-Model Field Name
-                              </label>
-                              <InputText
-                                type="text"
-                                id="relationCoModelFieldName"
-                                name="relationCoModelFieldName"
-                                onChange={formik.handleChange}
-                                disabled={fieldMetaData?.id}
-                                value={formik.values.relationCoModelFieldName}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "relationCoModelFieldName"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "relationCoModelFieldName") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.relationCoModelFieldName?.toString()}
-                                />
-                              )}
-
-                            </div>
-                          )}
-
-                          {/* {currentFields.includes("joinColumnName") && formik.values.relationType === "many-to-many" && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="joinColumnName"
-                                className="form-field-label"
-                              >
-                                Join Column Name
-                              </label>
-                              <InputText
-                                type="text"
-                                id="joinColumnName"
-                                name="joinColumnName"
-                                onChange={formik.handleChange}
-                                value={formik.values.joinColumnName}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "joinColumnName"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "joinColumnName") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.joinColumnName?.toString()}
-                                />
-                              )}
-
-                            </div>
-                          )} */}
-
-                          {currentFields.includes("relationCoModelColumnName") && formik.values.relationCreateInverse && (formik.values.relationType === "many-to-many" || formik.values.relationType === "many-to-one") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="relationCoModelColumnName"
-                                className="form-field-label"
-                              >
-                                Relation Co-Model Column Name
-                              </label>
-                              <InputText
-                                type="text"
-                                id="relationCoModelColumnName"
-                                name="relationCoModelColumnName"
-                                onChange={formik.handleChange}
-                                disabled={fieldMetaData?.id}
-                                value={formik.values.relationCoModelColumnName}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "relationCoModelColumnName"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "relationCoModelColumnName") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.relationCoModelColumnName?.toString()}
-                                />
-                              )}
-
-                            </div>
-                          )}
-
-                          {currentFields.includes("relationJoinTableName") && formik.values.relationType === "many-to-many" && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="relationJoinTableName"
-                                className="form-field-label"
-                              >
-                                Relation Join Table Name
-                              </label>
-                              <InputText
-                                type="text"
-                                id="relationJoinTableName"
-                                name="relationJoinTableName"
-                                onChange={formik.handleChange}
-                                disabled={fieldMetaData?.id}
-                                value={formik.values.relationJoinTableName}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "relationJoinTableName"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(formik, "relationJoinTableName") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.relationJoinTableName?.toString()}
-                                />
-                              )}
-
-                            </div>
-                          )}
-
-                          {currentFields.includes("selectionDynamicProvider") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="selectionDynamicProvider"
-                                className="form-field-label"
-                              >
-                                Selection Dynamic Provider
-                              </label>
-
-                              <SingleSelectAutoCompleteField
-                                key="selectionDynamicProvider"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                // relationField={false}
-                                fieldName="selectionDynamicProvider"
-                                fieldNameId={null}
-                                labelKey="label"
-                                valueKey="value"
-                                searchData={searchSelectionDynamicProvider}
-                                existingData={formik.values.selectionDynamicProvider}
-                                additionalAction={(e: any) => setMarkdownText(e.target.value.help)}
-                              />
-
-
-                              {/* <AutoComplete
-                                  value={selectionDynamicProvider}
-                                  suggestions={filteredSelectionDynamicProvider}
-                                  invalid={isFormFieldValid(
-                                    formik,
-                                    "selectionDynamicProvider"
-                                  )}
-                                  completeMethod={searchSelectionDynamicProvider}
-                                  virtualScrollerOptions={{ itemSize: 38 }}
-                                  field="label"
-                                  className="small-input"
-                                  dropdown
-                                  onChange={(e) => {
-                                    setSelectionDynamicProvider(e.value);
-                                    formik.setFieldValue(
-                                      "selectionDynamicProvider",
-                                      e.value.value
-                                    );
-                                  }}
-                                /> */}
-
-                              {isFormFieldValid(
-                                formik,
-                                "selectionDynamicProvider"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.selectionDynamicProvider?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-                          {currentFields.includes("selectionValueType") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="selectionValueType"
-                                className="form-field-label"
-                              >
-                                Select Value Type
-                              </label>
-                              <Dropdown
-                                id="selectionValueType"
-                                name="selectionValueType"
-                                value={formik.values.selectionValueType}
-                                options={selctionValueTypes}
-                                onChange={(e) =>
-                                  formik.setFieldValue(
-                                    "selectionValueType",
-                                    e.value
-                                  )
-                                }
-                                placeholder="Select Value Type"
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "selectionValueType"
-                                  ),
-                                })}
-                              />
-                              {isFormFieldValid(
-                                formik,
-                                "selectionValueType"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.selectionValueType?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-
-                          {currentFields.includes("selectionStaticValues") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="selectionStaticValues"
-                                className="form-field-label"
-                              >
-                                Selection Static Values
-                              </label>
-                              {/* <InputTextarea
-                                  value={selectionStaticValues}
-                                  placeholder="male:Male"
-                                  onChange={(e) => {
-                                    const data = e.target.value
-                                      .split("\n")
-                                      .filter((line) => line.trim() !== "");
-
-                                    setSelectionStaticValues(e.target.value);
-                                    formik.setFieldValue(
-                                      "selectionStaticValues",
-                                      data
-                                    );
-                                  }}
-                                  rows={5}
-                                  cols={30}
-                                /> */}
-                              {formik.values.selectionStaticValues.map((enumValue: string, index: number) => (
-                                <SelectionStaticValues
-                                  key={index}
-                                  enumValue={enumValue}
-                                  onUpdate={(updatedString: any) => updateEnumValues(index, updatedString)}
-                                  onDelete={() => deleteEnumValue(index)}
-                                  onAdd={addEnumValue}
-                                />
-                              ))
-                              }
-                              {isFormFieldValid(
-                                formik,
-                                "selectionStaticValues"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.selectionStaticValues?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-                          {currentFields.includes("computedFieldValueType") && (
-                            <div className="field col-6 flex-flex-column gap-2 mt-3">
-                              <label
-                                htmlFor="computedFieldValueType"
-                                className="form-field-label"
-                              >
-                                Computed Field Value Type
-                              </label>
-                              <AutoComplete
-
-                                value={selectedComputedFieldValueType}
-                                invalid={isFormFieldValid(formik, "computedFieldValueType")}
-                                suggestions={filteredComputedFieldValueTypes}
-                                completeMethod={searchComputedFieldValueType}
-                                virtualScrollerOptions={{ itemSize: 38 }}
-                                field="label"
-                                dropdown
-                                className="solid-standard-autocomplete"
-                                onChange={(e) => {
-                                  setSelectedComputedFieldValueType(e.value);
-                                  formik.setFieldValue("computedFieldValueType", e.value.value);
-                                }}
-                              />
-
-                              {/* <Dropdown
-                                id="mediaTypes"
-                                name="mediaTypes"
-                                value={formik.values.mediaTypes}
-                                options={fieldDefaultMetaData.data.mediaTypes}
-                                onChange={(e) =>
-                                  formik.setFieldValue("mediaTypes", e.value)
-                                }
-                                placeholder="Select a Data Source"
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(
-                                    formik,
-                                    "mediaTypes"
-                                  ),
-                                })}
-                              /> */}
-                              {isFormFieldValid(formik, "computedFieldValueType") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.computedFieldValueType?.toString()}
-                                />
-                              )}
-                            </div>
-                          )}
-
-                          {currentFields.includes(
-                            "computedFieldValueProvider"
-                          ) && (
-                              <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                <label
-                                  htmlFor="computedFieldValueProvider"
-                                  className="form-field-label"
-                                >
-                                  Computed Field Provider
-                                </label>
-
-                                <SingleSelectAutoCompleteField
-                                  key="computedFieldValueProvider"
-                                  formik={formik}
-                                  isFormFieldValid={isFormFieldValid}
-                                  // relationField={false}
-                                  fieldName="computedFieldValueProvider"
-                                  fieldNameId={null}
-                                  labelKey="label"
-                                  valueKey="value"
-                                  searchData={searchComputedProvider}
-                                  existingData={formik.values.computedFieldValueProvider}
-                                  additionalAction={(e: any) => setMarkdownText(e.target.value.help)}
-
-                                />
-                                {/* <InputText
-                                    type="text"
-                                    id="computedFieldValueProvider"
-                                    name="computedFieldValueProvider"
-                                    onChange={formik.handleChange}
-                                    value={formik.values.computedFieldValueProvider}
-                                    className={classNames("", {
-                                      "p-invalid": isFormFieldValid(
-                                        formik,
-                                        "computedFieldValueProvider"
-                                      ),
-                                    })}
-                                  /> */}
-                                {isFormFieldValid(
-                                  formik,
-                                  "computedFieldValueProvider"
-                                ) && (
-                                    <Message
-                                      severity="error"
-                                      text={formik?.errors?.computedFieldValueProvider?.toString()}
-                                    />
-                                  )}
-                              </div>
-                            )}
-                          {/* {currentFields.includes("externalIdProvider") && (
-                            <div className="md:col-6 sm:col-12">
-                              <div className="field col-6 flex-flex-column gap-2">
-                                <label
-                                  htmlFor="externalIdProvider"
-                                  className="form-field-label"
-                                >
-                                  External Id Provider
-                                </label>
-                                <SingleSelectAutoCompleteField
-                                  key="externalIdProvider"
-                                  formik={formik}
-                                  isFormFieldValid={isFormFieldValid}
-                                  // relationField={false}
-                                  fieldName="externalIdProvider"
-                                  fieldNameId={null}
-                                  labelKey="label"
-                                  valueKey="value"
-                                  searchData={searchExternalIdProvider}
-                                  existingData={formik.values.externalIdProvider}
-                                  additionalAction={(e: any) => setMarkdownText(e.target.value.help)}
-                                />
-                               
-
-                                {isFormFieldValid(
-                                  formik,
-                                  "externalIdProvider"
-                                ) && (
-                                    <Message
-                                      severity="error"
-                                      text={formik?.errors?.externalIdProvider?.toString()}
-                                    />
-                                  )}
-                              </div>
-                            </div>
-                          )} */}
-
-                          {currentFields.includes("selectionDynamicProviderCtxt") && (
-                            // {/* {markdownText &&
-                            //       <div className="md:col-12 sm:col-12">
-                            //         <div className="field col-6 flex-flex-column gap-2">
-                            //           <label htmlFor="name" className="form-field-label">
-                            //             Markdown
-                            //           </label>
-                            //           <MarkdownViewer data={markdownText}></MarkdownViewer>
-                            //         </div>
-                            //       </div>
-                            //     } */}
-
-                            <div className="field col-12 flex-flex-column gap-2 mt-4">
-                              <label htmlFor="selectionDynamicProviderCtxt" className="form-field-label">
-                                Selection Dynamic Provider Context
-                              </label>
-                              <CodeEditor
-                                formik={formik}
-                                field="selectionDynamicProviderCtxt" >
-                              </CodeEditor>
-                              <div className=" form-field-label  mt-4">{markdownText}</div>
-
-                              {isFormFieldValid(
-                                formik,
-                                "selectionDynamicProviderCtxt"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.selectionDynamicProviderCtxt?.toString()}
-                                  />
-                                )}
-                            </div>
-                            // {/* {currentFields.includes("markdown") && ( */}
-
-                          )}
-
-                          {currentFields.includes("computedFieldValueProviderCtxt") && (
-                            <div className="field col-12 flex-flex-column gap-2 mt-4">
-                              <label htmlFor="computedFieldValueProviderCtxt" className="form-field-label">
-                                Computed Field Value Provider Context
-                              </label>
-                              <CodeEditor
-                                formik={formik}
-                                field="computedFieldValueProviderCtxt" >
-                              </CodeEditor>
-                              <div className="form-field-label mt-4">{markdownText}</div>
-
-                              {isFormFieldValid(
-                                formik,
-                                "computedFieldValueProviderCtxt"
-                              ) && (
-                                  <Message
-                                    severity="error"
-                                    text={formik?.errors?.computedFieldValueProviderCtxt?.toString()}
-                                  />
-                                )}
-                            </div>
-                          )}
-
-                          {/* {currentFields.includes("externalIdProviderCtxt") && (
-                            <div className="md:col-12 sm:col-12">
-
-                              <div className="formgrid grid">
-                                {markdownText &&
-                                  <div className="md:col-12 sm:col-12">
-                                    <div className="field col-6 flex-flex-column gap-2">
-                                      <label htmlFor="name" className="form-field-label">
-                                        Markdown
-                                      </label>
-                                      <MarkdownViewer data={markdownText}></MarkdownViewer>
-                                    </div>
-                                  </div>
-                                }
-                                <div className="md:col-12 sm:col-12">
-                                  <div className="field col-6 flex-flex-column gap-2">
-                                    <label htmlFor="name" className="form-field-label">
-                                      External Id Provider Context
-                                    </label>
-                                    <CodeEditor
-                                      formik={formik}
-                                      field="externalIdProviderCtxt" >
-                                    </CodeEditor>
-                                    {isFormFieldValid(
-                                      formik,
-                                      "externalIdProviderCtxt"
-                                    ) && (
-                                        <Message
-                                          severity="error"
-                                          text={formik?.errors?.externalIdProviderCtxt?.toString()}
-                                        />
-                                      )}
-                                  </div>
-                                </div>
-
-                              </div>
-                            </div>
-                          )} */}
-
-                        </div>
-                      )}
-                      {(currentFields.includes("regexPattern") || currentFields.includes("min") || currentFields.includes("max") || currentFields.includes("ormType")) && ormTypeOptions && selectedType.value !== 'relation' &&
-                        <>
-                          <p className="form-wrapper-heading text-base mt-3">Validations</p>
-                          <div className="formgrid grid">
-                            {(currentFields.includes("regexPattern") && selectedType.value === "password") &&
-                              <>
-                                <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                  <label
-                                    htmlFor="regexPattern"
-                                    className="form-field-label"
-                                  >
-                                    Password Policy
-                                  </label>
-                                  <Dropdown value={selectedPasswordPolicy} onChange={(e: DropdownChangeEvent) => {
-                                    setSelectedPasswordPolicy(e.value)
-                                    if (e.value !== "custom") {
-                                      formik.setFieldValue('regexPattern', e.value)
-                                    }
-                                  }} options={passwordPolicyOptions} optionLabel="label"
-                                    placeholder="Select a Password Policy"
-                                    // className="w-full md:w-14rem"
-                                    className=""
-                                    checkmark={true} highlightOnSelect={false} />
-
-                                </div>
-                              </>
-                            }
-                            {currentFields.includes("regexPattern") && (
-                              <>
-                                <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                  <label
-                                    htmlFor="regexPattern"
-                                    className="form-field-label"
-                                  >
-                                    Regex Pattern
-                                  </label>
-                                  <InputText
-                                    type="text"
-                                    id="regexPattern"
-                                    name="regexPattern"
-                                    onChange={formik.handleChange}
-                                    value={formik.values.regexPattern}
-                                    className={classNames("", {
-                                      "p-invalid": isFormFieldValid(
-                                        formik,
-                                        "regexPattern"
-                                      ),
-                                    })}
-                                  />
-                                  {isFormFieldValid(formik, "regexPattern") && (
-                                    <Message
-                                      severity="error"
-                                      text={formik?.errors?.regexPattern?.toString()}
-                                    />
-                                  )}
-                                </div>
-                                {currentFields.includes("regexPattern") && (
-                                  <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                    <label
-                                      htmlFor="regexPatternNotMatchingErrorMsg"
-                                      className="form-field-label"
-                                    >
-                                      Regex Pattern Not Matching Error Msg
-                                    </label>
-                                    <InputText
-                                      type="text"
-                                      id="regexPatternNotMatchingErrorMsg"
-                                      name="regexPatternNotMatchingErrorMsg"
-                                      onChange={formik.handleChange}
-                                      value={formik.values.regexPatternNotMatchingErrorMsg}
-                                      className={classNames("", {
-                                        "p-invalid": isFormFieldValid(
-                                          formik,
-                                          "regexPatternNotMatchingErrorMsg"
-                                        ),
-                                      })}
-                                    />
-                                    {isFormFieldValid(formik, "regexPatternNotMatchingErrorMsg") && (
-                                      <Message
-                                        severity="error"
-                                        text={formik?.errors?.regexPatternNotMatchingErrorMsg?.toString()}
-                                      />
-                                    )}
-                                  </div>
-                                )}
-                              </>
-
-                            )}
-                            {(currentFields.includes("min") || currentFields.includes("max")) &&
-                              <>
-                                {currentFields.includes("min") && (
-                                  <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                    <label htmlFor="min" className="form-field-label">
-                                      Min {(selectedType.value !== "int" && selectedType.value !== "decimal") && `(Characters Allowed)`}
-
-                                    </label>
-                                    {/* <InputText
-                                type="text"
-                                id="min"
-                                name="min"
-                                onChange={formik.handleChange}
-                                value={formik.values.min}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(formik, "min"),
-                                })}
-                              /> */}
-                                    {/* <RenderMinValueInput></RenderMinValueInput> */}
-                                    {(selectedType.value === "int" ||
-                                      selectedType.value === "decimal" ||
-                                      selectedType.value === "shortText" ||
-                                      selectedType.value === "decimal" ||
-                                      selectedType.value === "longText" ||
-                                      selectedType.value === "richText" ||
-                                      selectedType.value === "password" ||
-                                      selectedType.value === "json") &&
-                                      <InputNumber
-                                        id="min"
-                                        name="min"
-                                        onValueChange={formik.handleChange}
-                                        value={formik.values.min}
-                                        className={classNames("", {
-                                          "p-invalid": isFormFieldValid(
-                                            formik,
-                                            "min"
-                                          ),
-                                        })}
-                                        disabled={fieldMetaData?.id}
-                                      />
-                                    }
-
-                                    {isFormFieldValid(formik, "min") && (
-                                      <Message
-                                        severity="error"
-                                        text={formik?.errors?.min?.toString()}
-                                      />
-                                    )}
-                                  </div>
-                                )}
-                                {currentFields.includes("max") && (
-                                  <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                    <label htmlFor="max" className="form-field-label">
-                                      Max {(selectedType.value !== "int" &&
-                                        selectedType.value !== "decimal") && `(Characters allowed)`}
-                                    </label>
-                                    {/* <InputText
-                                type="text"
-                                id="max"
-                                name="max"
-                                onChange={formik.handleChange}
-                                value={formik.values.max}
-                                className={classNames("", {
-                                  "p-invalid": isFormFieldValid(formik, "max"),
-                                })}
-                              /> */}
-                                    {(selectedType.value === "int" ||
-                                      selectedType.value === "decimal" ||
-                                      selectedType.value === "shortText" ||
-                                      selectedType.value === "decimal" ||
-                                      selectedType.value === "longText" ||
-                                      selectedType.value === "richText" ||
-                                      selectedType.value === "password" ||
-                                      selectedType.value === "json") &&
-                                      <InputNumber
-                                        id="max"
-                                        name="max"
-                                        onValueChange={formik.handleChange}
-                                        value={formik.values.max}
-                                        className={classNames("", {
-                                          "p-invalid": isFormFieldValid(
-                                            formik,
-                                            "max"
-                                          ),
-                                        })}
-                                        disabled={fieldMetaData?.id}
-                                      />
-                                    }
-
-                                    {isFormFieldValid(formik, "max") && (
-                                      <Message
-                                        severity="error"
-                                        text={formik?.errors?.max?.toString()}
-                                      />
-                                    )}
-                                  </div>
-                                )}
-                              </>
-                            }
-                            {currentFields.includes("ormType") && (
-                              <div className="md:col-12 sm:col-12">
-                                {ormTypeOptions && ormTypeOptions.length > 1 &&
-                                  <div className="field col-6 flex-flex-column gap-2 mt-3">
-                                    <label htmlFor="ormType" className="form-field-label">
-                                      Type
-                                    </label>
-                                    {/* <SingleSelectAutoCompleteField
-                                key="ormType"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                fieldName="ormType"
-                                fieldNameId="ormType"
-                                labelKey="label"
-                                valueKey="value"
-                                searchData={searchOrmTypes}
-                                existingData={formik.values.ormType}
-                              /> */}
-
-                                    <div className="ormTypeflex">
-                                      {ormTypeOptions && ormTypeOptions.map((ormType: any) => {
-                                        return (
-                                          <>
-                                            <div key={ormType.key} className="mr-3 align-items-center">
-                                              <RadioButton inputId={ormType.label} name="ormType" value={ormType.label} onChange={(e) => {
-                                                formik.setFieldValue("ormType", e.value);
-                                                setSelectedOrmType(e.value)
-                                              }} checked={selectedOrmType === ormType.label} />
-                                              <label htmlFor={ormType.label} className="ml-2">{ormType.label}<br></br>
-                                                <span className="ml-4 fieldSubTitle">{ormType.description}</span>
-                                              </label>
-                                            </div>
-
-                                          </>
-                                        );
-                                      })}
-
-                                    </div>
-
-                                    {isFormFieldValid(formik, "ormType") && (
-                                      <Message
-                                        severity="error"
-                                        text={formik?.errors?.ormType?.toString()}
-                                      />
-                                    )}
-                                  </div>
-                                }
-
-                              </div>
-                            )}
-                          </div>
-                        </>
-                      }
-
-                      {(formik.values.relationType !== "many-to-many" && formik.values.relationType !== "one-to-many") && <p className="form-wrapper-heading text-base">Settings</p>}
-                      <div className="formgrid grid">
-                        {currentFields.includes("required") && (formik.values.relationType !== "many-to-many" && formik.values.relationType !== "one-to-many") && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-3">
-                            <div className="flex align-items-center">
-                              <Checkbox
-                                name="required"
-                                onChange={(e) => {
-                                  formik.setFieldValue("required", e.checked);
-                                }}
-                                checked={formik.values.required}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label ml-2">
-                                Required
-                              </label>
-                            </div>
-                            <p className="text-xs mt-2">You won't be able to create an entry if this field is empty</p>
-
-                            {isFormFieldValid(formik, "required") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.required?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {currentFields.includes("unique") && selectedType.value !== 'relation' && (
-                          <div className="field col-6 flex-flex-column gap-2">
-                            <div className="flex align-items-center">
-                              <Checkbox
-                                name="unique"
-                                onChange={(e) => {
-                                  formik.setFieldValue("unique", e.checked);
-                                  formik.setFieldValue("isUserKey", false);
-                                }}
-                                checked={formik.values.unique}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label ml-2">
-                                Unique
-                              </label>
-                            </div>
-                            <p className="text-xs mt-2">You won't be able to create an entry if there is an existing entry with identical content</p>
-
-                            {isFormFieldValid(formik, "unique") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.unique?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {currentFields.includes("index") && selectedType.value !== 'relation' && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-3">
-                            <div className="flex align-items-center">
-                              <Checkbox
-                                name="index"
-                                onChange={(e) => {
-                                  formik.setFieldValue("index", e.checked);
-                                }}
-                                checked={formik.values.index}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label ml-2">
-                                Index
-                              </label>
-                            </div>
-                            {isFormFieldValid(formik, "index") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.index?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {currentFields.includes("private") && selectedType.value !== 'relation' && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-3">
-                            <div className="flex align-items-center">
-                              <Checkbox
-                                name="private"
-                                onChange={(e) => {
-                                  formik.setFieldValue("private", e.checked);
-                                }}
-                                checked={formik.values.private}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label ml-2">
-                                Private
-                              </label>
-                            </div>
-                            <p className="text-xs mt-2">This field will not show up in the API response</p>
-
-
-                            {isFormFieldValid(formik, "private") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.private?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {currentFields.includes("encrypt") && selectedType.value !== 'relation' && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-3">
-                            <div className="flex align-items-center gap-2">
-                              <Checkbox
-                                name="encrypt"
-                                onChange={(e) => {
-                                  formik.setFieldValue("encrypt", e.checked);
-                                  setEncryptState(e.checked);
-                                }}
-                                checked={formik.values.encrypt}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label">
-                                Encrypt
-                              </label>
-                            </div>
-                            {isFormFieldValid(formik, "encrypt") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.encrypt?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                        {/* {currentFields.includes("isSystem") && (
-                          <div className="md:col-6 sm:col-12">
-                            <div className="field">
-                              <div className="flex align-items-center">
-                                <Checkbox
-                                  name="isSystem"
-                                  onChange={(e) => {
-                                    formik.setFieldValue("isSystem", e.checked);
-                                  }}
-                                  checked={formik.values.isSystem}
-                                ></Checkbox>
-                                <label htmlFor="ingredient1" className="form-field-label">
-                                  isSystem
-                                </label>
-                              </div>
-                              {isFormFieldValid(formik, "isSystem") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.isSystem?.toString()}
-                                />
-                              )}
-                            </div>
-                          </div>
-                        )} */}
-                        {currentFields.includes("isUserKey") && formik.values.unique && (
-                          <div className="field col-6 flex-flex-column gap-2 mt-3">
-                            <div className="flex align-items-center gap-2">
-                              <Checkbox
-                                name="isUserKey"
-                                onChange={(e) => {
-                                  formik.setFieldValue("isUserKey", e.checked);
-                                }}
-                                checked={formik.values.isUserKey}
-                              ></Checkbox>
-                              <label htmlFor="ingredient1" className="form-field-label">
-                                Is Userkey
-                              </label>
-                            </div>
-                            <p className="fieldSubTitle">By selecting this option, you are setting this field as the model's user key. Any existing user key configuration will be overwritten</p>
-
-                            {isFormFieldValid(formik, "isUserKey") && (
-                              <Message
-                                severity="error"
-                                text={formik?.errors?.isUserKey?.toString()}
-                              />
-                            )}
-                          </div>
-                        )}
-                      </div>
-
-
-                      {formik.values.encrypt === true && (
-                        <div className="formgrid grid mt-2">
-                          <div className="md:col-6 sm:col-12">
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label
-                                htmlFor="encryptionType"
-                                className="form-field-label"
-                              >
-                                Encryption Type
-                              </label>
-                              {/* <AutoComplete
-                                value={selectedEncryptionType}
-                                suggestions={filteredSelectionEncryptionType}
-                                invalid={isFormFieldValid(
-                                  formik,
-                                  "encryptionType"
-                                )}
-                                completeMethod={searchSelectionEncryptionType}
-                                virtualScrollerOptions={{ itemSize: 38 }}
-                                field="label"
-                                className="small-input"
-                                dropdown
-                                onChange={(e) => {
-                                  setSelectedEncryptionType(e.value);
-                                  formik.setFieldValue("encryptionType", e.value.value);
-                                }}
-                              /> */}
-
-                              <SingleSelectAutoCompleteField
-                                key="encryptionType"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                fieldName="encryptionType"
-                                fieldNameId="encryptionType"
-                                labelKey="label"
-                                valueKey="value"
-                                searchData={searchSelectionEncryptionType}
-                                existingData={formik.values.encryptionType}
-                              />
-                              {isFormFieldValid(formik, "encryptionType") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.encryptionType?.toString()}
-                                />
-                              )}
-                            </div>
-                          </div>
-                          <div className="md:col-6 sm:col-12">
-                            <div className="field col-6 flex-flex-column gap-2">
-                              <label htmlFor="decryptWhen" className="form-field-label">
-                                Decrypt When
-                              </label>
-                              {/* <AutoComplete
-                                value={selectedDecryptWhen}
-                                suggestions={filteredSelectionDecryptWhen}
-                                invalid={isFormFieldValid(formik, "decryptWhen")}
-                                completeMethod={searchSelectionDecryptWhen}
-                                virtualScrollerOptions={{ itemSize: 38 }}
-                                field="label"
-                                className="small-input"
-                                dropdown
-                                onChange={(e) => {
-                                  setSelectedeDecryptWhen(e.value);
-                                  formik.setFieldValue("decryptWhen", e.value.value);
-                                }}
-                              /> */}
-
-                              <SingleSelectAutoCompleteField
-                                key="decryptWhen"
-                                formik={formik}
-                                isFormFieldValid={isFormFieldValid}
-                                fieldName="decryptWhen"
-                                fieldNameId="decryptWhen"
-                                labelKey="label"
-                                valueKey="value"
-                                searchData={searchSelectionDecryptWhen}
-                                existingData={formik.values.decryptWhen}
-                              />
-                              {isFormFieldValid(formik, "decryptWhen") && (
-                                <Message
-                                  severity="error"
-                                  text={formik?.errors?.decryptWhen?.toString()}
-                                />
-                              )}
-                            </div>
-                          </div>
-                        </div>
-                      )}
-                    </TabPanel>
-                  </TabView>
-                  <div className="flex gap-3">
-                    <div>
-                      <Button label="Finish" size="small" onClick={() => showError()} type="submit" />
-                    </div>
-                    <div>
-                      <Button label="Cancel" size="small" severity="secondary" type="reset" onClick={() => setVisiblePopup(false)} outlined />
-                    </div>
-                  </div>
-                </div>
-                {/* <div className="ml-4">
-                  <Button
-                    label="Save"
-                    onClick={() => showError(formik.validateForm)}
-                    type="submit"
-                  />
-                </div> */}
-              </div>
-            </div>
-          }
-
-        </form>
-      </div >
-      <Dialog
-        visible={isBackPopupVisible}
-        header="Select Type"
-        headerClassName="text-center"
-        modal
-        footer={() => (
-          <div className="flex gap-3">
-            <Button label="Yes" icon="pi pi-check" size="small" type="reset" severity="danger" autoFocus onClick={() => {
-              formik.resetForm()
-              setIsBackPopupVisible(false);
-              setShowTypeFilter(true);
-            }} />
-            <Button label="No" icon="pi pi-times" size="small" onClick={() => setIsBackPopupVisible(false)} />
-          </div>
-        )}
-        onHide={() => setIsBackPopupVisible(false)}
-      >
-        <p>You have some unsaved data are you sure  you want to go back?</p>
-      </Dialog>
-    </div >
-  );
-};
-
-
-export default FieldMetaDataForm;