itube-specs 0.0.764 → 0.0.766

package/composables/{use-fetch-categories-by-letter.ts → fetch/use-fetch-categories-by-letter.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { ICategoryCard } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { ICategoryCard } from '../../types';
 
 export const useFetchCategoriesByLetter = async (
     apiMethod: (...args: any[]) => Promise<Array<ICategoryCard>>
 ) => {
-    const key = EAsyncData.CategoriesByLetter;
-    const lang = useLang() as ELanguage;
+    const key = AsyncData.CategoriesByLetter;
+    const lang = useLang() as Language;
     const slug = useSlug();
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 

package/composables/{use-fetch-categories-by-name.ts → fetch/use-fetch-categories-by-name.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { ICardInfo } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { ICardInfo } from '../../types';
 
 export const useFetchCategoriesByName = async (
   apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-    const key = EAsyncData.CategoriesByName;
-    const lang = useLang() as ELanguage;
+    const key = AsyncData.CategoriesByName;
+    const lang = useLang() as Language;
     const slug = useSlug();
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 

package/composables/{use-fetch-categories-by-phrase.ts → fetch/use-fetch-categories-by-phrase.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IChipsItem } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IChipsItem } from '../../types';
 
 export const useFetchCategoriesByPhrase = async (
     apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>
 ) => {
-    const key = EAsyncData.CategoriesByPhrase;
-    const lang = useLang() as ELanguage;
+    const key = AsyncData.CategoriesByPhrase;
+    const lang = useLang() as Language;
     const slug = useSlug();
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 

package/composables/{use-fetch-categories-group-by-letter.ts → fetch/use-fetch-categories-group-by-letter.ts}

@@ -1,11 +1,11 @@
-import type { EAsyncData, ELanguage } from '../runtime';
-import type { ICategoryCard, IChipsItem } from '../types';
+import type { AsyncData, Language } from '../../runtime';
+import type { ICategoryCard, IChipsItem } from '../../types';
 
 export const useFetchCategoriesGroupByLetter = async (
-    key: EAsyncData,
+    key: AsyncData,
     apiMethod: (...args: any[]) => Promise<Record<string, Array<ICategoryCard>>> | Promise<IChipsItem[]>
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, error, refresh, status } = await useAsyncData<Record<string, Array<ICategoryCard>> | IChipsItem[]>(

package/composables/{use-fetch-categories-related.ts → fetch/use-fetch-categories-related.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IRelatedPhrases } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IRelatedPhrases } from '../../types';
 
 export const useFetchCategoriesRelated = async (
   apiMethod: (...args: any[]) => Promise<IRelatedPhrases>
 ) => {
-  const lang = useLang() as ELanguage;
+  const lang = useLang() as Language;
   const slug = useSlug();
-  const key = EAsyncData.CategoriesRelated;
+  const key = AsyncData.CategoriesRelated;
   const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
   const { data, status, error } = await useAsyncData<IRelatedPhrases>(

package/composables/{use-fetch-channels-by-model.ts → fetch/use-fetch-channels-by-model.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IChannelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IChannelCard, PaginatedResponse } from '../../types';
 
 export const useFetchChannelsByModel = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = EAsyncData.ChannelsByModel;
+    const key = AsyncData.ChannelsByModel;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(

package/composables/{use-fetch-channels-by-name.ts → fetch/use-fetch-channels-by-name.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { ICardInfo } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { ICardInfo } from '../../types';
 
 export const useFetchChannelsByName = async (
     apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug('channel');
-    const key = EAsyncData.ChannelByName;
+    const key = AsyncData.ChannelByName;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<ICardInfo>(

package/composables/{use-fetch-channels-by-network-name.ts → fetch/use-fetch-channels-by-network-name.ts}

@@ -1,17 +1,17 @@
 import { useRoute } from 'vue-router';
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IChannelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IChannelCard, PaginatedResponse } from '../../types';
 
 export const useFetchChannelsByNetworkName = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
     const slug = useSlug('channel');
-    const key = EAsyncData.ChannelsByNetworkName;
+    const key = AsyncData.ChannelsByNetworkName;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(

package/composables/{use-fetch-channels.ts → fetch/use-fetch-channels.ts}

@@ -1,8 +1,8 @@
 import { useRoute } from 'vue-router';
-import type { ELanguage } from '../runtime';
-import { EAsyncData, getSelectedQuery } from '../runtime';
-import { sortChannels } from '../lib';
-import type { IChannelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData, getSelectedQuery } from '../../runtime';
+import { sortChannels } from '../../lib';
+import type { IChannelCard, PaginatedResponse } from '../../types';
 
 export const useFetchChannels = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
@@ -10,8 +10,8 @@ export const useFetchChannels = async (
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.Channels;
+    const lang = useLang() as Language;
+    const key = AsyncData.Channels;
     const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(

package/composables/{use-fetch-dictionaries-countries.ts → fetch/use-fetch-dictionaries-countries.ts}

@@ -1,12 +1,12 @@
-import type { ICountries } from '../types';
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
+import type { ICountries } from '../../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
 
 export const useFetchDictionariesCountries = async (
     apiMethod: (...args: any[]) => Promise<ICountries>
 ) => {
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.Countries;
+    const lang = useLang() as Language;
+    const key = AsyncData.Countries;
     const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = await useAsyncData<ICountries>(

package/composables/{use-fetch-dictionaries-genders.ts → fetch/use-fetch-dictionaries-genders.ts}

@@ -1,12 +1,12 @@
-import type { IGenders } from '../types';
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
+import type { IGenders } from '../../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
 
 export const useFetchDictionariesGenders = async (
     apiMethod: (...args: any[]) => Promise<IGenders>
 ) => {
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.Genders;
+    const lang = useLang() as Language;
+    const key = AsyncData.Genders;
     const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = await useAsyncData<IGenders>(

package/composables/{use-fetch-footer-categories.ts → fetch/use-fetch-footer-categories.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IChipsItem } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IChipsItem } from '../../types';
 
 export const useFetchFooterCategories = async (
     apiMethod: (...args: any[]) => Promise<IChipsItem[]>
 ) => {
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.CategoriesTopRandomFooter;
+    const lang = useLang() as Language;
+    const key = AsyncData.CategoriesTopRandomFooter;
     const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = await useAsyncData<IChipsItem[]>(

package/composables/{use-fetch-groups-categories-lazy.ts → fetch/use-fetch-groups-categories-lazy.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import type { IGroupCategories } from '../types';
+import type { Language } from '../../runtime';
+import type { IGroupCategories } from '../../types';
 
 export const useFetchGroupsCategoriesLazy = (
     apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
 ) => {
     const data = useState<IGroupCategories[] | null>('lazy-groups-categories', () => null);
     const isLoading = useState<boolean>('lazy-groups-categories-loading', () => false);
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
 
     async function load() {
         if (data.value?.length || isLoading.value) return;

package/composables/{use-fetch-groups-categories.ts → fetch/use-fetch-groups-categories.ts}

@@ -1,12 +1,12 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IGroupCategories } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IGroupCategories } from '../../types';
 
 export const useFetchGroupsCategories = async (
     apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
 ) => {
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.GroupsCategoriesFilter;
+    const lang = useLang() as Language;
+    const key = AsyncData.GroupsCategoriesFilter;
     const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, pending: status, error } = await useAsyncData<IGroupCategories[]>(

package/composables/{use-fetch-model-by-name.ts → fetch/use-fetch-model-by-name.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { ICardInfo } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { ICardInfo } from '../../types';
 
 export const useFetchModelByName = async (
     apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = EAsyncData.ModelsByName;
+    const key = AsyncData.ModelsByName;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<ICardInfo>(

package/composables/{use-fetch-models-by-category.ts → fetch/use-fetch-models-by-category.ts}

@@ -1,14 +1,14 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModelsByCategory = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
     limit: number,
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = EAsyncData.ModelsByCategory;
+    const key = AsyncData.ModelsByCategory;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status } = await useAsyncData<PaginatedResponse<IModelCard>>(

package/composables/{use-fetch-models-by-channel.ts → fetch/use-fetch-models-by-channel.ts}

@@ -1,14 +1,14 @@
-import type { ELanguage } from '..runtime';
-import { EAsyncData } from '../runtime';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModelsByChannel = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
     limit: number,
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug('channel');
-    const key = EAsyncData.ModelsByChannel;
+    const key = AsyncData.ModelsByChannel;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status } = await useAsyncData<PaginatedResponse<IModelCard>>(

package/composables/{use-fetch-models-by-letter.ts → fetch/use-fetch-models-by-letter.ts}

@@ -1,8 +1,8 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData, getSelectedQuery } from '../runtime';
-import { sortModels } from '../lib';
+import type { Language } from '../../runtime';
+import { AsyncData, getSelectedQuery } from '../../runtime';
+import { sortModels } from '../../lib';
 import { useRoute } from 'vue-router';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModelsByLetter = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
@@ -11,8 +11,8 @@ export const useFetchModelsByLetter = async (
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
     const slug = useSlug();
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.ModelsByFirstLetter;
+    const lang = useLang() as Language;
+    const key = AsyncData.ModelsByFirstLetter;
     const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const filters = computed(() => Object.entries(route.query)

package/composables/{use-fetch-models-by-phrases.ts → fetch/use-fetch-models-by-phrases.ts}

@@ -1,6 +1,6 @@
-import type { ELanguage } from '../runtime';
-import { convertString, EAsyncData } from '../runtime';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { convertString, AsyncData } from '../../runtime';
+import type { IModelCard, PaginatedResponse } from '../../types';
 import { useRoute } from 'vue-router';
 
 export const useFetchModelsByPhrases = async (
@@ -9,9 +9,9 @@ export const useFetchModelsByPhrases = async (
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = EAsyncData.ModelsByPhrases;
+    const key = AsyncData.ModelsByPhrases;
     const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IModelCard>>(

package/composables/{use-fetch-models-by-tag.ts → fetch/use-fetch-models-by-tag.ts}

@@ -1,14 +1,14 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModelsByTag = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
     limit: number,
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug('tag');
-    const key = EAsyncData.ModelsByTag;
+    const key = AsyncData.ModelsByTag;
     const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status } = await useAsyncData<PaginatedResponse<IModelCard>>(

package/composables/{use-fetch-models-related.ts → fetch/use-fetch-models-related.ts}

@@ -1,15 +1,15 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchRelatedModels = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
     limit: number,
     cacheId: string
 ) => {
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = EAsyncData.TopModelsMore;
+    const key = AsyncData.TopModelsMore;
     const stateKey = computed(() => `data-${key}-${slug.value}-${cacheId}-${lang}`);
 
     const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(

package/composables/{use-fetch-models.ts → fetch/use-fetch-models.ts}

@@ -1,8 +1,8 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData, getSelectedQuery } from '../runtime';
-import { sortModels } from '../lib';
+import type { Language } from '../../runtime';
+import { AsyncData, getSelectedQuery } from '../../runtime';
+import { sortModels } from '../../lib';
 import { useRoute } from 'vue-router';
-import type { IModelCard, PaginatedResponse } from '../types';
+import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModels = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
@@ -10,8 +10,8 @@ export const useFetchModels = async (
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.Models;
+    const lang = useLang() as Language;
+    const key = AsyncData.Models;
     const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const filters = computed(() => Object.entries(route.query)

package/composables/{use-fetch-multi-suggest.ts → fetch/use-fetch-multi-suggest.ts}

@@ -1,6 +1,6 @@
-import type { ELanguage  } from '../runtime';
-import { EAsyncData  } from '../runtime';
-import type { IMultiSuggest } from '../types';
+import type { Language  } from '../../runtime';
+import { AsyncData  } from '../../runtime';
+import type { IMultiSuggest } from '../../types';
 import { useRoute } from 'vue-router';
 
 export async function useFetchMultiSuggest(
@@ -12,9 +12,9 @@ export async function useFetchMultiSuggest(
 ) {
     const route = useRoute();
     const searchValue = useState<string>('searchValue', () => '');
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const slug = useSlug();
-    const key = watchRoute ? EAsyncData.MultiSuggestRouteSearch : EAsyncData.MultiSuggestSearch;
+    const key = watchRoute ? AsyncData.MultiSuggestRouteSearch : AsyncData.MultiSuggestSearch;
     const stateKey = computed(() => `data-${key}-${watchRoute ? slug.value : searchValue.value}-${lang}`);
 
     const { data, status } = await useAsyncData<IMultiSuggest | null>(

package/composables/{use-fetch-playlists-by-id.ts → fetch/use-fetch-playlists-by-id.ts}

@@ -1,13 +1,13 @@
 import { useRoute } from 'vue-router';
-import { EAsyncData, type ELanguage } from '../runtime';
-import type { IPlaylistData } from '../types';
+import { AsyncData, type Language } from '../../runtime';
+import type { IPlaylistData } from '../../types';
 
 export const useFetchPlaylistsById = async (apiMethod: (...args: any[]) => Promise<IPlaylistData>) => {
     const route = useRoute();
     const id = computed(() => String(route.params['playlistId']));
-    const key = EAsyncData.PlaylistById;
+    const key = AsyncData.PlaylistById;
     const stateKey = computed(() => `data-${key}-${id.value}`);
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
 
     const { data, status, error, refresh } = await useAsyncData<IPlaylistData>(
         key,

package/composables/{use-fetch-playlists-by-niche.ts → fetch/use-fetch-playlists-by-niche.ts}

@@ -1,15 +1,15 @@
 import { useRoute } from 'vue-router';
-import type { ELanguage } from '../runtime';
-import { EAsyncData, getSelectedQuery } from '../runtime';
-import { sortPlaylists } from '../lib';
-import type { IPlaylistCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData, getSelectedQuery } from '../../runtime';
+import { sortPlaylists } from '../../lib';
+import type { IPlaylistCard, PaginatedResponse } from '../../types';
 
 export const useFetchPlaylistsByNiche = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IPlaylistCard>>) => {
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 12 : 48;
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.GetPlaylistsByNiche;
+    const lang = useLang() as Language;
+    const key = AsyncData.GetPlaylistsByNiche;
     const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IPlaylistCard>>(

package/composables/{use-fetch-playlists-get-videos-by-id.ts → fetch/use-fetch-playlists-get-videos-by-id.ts}

@@ -1,5 +1,5 @@
-import { EAsyncData, type ELanguage } from '../runtime';
-import type { IVideoCard, PaginatedResponse } from '../types';
+import { AsyncData, type Language } from '../../runtime';
+import type { IVideoCard, PaginatedResponse } from '../../types';
 import { useRoute } from 'vue-router';
 
 export const useFetchPlaylistsGetVideosById = async (
@@ -10,9 +10,9 @@ export const useFetchPlaylistsGetVideosById = async (
     const perPage = mobile ? 12 : 48;
     const route = useRoute();
     const id = computed(() => String(route.params['playlistId']));
-    const key = EAsyncData.GetPlaylistsVideo;
+    const key = AsyncData.GetPlaylistsVideo;
     const stateKey = computed(() => `data-${key}-${id.value}`);
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
         key,

package/composables/{use-fetch-popular-tags-by-channel-name.ts → fetch/use-fetch-popular-tags-by-channel-name.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IPopularTags } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IPopularTags } from '../../types';
 
 export const useFetchPopularTagsByChannelName = async (
   apiMethod: (...args: any[]) => Promise<IPopularTags[]>
 ) => {
-  const lang = useLang() as ELanguage;
+  const lang = useLang() as Language;
   const slug = useSlug('channel');
-  const key = EAsyncData.PopularTagsByChannel;
+  const key = AsyncData.PopularTagsByChannel;
   const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
   const { data, status, error } = await useAsyncData<IPopularTags[]>(

package/composables/{use-fetch-popular-tags-by-model-name.ts → fetch/use-fetch-popular-tags-by-model-name.ts}

@@ -1,13 +1,13 @@
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IPopularTags } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IPopularTags } from '../../types';
 
 export const useFetchPopularTagsByModelName = async (
   apiMethod: (...args: any[]) => Promise<IPopularTags[]>
 ) => {
-  const lang = useLang() as ELanguage;
+  const lang = useLang() as Language;
   const slug = useSlug();
-  const key = EAsyncData.PopularTagsByModel;
+  const key = AsyncData.PopularTagsByModel;
   const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
   const { data, status, error } = await useAsyncData<IPopularTags[]>(

package/composables/{use-fetch-related-searches.ts → fetch/use-fetch-related-searches.ts}

@@ -1,9 +1,9 @@
-import type { ELanguage  } from '../runtime';
-import { EAsyncData  } from '../runtime';
+import type { Language  } from '../../runtime';
+import { AsyncData  } from '../../runtime';
 
 export const useFetchRelatedSearch = async (apiMethod: (...args: any[]) => Promise<Array<string>>) => {
-    const lang = useLang() as ELanguage;
-    const key = EAsyncData.RelatedSearch;
+    const lang = useLang() as Language;
+    const key = AsyncData.RelatedSearch;
 
     const { data, status, error } = await useAsyncData<Array<string>>(
         key,

package/composables/{use-fetch-related-videos.ts → fetch/use-fetch-related-videos.ts}

@@ -1,18 +1,18 @@
 import { useRoute } from 'vue-router';
-import type { ELanguage } from '../runtime';
-import { EAsyncData } from '../runtime';
-import type { IVideoCard, PaginatedResponse } from '../types';
+import type { Language } from '../../runtime';
+import { AsyncData } from '../../runtime';
+import type { IVideoCard, PaginatedResponse } from '../../types';
 
 export const useFetchRelatedVideos = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>
 ) => {
     const { locale } = useI18n();
-    const lang = useLang() as ELanguage;
+    const lang = useLang() as Language;
     const route = useRoute();
     const mobile = !!useState<boolean>('isMobile').value;
     const perPage = mobile ? 6 : 14;
     const slug = useSlug();
-    const key = EAsyncData.RelatedVideos;
+    const key = AsyncData.RelatedVideos;
     const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(