@creopse/react 0.0.22 → 0.0.24

package/dist/{content-BpVMJ1wf.cjs → content-Cgzd1E-Q.cjs}

@@ -7967,6 +7967,29 @@ const useContent = () => {
     },
     [request, formatContentModelItemData]
   );
+  const submitUserContentModelItem = React.useCallback(
+    async (title, contentModelId, singletonsData = {}, collectionsData = {}, successCallback, errorCallback) => {
+      const task = await request({
+        url: `/content-model/user-items`,
+        method: "post",
+        data: {
+          title,
+          contentModelId,
+          contentModelData: {
+            index: { ...singletonsData },
+            ...collectionsData
+          }
+        }
+      });
+      if (task.failure && task.error) {
+        if (errorCallback) errorCallback(task.error?.response?.data);
+      } else {
+        if (successCallback) successCallback();
+      }
+      return task;
+    },
+    [request]
+  );
   const getMenu = React.useCallback(
     (name, filterByIsActive = true) => {
       const menu = cloneDeep(props?.menus?.find((menu2) => menu2.name === name));
@@ -8144,6 +8167,7 @@ const useContent = () => {
     getContentModelItems,
     getPaginatedContentModelItems,
     getAppInformationValue,
+    submitUserContentModelItem,
     appAccentColor,
     appPrimaryColor,
     appSecondaryColor

package/dist/{content-CSFJStkb.js → content-DP8wQsOf.js}

@@ -7966,6 +7966,29 @@ const useContent = () => {
     },
     [request, formatContentModelItemData]
   );
+  const submitUserContentModelItem = useCallback(
+    async (title, contentModelId, singletonsData = {}, collectionsData = {}, successCallback, errorCallback) => {
+      const task = await request({
+        url: `/content-model/user-items`,
+        method: "post",
+        data: {
+          title,
+          contentModelId,
+          contentModelData: {
+            index: { ...singletonsData },
+            ...collectionsData
+          }
+        }
+      });
+      if (task.failure && task.error) {
+        if (errorCallback) errorCallback(task.error?.response?.data);
+      } else {
+        if (successCallback) successCallback();
+      }
+      return task;
+    },
+    [request]
+  );
   const getMenu = useCallback(
     (name, filterByIsActive = true) => {
       const menu = cloneDeep(props?.menus?.find((menu2) => menu2.name === name));
@@ -8143,6 +8166,7 @@ const useContent = () => {
     getContentModelItems,
     getPaginatedContentModelItems,
     getAppInformationValue,
+    submitUserContentModelItem,
     appAccentColor,
     appPrimaryColor,
     appSecondaryColor

package/dist/hooks/index.cjs

@@ -1,7 +1,234 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const content = require("../content-BpVMJ1wf.cjs");
+const content = require("../content-Cgzd1E-Q.cjs");
 const React = require("react");
+const articlesUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set("pageSize", String(p.pageSize));
+  if (p.query) searchParams.set("query", p.query);
+  if (p.page) searchParams.set("page", String(p.page));
+  if (p.status) searchParams.set("status", String(p.status));
+  if (p.categories?.length) {
+    p.categories.forEach(
+      (cat) => searchParams.append("categories[]", String(cat))
+    );
+  }
+  if (p.tags?.length) {
+    p.tags.forEach((tag) => searchParams.append("tags[]", String(tag)));
+  }
+  if (p.months?.length) {
+    p.months.forEach((month) => searchParams.append("months[]", month));
+  }
+  return `/news-articles?${searchParams.toString()}`;
+};
+const commentsUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  Object.entries(p).forEach(([key, value]) => {
+    if (value !== void 0) searchParams.set(key, String(value));
+  });
+  return `/news-comments?${searchParams.toString()}`;
+};
+const useNews = () => {
+  const { request } = content.useApi();
+  const [isLoading, setIsLoading] = React.useState(false);
+  const loadCategories = React.useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({ url: "/news-categories" });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadTags = React.useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({ url: "/news-tags" });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadArticles = React.useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({ url: articlesUrlBuilder(params) });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        articles: [],
+        meta: { total: 0, currentPage: 1, perPage: 1, lastPage: 1 }
+      };
+    },
+    [request]
+  );
+  const loadArticlesMonths = React.useCallback(async () => {
+    setIsLoading(true);
+    const task = await request({ url: "/news-articles/list/months" });
+    setIsLoading(false);
+    if (task.success && task.result.data) {
+      return task.result.data;
+    }
+    return [];
+  }, [request]);
+  const loadArticlesCount = React.useCallback(async () => {
+    setIsLoading(true);
+    const task = await request({ url: "/count/news-articles" });
+    setIsLoading(false);
+    if (task.success) {
+      return task.result.data;
+    }
+    return 0;
+  }, [request]);
+  const loadArticlesCountByStatus = React.useCallback(
+    async (status) => {
+      setIsLoading(true);
+      const task = await request({
+        url: `/count/news-articles/status/${status}`
+      });
+      setIsLoading(false);
+      if (task.success) {
+        return task.result.data;
+      }
+      return 0;
+    },
+    [request]
+  );
+  const loadArticlesCountByAuthor = React.useCallback(
+    async (id) => {
+      setIsLoading(true);
+      const task = await request({
+        url: `/count/news-articles/author/${id}`
+      });
+      setIsLoading(false);
+      if (task.success) {
+        return task.result.data;
+      }
+      return 0;
+    },
+    [request]
+  );
+  const loadComments = React.useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({ url: commentsUrlBuilder(params) });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        comments: [],
+        meta: { total: 0, currentPage: 1, perPage: 1, lastPage: 1 }
+      };
+    },
+    [request]
+  );
+  const addComment = React.useCallback(
+    async (comment, successCallback, errorCallback) => {
+      setIsLoading(true);
+      const task = await request({
+        url: "/news-comments",
+        method: "post",
+        data: comment
+      });
+      setIsLoading(false);
+      if (task.failure && task.error) {
+        if (errorCallback) errorCallback(task.error?.response?.data);
+      } else {
+        if (successCallback) successCallback();
+      }
+      return task;
+    },
+    [request]
+  );
+  return {
+    isLoading,
+    loadTags,
+    loadComments,
+    loadArticles,
+    loadCategories,
+    loadArticlesCount,
+    loadArticlesMonths,
+    loadArticlesCountByStatus,
+    loadArticlesCountByAuthor,
+    addComment
+  };
+};
+const videoItemsUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set("pageSize", String(p.pageSize));
+  if (p.query) searchParams.set("query", p.query);
+  if (p.page) searchParams.set("page", String(p.page));
+  if (p.source) searchParams.set("source", p.source);
+  if (p.visible !== void 0) searchParams.set("visible", String(p.visible));
+  if (p.orderByPublishedAt !== void 0)
+    searchParams.set("orderByPublishedAt", String(p.orderByPublishedAt));
+  if (p.categories?.length) {
+    p.categories.forEach(
+      (cat) => searchParams.append("categories[]", String(cat))
+    );
+  }
+  return `/video-items?${searchParams.toString()}`;
+};
+const useVideo = () => {
+  const { request } = content.useApi();
+  const [isLoading, setIsLoading] = React.useState(false);
+  const loadCategories = React.useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({
+        url: "/video-categories"
+      });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadVideoItems = React.useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({
+        url: videoItemsUrlBuilder(params)
+      });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        videoItems: [],
+        meta: {
+          total: 0,
+          currentPage: 1,
+          perPage: 1,
+          lastPage: 1
+        }
+      };
+    },
+    [request]
+  );
+  return {
+    isLoading,
+    loadCategories,
+    loadVideoItems
+  };
+};
 const useNewsletter = () => {
   const { request } = content.useApi();
   const [isLoading, setIsLoading] = React.useState(false);
@@ -50,4 +277,6 @@ exports.useConfig = content.useConfig;
 exports.useContent = content.useContent;
 exports.useHelper = content.useHelper;
 exports.useProps = content.useProps;
+exports.useNews = useNews;
 exports.useNewsletter = useNewsletter;
+exports.useVideo = useVideo;

package/dist/hooks/index.mjs

@@ -1,6 +1,233 @@
-import { e as useApi } from "../content-CSFJStkb.js";
-import { f, a, u, b } from "../content-CSFJStkb.js";
+import { e as useApi } from "../content-DP8wQsOf.js";
+import { f, a, u, b } from "../content-DP8wQsOf.js";
 import { useState, useCallback } from "react";
+const articlesUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set("pageSize", String(p.pageSize));
+  if (p.query) searchParams.set("query", p.query);
+  if (p.page) searchParams.set("page", String(p.page));
+  if (p.status) searchParams.set("status", String(p.status));
+  if (p.categories?.length) {
+    p.categories.forEach(
+      (cat) => searchParams.append("categories[]", String(cat))
+    );
+  }
+  if (p.tags?.length) {
+    p.tags.forEach((tag) => searchParams.append("tags[]", String(tag)));
+  }
+  if (p.months?.length) {
+    p.months.forEach((month) => searchParams.append("months[]", month));
+  }
+  return `/news-articles?${searchParams.toString()}`;
+};
+const commentsUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  Object.entries(p).forEach(([key, value]) => {
+    if (value !== void 0) searchParams.set(key, String(value));
+  });
+  return `/news-comments?${searchParams.toString()}`;
+};
+const useNews = () => {
+  const { request } = useApi();
+  const [isLoading, setIsLoading] = useState(false);
+  const loadCategories = useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({ url: "/news-categories" });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadTags = useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({ url: "/news-tags" });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadArticles = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({ url: articlesUrlBuilder(params) });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        articles: [],
+        meta: { total: 0, currentPage: 1, perPage: 1, lastPage: 1 }
+      };
+    },
+    [request]
+  );
+  const loadArticlesMonths = useCallback(async () => {
+    setIsLoading(true);
+    const task = await request({ url: "/news-articles/list/months" });
+    setIsLoading(false);
+    if (task.success && task.result.data) {
+      return task.result.data;
+    }
+    return [];
+  }, [request]);
+  const loadArticlesCount = useCallback(async () => {
+    setIsLoading(true);
+    const task = await request({ url: "/count/news-articles" });
+    setIsLoading(false);
+    if (task.success) {
+      return task.result.data;
+    }
+    return 0;
+  }, [request]);
+  const loadArticlesCountByStatus = useCallback(
+    async (status) => {
+      setIsLoading(true);
+      const task = await request({
+        url: `/count/news-articles/status/${status}`
+      });
+      setIsLoading(false);
+      if (task.success) {
+        return task.result.data;
+      }
+      return 0;
+    },
+    [request]
+  );
+  const loadArticlesCountByAuthor = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      const task = await request({
+        url: `/count/news-articles/author/${id}`
+      });
+      setIsLoading(false);
+      if (task.success) {
+        return task.result.data;
+      }
+      return 0;
+    },
+    [request]
+  );
+  const loadComments = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({ url: commentsUrlBuilder(params) });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        comments: [],
+        meta: { total: 0, currentPage: 1, perPage: 1, lastPage: 1 }
+      };
+    },
+    [request]
+  );
+  const addComment = useCallback(
+    async (comment, successCallback, errorCallback) => {
+      setIsLoading(true);
+      const task = await request({
+        url: "/news-comments",
+        method: "post",
+        data: comment
+      });
+      setIsLoading(false);
+      if (task.failure && task.error) {
+        if (errorCallback) errorCallback(task.error?.response?.data);
+      } else {
+        if (successCallback) successCallback();
+      }
+      return task;
+    },
+    [request]
+  );
+  return {
+    isLoading,
+    loadTags,
+    loadComments,
+    loadArticles,
+    loadCategories,
+    loadArticlesCount,
+    loadArticlesMonths,
+    loadArticlesCountByStatus,
+    loadArticlesCountByAuthor,
+    addComment
+  };
+};
+const videoItemsUrlBuilder = (p) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set("pageSize", String(p.pageSize));
+  if (p.query) searchParams.set("query", p.query);
+  if (p.page) searchParams.set("page", String(p.page));
+  if (p.source) searchParams.set("source", p.source);
+  if (p.visible !== void 0) searchParams.set("visible", String(p.visible));
+  if (p.orderByPublishedAt !== void 0)
+    searchParams.set("orderByPublishedAt", String(p.orderByPublishedAt));
+  if (p.categories?.length) {
+    p.categories.forEach(
+      (cat) => searchParams.append("categories[]", String(cat))
+    );
+  }
+  return `/video-items?${searchParams.toString()}`;
+};
+const useVideo = () => {
+  const { request } = useApi();
+  const [isLoading, setIsLoading] = useState(false);
+  const loadCategories = useCallback(
+    async (filterByIsVisible = true) => {
+      setIsLoading(true);
+      const task = await request({
+        url: "/video-categories"
+      });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data.filter(
+          (p) => !filterByIsVisible || p.isActive
+        );
+      }
+      return [];
+    },
+    [request]
+  );
+  const loadVideoItems = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      const task = await request({
+        url: videoItemsUrlBuilder(params)
+      });
+      setIsLoading(false);
+      if (task.success && task.result.data) {
+        return task.result.data;
+      }
+      return {
+        videoItems: [],
+        meta: {
+          total: 0,
+          currentPage: 1,
+          perPage: 1,
+          lastPage: 1
+        }
+      };
+    },
+    [request]
+  );
+  return {
+    isLoading,
+    loadCategories,
+    loadVideoItems
+  };
+};
 const useNewsletter = () => {
   const { request } = useApi();
   const [isLoading, setIsLoading] = useState(false);
@@ -49,6 +276,8 @@ export {
   f as useConfig,
   a as useContent,
   u as useHelper,
+  useNews,
   useNewsletter,
-  b as useProps
+  b as useProps,
+  useVideo
 };

package/dist/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
-const content = require("./content-BpVMJ1wf.cjs");
+const content = require("./content-Cgzd1E-Q.cjs");
 const react = require("@inertiajs/react");
 const reactDom = require("react-dom");
 function _interopNamespaceDefault(e) {
@@ -8247,6 +8247,11 @@ const RootContainer$1 = () => {
         true
       );
       ["assign", "replace"].forEach((method) => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          window.location,
+          method
+        );
+        if (descriptor?.configurable === false) return;
         Object.defineProperty(window.location, method, {
           value: function() {
             console.debug(`🚫 location.${method}() blocked`);
@@ -8255,14 +8260,20 @@ const RootContainer$1 = () => {
           configurable: false
         });
       });
-      const currentHref = window.location.href;
-      Object.defineProperty(window.location, "href", {
-        get: () => currentHref,
-        set: (value) => {
-          console.debug("🚫 location.href = blocked:", value);
-        },
-        configurable: false
-      });
+      const hrefDescriptor = Object.getOwnPropertyDescriptor(
+        window.location,
+        "href"
+      );
+      if (hrefDescriptor?.configurable !== false) {
+        const currentHref = window.location.href;
+        Object.defineProperty(window.location, "href", {
+          get: () => currentHref,
+          set: (value) => {
+            console.debug("🚫 location.href = blocked:", value);
+          },
+          configurable: false
+        });
+      }
       window.open = function() {
         console.debug("🚫 window.open() blocked");
         return null;

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import * as React from "react";
 import React__default, { useState, useEffect, createContext, useRef, useLayoutEffect, useId, useContext, useInsertionEffect, useMemo, useCallback, Children, isValidElement, Fragment, createElement, forwardRef, Component } from "react";
-import { u as useHelper, a as useContent, b as useProps, P as PropsContext, R as ResolveSectionsContext, c as cloneDeep, s as slideToId, E as EditorMessageType, d as RouterContext, C as ConfigContext } from "./content-CSFJStkb.js";
+import { u as useHelper, a as useContent, b as useProps, P as PropsContext, R as ResolveSectionsContext, c as cloneDeep, s as slideToId, E as EditorMessageType, d as RouterContext, C as ConfigContext } from "./content-DP8wQsOf.js";
 import { router } from "@inertiajs/react";
 import { createPortal } from "react-dom";
 var jsxRuntime = { exports: {} };
@@ -8229,6 +8229,11 @@ const RootContainer$1 = () => {
         true
       );
       ["assign", "replace"].forEach((method) => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          window.location,
+          method
+        );
+        if (descriptor?.configurable === false) return;
         Object.defineProperty(window.location, method, {
           value: function() {
             console.debug(`🚫 location.${method}() blocked`);
@@ -8237,14 +8242,20 @@ const RootContainer$1 = () => {
           configurable: false
         });
       });
-      const currentHref = window.location.href;
-      Object.defineProperty(window.location, "href", {
-        get: () => currentHref,
-        set: (value) => {
-          console.debug("🚫 location.href = blocked:", value);
-        },
-        configurable: false
-      });
+      const hrefDescriptor = Object.getOwnPropertyDescriptor(
+        window.location,
+        "href"
+      );
+      if (hrefDescriptor?.configurable !== false) {
+        const currentHref = window.location.href;
+        Object.defineProperty(window.location, "href", {
+          get: () => currentHref,
+          set: (value) => {
+            console.debug("🚫 location.href = blocked:", value);
+          },
+          configurable: false
+        });
+      }
       window.open = function() {
         console.debug("🚫 window.open() blocked");
         return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@creopse/react",
   "description": "Creopse React Toolkit",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "private": false,
   "author": "Noé Gnanih <noegnanih@gmail.com>",
   "license": "MIT",

package/types/hooks/content.d.ts

@@ -1,3 +1,4 @@
+import type { Response } from '@/types/api';
 import type { AppInformationKey, ContentModelItemModel, ContentModelModel, MenuItemGroupModel, MenuItemModel, MenuModel, NewsArticleModel, NewsCategoryModel, NewsTagModel, PageModel, SettingType, SharedProps } from '@creopse/utils';
 /**
  * A hook that provides a set of functions and properties for
@@ -41,6 +42,7 @@ export declare const useContent: () => {
         currentPage: number;
     }>;
     getAppInformationValue: (key: AppInformationKey, type?: SettingType) => any;
+    submitUserContentModelItem: (title: string, contentModelId: string, singletonsData?: any, collectionsData?: any, successCallback?: () => void, errorCallback?: (errorData: any) => void) => Promise<Response<any>>;
     appAccentColor: string;
     appPrimaryColor: string;
     appSecondaryColor: string;

package/types/hooks/index.d.ts

@@ -1,5 +1,7 @@
 export { useApi } from './api';
+export { useNews } from './news';
 export { useProps } from './props';
+export { useVideo } from './video';
 export { useConfig } from './config';
 export { useHelper } from './helper';
 export { useContent } from './content';

package/types/hooks/news.d.ts

@@ -0,0 +1,31 @@
+import type { Response } from '@/types/api';
+import type { ArticlesQueryParams, CommentsQueryParams, PaginatedArticles, PaginatedComments } from '@/types/news';
+import type { NewsArticleStatus, NewsCategoryModel, NewsCommentModel, NewsTagModel } from '@creopse/utils';
+/**
+ * A hook that provides a set of functions and properties for
+ * easily accessing and manipulating news articles, categories, tags, and comments.
+ *
+ * @returns {Object}
+ * @property {boolean} isLoading - A boolean that indicates whether a request is being processed.
+ * @property {function} loadTags - A function that loads news tags from the server.
+ * @property {function} loadComments - A function that loads news comments from the server.
+ * @property {function} loadArticles - A function that loads news articles from the server.
+ * @property {function} loadCategories - A function that loads news categories from the server.
+ * @property {function} loadArticlesCount - A function that loads the total count of news articles.
+ * @property {function} loadArticlesMonths - A function that loads months having at least one article.
+ * @property {function} loadArticlesCountByStatus - A function that loads the article count by status.
+ * @property {function} loadArticlesCountByAuthor - A function that loads the article count by author.
+ * @property {function} addComment - A function that adds a new news comment to the server.
+ */
+export declare const useNews: () => {
+    isLoading: boolean;
+    loadTags: (filterByIsVisible?: boolean) => Promise<NewsTagModel[]>;
+    loadComments: (params: CommentsQueryParams) => Promise<PaginatedComments>;
+    loadArticles: (params: ArticlesQueryParams) => Promise<PaginatedArticles>;
+    loadCategories: (filterByIsVisible?: boolean) => Promise<NewsCategoryModel[]>;
+    loadArticlesCount: () => Promise<number>;
+    loadArticlesMonths: () => Promise<string[]>;
+    loadArticlesCountByStatus: (status: NewsArticleStatus) => Promise<number>;
+    loadArticlesCountByAuthor: (id: number) => Promise<number>;
+    addComment: (comment: NewsCommentModel, successCallback?: () => void, errorCallback?: (errorData: any) => void) => Promise<Response<any>>;
+};

package/types/hooks/video.d.ts

@@ -0,0 +1,16 @@
+import type { PaginatedVideoItems, VideoItemsQueryParams } from '@/types/video';
+import type { VideoCategoryModel } from '@creopse/utils';
+/**
+ * A hook that provides a set of functions and properties for
+ * easily accessing and manipulating video categories and video items.
+ *
+ * @returns {Object}
+ * @property {boolean} isLoading - A boolean that indicates whether a request is being processed.
+ * @property {function} loadCategories - A function that loads video categories from the server.
+ * @property {function} loadVideoItems - A function that loads video items from the server.
+ */
+export declare const useVideo: () => {
+    isLoading: boolean;
+    loadCategories: (filterByIsVisible?: boolean) => Promise<VideoCategoryModel[]>;
+    loadVideoItems: (params: VideoItemsQueryParams) => Promise<PaginatedVideoItems>;
+};

package/types/types/news.d.ts

@@ -0,0 +1,35 @@
+import type { NewsArticleModel, NewsCommentModel } from '@creopse/utils';
+export interface PaginatedResponseMeta {
+    links?: {
+        first: string;
+        last: string;
+        prev: string;
+        next: string;
+    };
+    currentPage: number;
+    perPage: number;
+    total: number;
+    lastPage: number;
+}
+export interface ArticlesQueryParams {
+    pageSize: number;
+    query?: string;
+    page?: number;
+    status?: number;
+    categories?: number[];
+    tags?: number[];
+    months?: string[];
+}
+export interface PaginatedArticles {
+    articles: NewsArticleModel[];
+    meta: PaginatedResponseMeta;
+}
+export interface CommentsQueryParams {
+    pageSize: number;
+    query?: string;
+    page?: number;
+}
+export interface PaginatedComments {
+    comments: NewsCommentModel[];
+    meta: PaginatedResponseMeta;
+}

package/types/types/video.d.ts

@@ -0,0 +1,25 @@
+import type { VideoItemModel } from '@creopse/utils';
+export interface VideoItemsQueryParams {
+    pageSize: number;
+    source?: string;
+    query?: string;
+    page?: number;
+    visible?: boolean;
+    orderByPublishedAt?: boolean;
+    categories?: (string | number)[];
+}
+export interface PaginatedVideoItems {
+    videoItems: VideoItemModel[];
+    meta: {
+        links?: {
+            first: string;
+            last: string;
+            prev: string;
+            next: string;
+        };
+        currentPage: number;
+        perPage: number;
+        total: number;
+        lastPage: number;
+    };
+}