oneentry 1.0.117 → 1.0.118

package/README.md

@@ -200,6 +200,9 @@ Now you can use the following links to jump to specific entries:
 
 ## <h2 id="admins"> Admins </h2>
 
+The "Administrators" module is designed for creating and managing administrators.
+An administrator is a user who can add, update, and edit information on the website or in the mobile application.
+
 ```js
 const { Admins } = defineOneEntry('your-url');
 ```
@@ -354,6 +357,54 @@ const result = await Admins.getAdminsInfo(body, 'en_US', 0, 30);
 
 ## <h2 id="attributesets"> AttributesSets </h2>
 
+Attributes are an entity that allows you to configure the structure of your application. With them, you can achieve maximum flexibility and eliminate hardcoding.
+
+Attribute sets are similar to a collection of properties, the values of which you can manage through the admin panel. They differ by the type of binding to various entities. You can read more about the types in the section "Types".
+
+An attribute set forms the data structure that can then be used within your project. For example, for a product, you can define that its structure should contain a name, image, price, and text description. At the same time, the structure of a blog post may contain text with a title and a set of images.
+
+Some attributes may be similar in structure and used in different entities, so you can reuse attribute sets for different entities.
+
+Structure
+Each attribute set contains a customizable collection of attributes that store the content of your project. You can manage these attributes from the management system. This is convenient, as you no longer need to edit the application code to change your project. Just move all content components that can be changed into attributes.
+
+Markers
+Markers cannot contain spaces and cannot start with a digit. If you attempt to enter invalid values in the marker field, the system will ignore the input.
+
+Name
+To make it easier for you to navigate, each attribute has a required name parameter, which is a non-unique string. Name the attributes in a way that makes it easy for you to work with them.
+
+Marker
+As an identifier, each attribute has a required parameter - "marker", which is a unique string. The marker is also used as a key to access the attributes in your project code. Keep this in mind when setting the attribute marker to avoid syntax conflicts.
+
+Data Type
+Choose the data type for each attribute field that it will store.
+
+Data types can be of the following types:
+
+String: Simple text, for example, "Hello, world!".
+Text: Longer text, often formatted, for example, an article or a letter.
+Text with Header: Text with a header that can be used to denote a topic or category.
+Integer: An integer, for example, 5, 100, -2.
+Float: A data type for floating-point numbers that can have a decimal part, for example, 3.14, 1.5, -0.25.
+Real: The same as Float, but with higher precision.
+Date and Time: A combination of date and time, for example, 2023-10-27 10:00:00.
+Date: A date, for example, 2023-10-27.
+Time: A time, for example, 10:00:00.
+File: Any file on your computer, for example, a document, image, music.
+Image: An image, for example, a photograph, drawing.
+Group of Images: A collection of images, for example, a photo album.
+Radio Button: A selection button from which only one option can be chosen.
+List: A list of items, for example, a shopping list.
+Entity: An entity representing an object from the real world, for example, a person, place, organization.
+The content filling interface will correspond to the selected data type for each attribute field.
+
+Opportunities
+You can add validators for attributes. This mechanism is discussed in more detail in the section "Validators".
+
+Attributes
+If one attribute set is used by several entities at once, you need to be careful when changing the attributes of that set. For example, if you delete one of the attributes, that attribute will be removed everywhere it is used along with the content. If you add a new attribute to the set, that attribute will also be added everywhere the attribute set is used.
+
 ```js
 const { AttributesSets } = defineOneEntry('your-url');
 ```
@@ -793,6 +844,8 @@ Example return:
 
 ## <h2 id="authprovider"> User Auth Provider </h2>
 
+The User Auth Provider in OneEntry Headless CMS facilitates user authentication and registration through various methods, such as email. By using the AuthProvider object, developers can handle user registration, including sending activation codes when necessary. The system supports diverse data types for form attributes, allowing comprehensive user data management. Key functionalities include user authentication, token management (access and refresh tokens), password changes, and logout. Additionally, it provides methods to manage authentication providers and retrieve specific details by marker or language code, ensuring secure and efficient user management across applications.
+
 ```js
 const { AuthProvider } = defineOneEntry('your-url');
 ```
@@ -1900,6 +1953,10 @@ Example return:
 
 ## <h2 id="blocks"> Blocks </h2>
 
+The "Blocks" module is designed to create structures that contain sets of attributes. The Headless CMS OneEntry provides users with very flexible tools, and you can use the "Blocks" module as you see fit for your specific case. The main concept of the "Blocks" module is to create reusable entities (blocks) that contain sets of attributes and additional content.
+
+For example, you can create a block - "footer" and use it on all pages of your project.
+
 ```js
 const { Blocks } = defineOneEntry('your-url');
 ```
@@ -2206,10 +2263,17 @@ Example return:
 
 ## <h2 id="events"> Events </h2>
 
+The "Events" module allows you to create and edit events, through which you can interact with the users of your system. In this module, you select an event that the system will respond to and send notifications to the users of your system. For example, you have statuses for catalog items "In stock" and "Out of stock," and you want to send users a notification about the status change from "Out of stock" to "In stock"
+
 ```js
 const { Events } = defineOneEntry('your-url');
 ```
 
+In the Headless CMS OneEntry, there are three ways to interact with the users of your system through the "Events" module: <br/>
+Push Notification <br/>
+Email <br/>
+Socket IO <br/>
+
 ### Events.getAllSubscriptions(offset, limit)
 
 Returns all subscriptions to products 🔐 This method requires authorization.
@@ -2327,6 +2391,8 @@ This method unsubscribes to the product event. Returns nothing if the unsubscrip
 
 ## <h2 id="fileuploading"> FileUploading </h2>
 
+FileUploading in OneEntry Headless CMS provides methods for managing files in cloud storage. The upload method allows uploading files with optional parameters such as type, entity, ID, and image optimization options. It returns information about the uploaded file, including its name and download link. The delete method removes a file from storage by its name and specified parameters. The getFile method searches for and returns a file object based on provided parameters such as ID, type, entity, and filename.
+
 ```js
 const { FileUploading } = defineOneEntry('your-url');
 ```
@@ -2513,6 +2579,8 @@ Example return:
 
 ## <h2 id="forms"> Forms </h2>
 
+The "Forms" module is a user-friendly tool for creating and managing various forms, such as contact forms, surveys, and registration sheets. With an intuitive interface, users can add form elements, customize layouts, and apply themes. The module supports organizing and categorizing forms, setting access permissions, and tracking responses in real-time. Automation features include notifications upon form submissions and integration with applications.
+
 ```js
 const { Forms } = defineOneEntry('your-url');
 ```
@@ -2769,6 +2837,8 @@ Example return:
 
 ## <h2 id="formsdata"> FormData </h2>
 
+The FormData module in OneEntry Headless CMS allows for managing and interacting with form data. By using the defineOneEntry function, you can create a FormData object to handle various operations. The module supports different data types such as strings, numbers, dates, text, images, files, lists, and nested entities. It provides methods like getFormsData, postFormsData, and getFormsDataByMarker for retrieving, creating, and searching form data. Each method interacts with the API to perform these tasks, returning structured JSON objects with detailed information about the form data, including identifiers, timestamps, and language-specific data.
+
 ```js
 const { FormData } = defineOneEntry('your-url');
 ```
@@ -3193,6 +3263,8 @@ Example return:
 
 ## <h2 id="generaltypes"> GeneralTypes </h2>
 
+The `GeneralTypes` module in OneEntry Headless CMS is designed to manage and retrieve general types used within the system. By using the `defineOneEntry` function, you can create a `GeneralTypes` object to interact with these types. The primary method available is `getAllTypes`, which retrieves all objects of type `GeneralTypeEntity` from the API. This method returns a Promise that resolves to an array of `GeneralTypeEntity` objects, each containing an `id` and a `type`. The types cover various purposes, such as page layouts, forms, product blocks, and more, providing flexibility for different content management needs.
+
 ```js
 const { GeneralTypes } = defineOneEntry('your-url');
 ```
@@ -3237,6 +3309,8 @@ Example return:
 
 ## <h2 id="integrationcollections">IntegrationCollections</h2>
 
+Integration Collections is a module for storing various data that can be used for integrating different services and systems. To integrate third-party services, it is necessary to create and configure collections.
+
 ```js
 const { IntegrationCollections } = defineOneEntry('your-url');
 ```
@@ -3845,6 +3919,8 @@ Returns true (in case of successful deletion) or false (in case of unsuccessful
 
 ## <h2 id="locales"> Locales </h2>
 
+Thanks to the support of multiple languages in Oneentry Headless CMS, you can flexibly customize the interface of your dashboard and conveniently manage languages in your project. In this section, you can learn about the principles of working with languages.
+
 ```js
 const { Locales } = defineOneEntry('your-url');
 ```
@@ -3917,6 +3993,24 @@ Example return:
 
 ## <h2 id="menus"> Menus </h2>
 
+The menu is a key element of the structure and navigation of your site. With the menu, you provide visitors with a convenient way to navigate through different sections of your application and find the information they need.
+
+In OneEntry Headless CMS, you can create the menu structure directly from your personal account. This allows you to change the set of pages included in the menu, their order, and titles without modifying the source code of your application.
+
+Additionally, if necessary, you can create nested levels in the menu, allowing for a tree-like structure with sections and subsections.
+
+All of this enables you to work conveniently and flexibly with the navigation of your application directly from your personal account.
+
+At the core of the menu are pages. The menu structure is created from pages.
+
+You can define:
+
+Which pages will be included in the menu
+In what order they will be presented to the user
+What title will be given to the menu item leading to a specific page
+The nesting of menu items (Tree structure)
+Some of these concepts were discussed in the pages section, and some page settings affect the menu structure you can create from these pages.
+
 ```js
 const { Menus } = defineOneEntry('your-url')
 ```
@@ -3994,6 +4088,8 @@ Example return:
 
 ## <h2 id="orders"> Orders </h2>
 
+The ability to make and pay for goods or services is an integral part of the E-commerce application. In this section, you can familiarize yourself with the principles of working with orders.
+
 ```js
 const { Orders } = defineOneEntry('your-url');
 ```
@@ -4673,6 +4769,8 @@ Example return:
 
 ## <h2 id="pages"> Pages </h2>
 
+The Pages module in the Headless CMS OneEntry interface allows you to manage pages if it is a web application, or screens if it is a mobile application.
+
 ```js
 const { Pages } = defineOneEntry('your-url');
 ```
@@ -5596,6 +5694,8 @@ Example return:
 
 ## <h2 id="payments"> Payments </h2>
 
+An important part of the E-commerce application is working with payments. In this section, you can learn about the principles of working with payments.
+
 ```js
 const { Payments } = defineOneEntry('your-url');
 ```
@@ -6244,6 +6344,8 @@ This method use webhook for Stripe. Returns true (in case of successful executio
 
 ## <h2 id="products"> Products </h2>
 
+Products is a separate module in the Headless CMS OneEntry interface that allows you to create a product catalog or a set of multimedia elements, such as a gallery.
+
 ```js
 const { Products } = defineOneEntry('your-url');
 ```
@@ -8092,6 +8194,8 @@ Example return:
 
 ## <h2 id="productstatuses"> ProductStatuses </h2>
 
+To create additional filtering conditions for catalog items in Headless CMS OneEntry, the functionality of Product Statuses has been added. In this tab, you can create a status that will serve as an additional filter alongside the existing conditions from attributes.
+
 ```js
 const { ProductStatuses } = defineOneEntry('your-url');
 ```
@@ -8297,6 +8401,8 @@ true
 
 ## <h2 id="system"> System </h2>
 
+The System module in OneEntry Headless CMS provides methods for testing error page redirections, allowing developers to ensure that their error handling mechanisms are functioning correctly. By using the defineOneEntry function, you can create a System object to access these functionalities. The module offers two primary methods: test404 and test500. Both methods simulate scenarios where the user is redirected to an error page, specifically 404 (Not Found) and 500 (Internal Server Error) pages, respectively. These tools are essential for verifying that the system's error pages are correctly implemented and displayed to users when needed.
+
 ```js
 const { System } = defineOneEntry('your-url');
 ```
@@ -8321,6 +8427,8 @@ const value = await System.test500()
 
 ## <h2 id="templates"> Templates </h2>
 
+Templates help configure the display of the content part of your application. Some templates affect the images stored in the CMS system, while others influence the appearance of other entities, such as blocks, pages, products, etc. In this section, you can familiarize yourself with the principles of working with templates.
+
 ```js
 const { Templates } = defineOneEntry('your-url');
 ```
@@ -8679,6 +8787,8 @@ Example return:
 
 ## <h2 id="templatepreviews"> TemplatePreviews </h2>
 
+Preview templates allow you to configure the image parameters used in attributes. By applying a template to an attribute of type "Image" or "Image Group," you will get images standardized according to the specifications in the preview template. This is convenient if the design of your project is sensitive to image sizes. By configuring the preview template, you can change the image parameters that the end user will see.
+
 ```js
 const { TemplatePreviews } = defineOneEntry('your-url');
 ```
@@ -8998,6 +9108,8 @@ Example return:
 
 ## <h2 id="users"> Users </h2>
 
+In Headless CMS OneEntry, there are the necessary tools for working with registered users. In this section, you can familiarize yourself with the principles of working with users.
+
 You can store the data necessary for your application to work in a state object. When changing the user, add the necessary data to the state. When the user's data is subsequently received, it will contain a state object.
 
 An example in which we add information to the user about how many orders he has made. Add a field "orderCount" with the value to the state object.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneentry",
-  "version": "1.0.117",
+  "version": "1.0.118",
   "description": "OneEntry NPM package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",