@futdevpro/nts-dynamo 1.11.1 → 1.11.4

package/src/_modules/discord-assistant/_services/dias-chunk.data-service.ts

@@ -1,16 +1,20 @@
-
-import { DyNTS_OAI_DocChunk } from '../../open-ai/_models/oai-doc-chunk.data-model';
-import { DyNTS_OAI_Chunk_ServiceBase } from '../../open-ai/_services/oai-chunk.service-base';
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_OAI_Chunk, DyNTS_OAI_defaultChunk_dataParams } from '../../open-ai/_models/oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk_DataServiceBase } from '../../open-ai/_services/oai-chunk.service-base';
+import { DyFM_DataModel_Params, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
 import { DyFM_OpenAI_Settings, DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
 import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
 import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base';
 import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface';
 import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../open-ai/_collections/oai-llm-predefined-requests.conts';
 import { DyNTS_OAI_Document_Util } from '../../open-ai/_collections/oai-document.util';
+import { DyNTS_OAI_DocumentPage } from '../../open-ai/_models/interfaces/oai-document-page.interface';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
 
-export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_ServiceBase {
+export abstract class DyNTS_DiAs_Chunk_DataService<
+  T_Page extends DyNTS_OAI_DocumentPage<T_Chunk>, 
+  T_Chunk extends DyNTS_OAI_Chunk
+> extends DyNTS_OAI_Chunk_DataServiceBase<T_Page, T_Chunk> {
 
   protected abstract readonly mainDiscordBot_CS: DyNTS_DiAs_Main_ControlService;
 
@@ -20,10 +24,28 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
   constructor(
     issuer: string,
+    dataParams?: DyFM_DataModel_Params<T_Chunk>,
+    openAiSettings?: DyFM_OpenAI_Settings,
   ) {
-    super(issuer);
+    super(
+      dataParams ?? DyNTS_OAI_defaultChunk_dataParams as DyFM_DataModel_Params<T_Chunk>, 
+      openAiSettings ?? 
+        new DyFM_OpenAI_Settings({
+          openAIConfig: {
+            apiKey: DyNTS_global_settings.env_settings.openAi.apiKey,
+            organization: DyNTS_global_settings.env_settings.openAi.organization,
+            project: DyNTS_global_settings.env_settings.openAi.project,
+          },
+          defaultSettings: {
+            useModel: DyFM_OpenAIModel.textEmbedding_3Large,
+          },
+        }),
+      issuer
+    );
   }
 
+  abstract getPageLink(page: T_Page, issuer: string): string;
+
   async resolveConversation(
     conversation: DyNTS_OAI_GPT_Message[],
   ): Promise<string> {
@@ -71,7 +93,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
     numberOfCandidates: number = 100,
   ): Promise<string> {
     try {
-      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearchUsingConversation(
+      const searchResults: T_Chunk[] = await this.vectorSearchUsingConversation(
         conversation,
         limit,
         numberOfCandidates,
@@ -79,13 +101,8 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
       const parsedSearchResults: string = searchResults.map((result) => {
         return '' +
-          '\npage: ' + result.documentName +
-          '\npageLink: ' + DyNTS_OAI_Document_Util.getClickupPageLink(
-            result.documentName,
-            result.workspaceId,
-            result.documentId,
-            result.documentPageId
-          ) +
+          '\npage: ' + result.pageName +
+          '\npageLink: ' + result.pageLink +
           '\ncontent: ' +
           `\n${result.chunkParentedContent.replace(/\n/g, '\n  ')}`
       }).join('\n\n');
@@ -117,7 +134,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
     conversation: DyNTS_OAI_GPT_Message[],
     limit: number = 3,
     numberOfCandidates: number = 100,
-  ): Promise<DyNTS_OAI_DocChunk[]> {
+  ): Promise<T_Chunk[]> {
     try {
       const lastMessage: DyNTS_OAI_GPT_Message = conversation[conversation.length - 1];
 
@@ -134,7 +151,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
       DyFM_Log.testInfo('🔍 Document search question:', searchQuestion);
 
-      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearch(
+      const searchResults: T_Chunk[] = await this.vectorSearch(
         searchQuestion + ' ' + lastMessage.content,
         'chunkParentedContentVectorized',
         limit,

package/src/_modules/discord-assistant/_services/dias-io.control-service.ts

@@ -7,6 +7,7 @@ import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service'
 import { DyNTS_DiBo_global_settings } from '../../discord-bot/_collections/dibo-global-settings.conts'
 import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base'
 import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface'
+import { DyNTS_DiAs_Util } from '../_collections/dias.util'
 
 export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_ControlService {
 
@@ -27,7 +28,11 @@ export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_Control
     try {
       const messages: Message[] = await this.mainDiscordBot_CS.gatherMessages(message);
       const oaiMessages: DyNTS_OAI_GPT_Message[] = 
-        await this.mainDiscordBot_CS.convertDiscordMessagesToOAIConversation(messages);
+        DyNTS_DiAs_Util.convertDiscordMessagesToOAIConversation(
+          messages,
+          this.mainDiscordBot_CS.botClientId,
+          this.mainDiscordBot_CS.botDisplayName,
+        );
 
       const gptResult: string = await this.llmChat_CS.resolveConversation(
         oaiMessages,

package/src/_modules/discord-assistant/_services/dias.service-base.ts

@@ -46,36 +46,4 @@ export abstract class DyNTS_DiAs_ServiceBase extends DyNTS_DiBo_Main_ControlServ
 
     return messages;
   }
-
-  async convertDiscordMessagesToOAIConversation(
-    messages: Message[]
-  ): Promise<DyNTS_OAI_GPT_Message[]> {
-    return messages.map(message => {
-      if (
-        (message?.author &&
-          (message.author.bot || 
-            message.author.id === this.botClientId ||
-            message.author.displayName === this.botDisplayName))
-      ) {
-        if (DyNTS_DiAs_global_settings.userTranslationFlags.some(
-          flag => message.content.includes(flag)
-        )) {
-          return {
-            role: DyNTS_OAI_GPT_Message_Role.user,
-            content: message.content,
-          };
-        } else {
-          return {
-            role: DyNTS_OAI_GPT_Message_Role.assistant,
-            content: message.content,
-          };
-        }
-      } else {
-        return {
-          role: DyNTS_OAI_GPT_Message_Role.user,
-          content: message.content,
-        };
-      }
-    })
-  }
 }

package/src/_modules/open-ai/_collections/oai-chunking.util.ts

@@ -1,5 +1,5 @@
 import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_OAI_DocChunk } from '../_models/oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../_models/oai-doc-chunk.data-model';
 import { DyNTS_OAI_DocumentPage } from '../_models/interfaces/oai-document-page.interface';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
@@ -20,10 +20,11 @@ export class DyNTS_OAI_Chunking_Util {
    * @param issuer - Kérés kezdeményezője
    * @returns Promise<CU_DocChunk[]> - Létrehozott chunk-ok listája
    */
-  static async chunkMdContent(
-    page: DyNTS_OAI_DocumentPage,
+  static async chunkMdContent<T_Chunk extends DyNTS_OAI_Chunk>(
+    page: DyNTS_OAI_DocumentPage<T_Chunk>,
+    getPageLink: (page: DyNTS_OAI_DocumentPage<T_Chunk>, issuer: string) => string,
     issuer: string
-  ): Promise<DyNTS_OAI_DocChunk[]> {
+  ): Promise<T_Chunk[]> {
     try {
       if (page.content.includes('#####')) {
         DyFM_Log.warn('lvl5+ headers are not supported yet for page: ' + page.name);
@@ -34,7 +35,7 @@ export class DyNTS_OAI_Chunking_Util {
       let leftovers = page.content;
       const maxChunkSize = DyNTS_global_settings.docChunking.maxChunkSize;
       const maxChunkCount = DyNTS_global_settings.docChunking.maxChunkCount;
-      const chunks: DyNTS_OAI_DocChunk[] = [];
+      const chunks: T_Chunk[] = [];
       let chunkIndex = 0;
       let currentPosition = 0; // Track current position in original content
 
@@ -58,20 +59,25 @@ export class DyNTS_OAI_Chunking_Util {
           if (chunkContent.length > 0) {
             const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
             const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
+            const headParents = headerHierarchy.map(header => header.header);
+            const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
             
-            const chunk = new DyNTS_OAI_DocChunk({
-              workspaceId: page.workspaceId,
-              documentId: page.docId,
-              documentPageId: page._id,
+            const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+              filePathParents: page.path,
+              chunkHeadParents: headParents,
 
-              documentName: page.name,
-              documentPath: page.path,
+              allFlaggedParents: allFlaggedParents,
+              allFlaggedParentsMerged: allFlaggedParents.join('/'),
 
+              documentName: page.documentId,
+              pageName: page.name,
+              pageLink: getPageLink(page, issuer),
               chunkIndex: chunkIndex,
-              chunkPath: chunkPath,
               
               chunkOriginalContent: chunkContent,
-            });
+
+              chunkParentedContent: chunkWithHierarchy,
+            }) as T_Chunk;
             chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
             chunks.push(chunk);
           }
@@ -99,23 +105,28 @@ export class DyNTS_OAI_Chunking_Util {
           
           const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
           const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
+          const headParents = headerHierarchy.map(header => header.header);
+          const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
           
           /* console.log(`Chunk path:`, chunkPath);
           console.log(`Chunk with hierarchy preview:`, chunkWithHierarchy.substring(0, 100) + '...'); */
           
-          const chunk = new DyNTS_OAI_DocChunk({
-            workspaceId: page.workspaceId,
-            documentId: page.docId,
-            documentPageId: page._id,
-            
-            documentName: page.name,
-            documentPath: page.path,
+          const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+            filePathParents: page.path,
+            chunkHeadParents: headParents,
 
+            allFlaggedParents: allFlaggedParents,
+            allFlaggedParentsMerged: allFlaggedParents.join('/'),
+
+            documentName: page.documentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
             chunkIndex: chunkIndex,
-            chunkPath: chunkPath,
-                        
+
             chunkOriginalContent: chunkContent,
-          });
+
+            chunkParentedContent: chunkWithHierarchy,
+          }) as T_Chunk;
           chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
           chunks.push(chunk);
           chunkIndex++;
@@ -132,20 +143,25 @@ export class DyNTS_OAI_Chunking_Util {
           const chunkContent = leftovers.substring(0, maxChunkSize).trim();
           const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
           const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
+          const headParents = headerHierarchy.map(header => header.header);
+          const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
           
-          const chunk = new DyNTS_OAI_DocChunk({
-            workspaceId: page.workspaceId,
-            documentId: page.docId,
-            documentPageId: page._id,
+          const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+            filePathParents: page.path,
+            chunkHeadParents: headParents,
 
-            documentName: page.name,
-            documentPath: page.path,
+            allFlaggedParents: allFlaggedParents,
+            allFlaggedParentsMerged: allFlaggedParents.join('/'),
 
+            documentName: page.documentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
             chunkIndex: chunkIndex,
-            chunkPath: chunkPath,
 
             chunkOriginalContent: chunkContent,
-          });
+
+            chunkParentedContent: chunkWithHierarchy,
+          }) as T_Chunk;
           chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
           chunks.push(chunk);
           chunkIndex++;
@@ -190,12 +206,12 @@ export class DyNTS_OAI_Chunking_Util {
     }
   }
 
-  private static assembleChunkWithHeaders(chunk: DyNTS_OAI_DocChunk, issuer: string): string {
+  private static assembleChunkWithHeaders(chunk: DyNTS_OAI_Chunk, issuer: string): string {
     try {
-      const fileHeaders = chunk.documentPath.map(
+      const fileHeaders = chunk.filePathParents.map(
         (header, index) => `${'>'.repeat(index + 1)} **${header}**`
       ).join('\n');
-      const headers = chunk.chunkPath.filter(
+      const headers = chunk.chunkHeadParents.filter(
         path => !chunk.chunkOriginalContent.includes(path)
       ).join('\n');
       return `${fileHeaders}\n\n${headers}\n\n${chunk.chunkOriginalContent}`;
@@ -208,7 +224,7 @@ export class DyNTS_OAI_Chunking_Util {
   }
 
   static reassembleChunksToContent(
-    chunks: DyNTS_OAI_DocChunk[],
+    chunks: DyNTS_OAI_Chunk[],
     issuer: string
   ): string {
     try {

package/src/_modules/open-ai/_models/interfaces/oai-chunk-compare-result.interface.ts

@@ -1,10 +1,13 @@
 
 
 import { DyNTS_OAI_CompareResult_Type } from '../../_enums/oai-compare-result-type.enum';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
 
 
-export interface DyNTS_OAI_ChunkCompareResult {
+export interface DyNTS_OAI_ChunkCompareResult<T extends DyNTS_OAI_Chunk> {
   result: DyNTS_OAI_CompareResult_Type;
-  oldChunk: DyNTS_OAI_DocChunk;
+  oldChunk: T;
 }
+
+
+

package/src/_modules/open-ai/_models/interfaces/oai-document-page.interface.ts

@@ -1,20 +1,23 @@
 import { DyFM_Metadata } from '@futdevpro/fsm-dynamo';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
 
 
 
 
-export interface DyNTS_OAI_DocumentPage extends DyFM_Metadata {
-  workspaceId: string;
-  docId: string;
-  parentPageId: string;
+export interface DyNTS_OAI_DocumentPage<T_Chunk extends DyNTS_OAI_Chunk> {
+  documentId: string;
+  pageId: string;
 
+  name: string;
+  
+  allFlaggedParents: string[];
+  allFlaggedParentsMerged: string;
+  
+  /** Path to the page in the document, starting with the document name */
   path: string[];
-  documentParent: string;
 
-  name: string;
+  chunks: T_Chunk[];
   content: string;
-  
-  pages: DyNTS_OAI_DocumentPage[];
-  chunks: DyNTS_OAI_DocChunk[];
 }
+
+

package/src/_modules/open-ai/_models/interfaces/oai-page-compare-result.interface.ts

@@ -1,18 +1,15 @@
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_ChunkCompareResult, DyNTS_OAI_CompareResult_Type, DyNTS_OAI_DocumentPage } from '../..';
 
-import { DyNTS_OAI_CompareResult_Type } from '../../_enums/oai-compare-result-type.enum';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
-import { DyNTS_OAI_ChunkCompareResult } from './oai-chunk-compare-result.interface';
-import { DyNTS_OAI_DocumentPage } from './oai-document-page.interface';
-
-
-
-
-export interface DyNTS_OAI_PageCompareResult {
+export interface DyNTS_OAI_PageCompareResult<
+  T_Doc extends DyNTS_OAI_DocumentPage<T_Chunk>, 
+  T_Chunk extends DyNTS_OAI_Chunk
+> {
   result: DyNTS_OAI_CompareResult_Type;
-  subjectPage: DyNTS_OAI_DocumentPage;
+  subjectPage: T_Doc;
   oldPageContent: string;
-  chunkCompareResults: DyNTS_OAI_ChunkCompareResult[];
+  chunkCompareResults: DyNTS_OAI_ChunkCompareResult<T_Chunk>[];
 
-  newChunks: DyNTS_OAI_DocChunk[];
-  oldChunks: DyNTS_OAI_DocChunk[];
+  newChunks: T_Chunk[];
+  oldChunks: T_Chunk[];
 }

package/src/_modules/open-ai/_models/oai-doc-chunk.data-model.ts

@@ -1,92 +1,101 @@
 
 
 
-import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
+import { DyFM_DataModel_Params, DyFM_DataProperties, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
 import { DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
 
+export class DyNTS_OAI_Chunk extends DyFM_Metadata {
+  /** Path to the page where the chunk is located ending with the page name */
+  filePathParents: string[] = [];
+  /** Headers that are parents of the chunk */
+  chunkHeadParents: string[] = [];
 
+  /** 
+   * All parents of the chunk, flagged, from the highest level to the lowest local level
+   * like: System:FDP, Project:Organizer, Side:Backend, Module:Chat, etc. 
+   * */
+  allFlaggedParents: string[] = [];
+  /** 
+   * All parents of the chunk, flagged, merged into a with '/' as separator
+   * */
+  allFlaggedParentsMerged: string;
+  
+  documentName: string;
+  pageName: string;
+  pageLink: string;
+  /** Index of the chunk in the page */
+  chunkIndex: number;
 
-export class DyNTS_OAI_DocChunk extends DyFM_Metadata {
-  workspaceId?: string;
-  documentId?: string;
-  documentPageId?: string;
-  mainDocumentName?: string;
-  documentName?: string;
-  documentPath?: string[];
+  chunkOriginalContent: string;
 
-  chunkIndex?: number;
-  /** parent headers */
-  chunkPath?: string[];
-
-  chunkOriginalContent?: string;
-
-  chunkParentedContent?: string;
-  chunkParentedContentVectorized?: number[] = [];
+  chunkParentedContent: string;
+  chunkParentedContentVectorized?: number[];
 
   constructor(
-    set?: DyNTS_OAI_DocChunk,
+    set: DyNTS_OAI_Chunk
   ) {
     super(set);
-
-    if (set) {
-      Object.assign(this, set);
-    }
+ 
+    Object.assign(this, set);
   }
 }
 
-export const DyNTS_OAI_docChunk_dataParams = new DyFM_DataModel_Params<DyNTS_OAI_DocChunk>({
-  dataName: 'oai_doc_chunk',
-  properties: {
-    workspaceId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    documentId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    documentPageId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    mainDocumentName: { 
-      type: 'string',
-      required: true, 
-    },
-    documentName: { 
-      type: 'string',
-      required: true, 
-    },
-    documentPath: { 
-      type: 'string[]',
-      required: true, 
-    },
+export const chunk_propertyParams: DyFM_DataProperties<DyNTS_OAI_Chunk> = {
+  filePathParents: {
+    type: 'string[]', 
+    required: true,
+  },
+  chunkHeadParents: {
+    type: 'string[]', 
+    required: true,
+  },
+
+  allFlaggedParents: {
+    type: 'string[]', 
+    required: true,
+  },
+  allFlaggedParentsMerged: {
+    type: 'string', index: true,
+    required: true,
+  },
 
-    chunkIndex: { 
-      type: 'number', index: true,
-      required: true, 
-    },
-    chunkPath: { 
-      type: 'string[]',
-      required: true, 
-    },
+  documentName: {
+    type: 'string', index: true,
+    required: true,
+  },
+  pageName: {
+    type: 'string', index: true,
+    required: true,
+  },
+  pageLink: {
+    type: 'string', index: true,
+    required: true,
+  },
+  chunkIndex: {
+    type: 'number', index: true,
+    required: true,
+  },
 
-    chunkOriginalContent: { 
-      type: 'string',
-      required: true,
-    },
+  chunkOriginalContent: {
+    type: 'string',
+    required: true,
+  },
 
-    chunkParentedContent: { 
-      type: 'string', index: true,
-      required: true,
-    },
-    chunkParentedContentVectorized: { 
-      type: 'number[]', 
-      required: true, index: true,
-      embeddingModel: DyFM_OpenAIModel.textEmbedding_3Large,
-      vectorizedFrom: 'chunkParentedContent',
-      vectorizeUseIndex: 'chunkParentedContentVectorized',
-      vectorizeAlways: true,
-    },
+  chunkParentedContent: {
+    type: 'string', index: true,
+    required: true,
+  },
+  chunkParentedContentVectorized: {
+    type: 'number[]',
+    required: true,
+    embeddingModel: DyFM_OpenAIModel.textEmbedding_3Large,
+    vectorizedFrom: [ 'chunkParentedContent' ],
+    vectorizeUseIndex: 'chunkParentedContentVectorized',
+    vectorizeAlways: true,
   },
+}
+
+export const DyNTS_OAI_defaultChunk_dataParams: DyFM_DataModel_Params<DyNTS_OAI_Chunk> = new DyFM_DataModel_Params<DyNTS_OAI_Chunk>({
+  dataName: 'doc_chunk',
+  properties: chunk_propertyParams,
 });