@futdevpro/fsm-dynamo 1.9.15 → 1.9.16

package/src/_models/control-models/error.control-model.ts

@@ -1,11 +1,8 @@
-import { DynamoFM_error_defaults } from '../../_collections/constants/error-defaults.const';
-import { DynamoFM_ErrorLevel } from '../../_enums';
-import { DynamoFM_Log } from '../../_collections/utils/log.util';
-import { DynamoFM_Metadata } from '../data-models/metadata.data-model';
-
-export type DFM_Error = DynamoFM_Error;
-
-export interface DynamoFM_Error_Settings {
+import { DyFM_error_defaults } from '../../_collections/constants/error-defaults.const';
+import { DyFM_ErrorLevel } from '../../_enums';
+import { DyFM_Log } from '../../_collections/utils/log.util';
+import { DyFM_Metadata } from '../data-models/metadata.data-model';
+export interface DyFM_Error_Settings {
   _id?: string;
 
   handled?: boolean;
@@ -17,14 +14,14 @@ export interface DynamoFM_Error_Settings {
   userMessageTranslateCode?: string;
   addECToUserMsg?: boolean;
 
-  error?: DynamoFM_AnyError;
-  errors?: DynamoFM_AnyError[];
+  error?: DyFM_AnyError;
+  errors?: DyFM_AnyError[];
 
   issuer?: string;
   issuerSystem?: string;
   issuerService?: string;
 
-  level?: DynamoFM_ErrorLevel;
+  level?: DyFM_ErrorLevel;
 
   levelUpThis?: boolean;
   additionalContent?: any;
@@ -40,9 +37,9 @@ export interface DynamoFM_Error_Settings {
   __v?: number;
 }
 
-export type DynamoFM_AnyError = Error | DynamoFM_Error;
+export type DyFM_AnyError = Error | DyFM_Error;
 
-export class DynamoFM_Error extends DynamoFM_Metadata {
+export class DyFM_Error extends DyFM_Metadata {
   readonly flag = 'DYNAMO-ERROR-OBJECT-v2';
 
   _errorCode?: string;
@@ -64,24 +61,24 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
   ___issuerSystem?: string;
   ___issuerService?: string;
 
-  error?: DynamoFM_AnyError;
-  errors?: DynamoFM_AnyError[] = [];
+  error?: DyFM_AnyError;
+  errors?: DyFM_AnyError[] = [];
 
-  level?: DynamoFM_ErrorLevel;
+  level?: DyFM_ErrorLevel;
   
   levelUpThis?: boolean;
   additionalContent?: any = {};
   confidentialContent?: any = {};
 
   constructor(
-    set?: DynamoFM_Error_Settings
+    set?: DyFM_Error_Settings
   ) {
     super(
       set, 
       { 
         issuer: set?.issuerService ?? 
-          (set?.error as DynamoFM_Error)?.___issuerService ?? 
-            DynamoFM_error_defaults.issuerService,
+          (set?.error as DyFM_Error)?.___issuerService ?? 
+            DyFM_error_defaults.issuerService,
       }
     );
     
@@ -91,47 +88,47 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       }
 
       /** set simple properties */
-      this.___handled = Boolean(set?.handled ?? (set?.error as DynamoFM_Error)?.___handled);
-      this.___status = set?.status ?? (set?.error as DynamoFM_Error)?.___status;
+      this.___handled = Boolean(set?.handled ?? (set?.error as DyFM_Error)?.___handled);
+      this.___status = set?.status ?? (set?.error as DyFM_Error)?.___status;
       this.___issuer = set?.issuer ?? 
-        (set?.error as DynamoFM_Error)?.___issuer ?? 
-          DynamoFM_error_defaults.issuer;
+        (set?.error as DyFM_Error)?.___issuer ?? 
+          DyFM_error_defaults.issuer;
       this.___issuerSystem = set?.issuerSystem ??
-        (set?.error as DynamoFM_Error)?.___issuerSystem ?? 
-          DynamoFM_error_defaults.issuerSystem;
+        (set?.error as DyFM_Error)?.___issuerSystem ?? 
+          DyFM_error_defaults.issuerSystem;
       this.___issuerService = set?.issuerService ?? 
-        (set?.error as DynamoFM_Error)?.___issuerService ?? 
-          DynamoFM_error_defaults.issuerService;
+        (set?.error as DyFM_Error)?.___issuerService ?? 
+          DyFM_error_defaults.issuerService;
       
-      this.level = set?.level ?? (set?.error as DynamoFM_Error)?.level ?? DynamoFM_ErrorLevel.error;
+      this.level = set?.level ?? (set?.error as DyFM_Error)?.level ?? DyFM_ErrorLevel.error;
 
       this.levelUpThis = set?.levelUpThis;
 
-      if (set?.additionalContent && (set?.error as DynamoFM_Error)?.additionalContent) {
+      if (set?.additionalContent && (set?.error as DyFM_Error)?.additionalContent) {
         this.additionalContent = {
-          ...(set?.error as DynamoFM_Error)?.additionalContent,
+          ...(set?.error as DyFM_Error)?.additionalContent,
           ...set.additionalContent,
         };
       } else if (set?.additionalContent) {
         this.additionalContent = set.additionalContent;
-      } else if ((set?.error as DynamoFM_Error)?.additionalContent) {
-        this.additionalContent = (set?.error as DynamoFM_Error)?.additionalContent;
+      } else if ((set?.error as DyFM_Error)?.additionalContent) {
+        this.additionalContent = (set?.error as DyFM_Error)?.additionalContent;
       }
 
-      if (set?.confidentialContent && (set?.error as DynamoFM_Error)?.confidentialContent) {
+      if (set?.confidentialContent && (set?.error as DyFM_Error)?.confidentialContent) {
         this.confidentialContent = {
-          ...(set?.error as DynamoFM_Error)?.confidentialContent,
+          ...(set?.error as DyFM_Error)?.confidentialContent,
           ...set.confidentialContent,
         };
       } else if (set?.confidentialContent) {
         this.confidentialContent = set.confidentialContent;
-      } else if ((set?.error as DynamoFM_Error)?.confidentialContent) {
-        this.confidentialContent = (set?.error as DynamoFM_Error)?.confidentialContent;
+      } else if ((set?.error as DyFM_Error)?.confidentialContent) {
+        this.confidentialContent = (set?.error as DyFM_Error)?.confidentialContent;
       }
 
       /** set default error code */
       if (!set.errorCode) {
-        set.errorCode = DynamoFM_error_defaults.errorCode;
+        set.errorCode = DyFM_error_defaults.errorCode;
       }
 
       /** set default error (self defined) */
@@ -146,12 +143,12 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       /** set errorCodes */
       let previousErrorCodes: string[] = [];
 
-      if ((set?.error as DynamoFM_Error)?._errorCodes) {
-        previousErrorCodes.push(...((set?.error as DynamoFM_Error)?._errorCodes ?? []));
+      if ((set?.error as DyFM_Error)?._errorCodes) {
+        previousErrorCodes.push(...((set?.error as DyFM_Error)?._errorCodes ?? []));
       }
 
       if (!set.errorCode) {
-        set.errorCode = DynamoFM_error_defaults.errorCode;
+        set.errorCode = DyFM_error_defaults.errorCode;
       }
       previousErrorCodes = previousErrorCodes.filter(
         (code: string): boolean => code !== set.errorCode
@@ -161,7 +158,7 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       /** bring up non NTS and non default first error */
       const filteredErrorCodes: string[] = this._errorCodes.filter(
         (code: string): boolean => 
-          code && code !== DynamoFM_error_defaults.errorCode && !code.includes('NTS-')
+          code && code !== DyFM_error_defaults.errorCode && !code.includes('NTS-')
       );
 
       this._errorCode = filteredErrorCodes[0] ?? this._errorCodes?.[0];
@@ -175,7 +172,7 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
         /** string error */
           set.message = set.error;
         } else if (
-          !(set?.error as DynamoFM_Error)?.flag?.includes('DYNAMO') && 
+          !(set?.error as DyFM_Error)?.flag?.includes('DYNAMO') && 
           (set?.error as Error)?.message
         ) {
         /** simple - non-dynamo - error */
@@ -184,14 +181,14 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
         /** error not defined - self defining */
           const posFull: string[] = (set.error as Error).stack.split('\n')?.[1]?.split('\\');
 
-          set.message = DynamoFM_error_defaults.message + '; ' + posFull[posFull.length - 1];
+          set.message = DyFM_error_defaults.message + '; ' + posFull[posFull.length - 1];
         }
       }
       /** set messages */
       let previousMessages: string[] = [];
       
-      if ((set?.error as DynamoFM_Error)?._messages) {
-        previousMessages.push(...((set?.error as DynamoFM_Error)?._messages ?? []));
+      if ((set?.error as DyFM_Error)?._messages) {
+        previousMessages.push(...((set?.error as DyFM_Error)?._messages ?? []));
       } else if ((set?.error as Error)?.message) {
         previousErrorCodes.push((set?.error as Error)?.message);
       }
@@ -203,7 +200,7 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       if (
         -1 < highlightedErrorCodeIndex && 
         this._messages[highlightedErrorCodeIndex] && 
-        this._messages[highlightedErrorCodeIndex] !== DynamoFM_error_defaults.message
+        this._messages[highlightedErrorCodeIndex] !== DyFM_error_defaults.message
       ) {
         this._message = this._messages[highlightedErrorCodeIndex];
       } else {
@@ -213,17 +210,17 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       /** set userMessages */
       let previousUserMessages: string[] = [];
 
-      if ((set?.error as DynamoFM_Error)?.__userMessages) {
-        previousUserMessages.push(...((set?.error as DynamoFM_Error)?.__userMessages ?? []));
+      if ((set?.error as DyFM_Error)?.__userMessages) {
+        previousUserMessages.push(...((set?.error as DyFM_Error)?.__userMessages ?? []));
       }
 
       if (!set.userMessage) {
-        set.userMessage = DynamoFM_error_defaults.userMessage;
+        set.userMessage = DyFM_error_defaults.userMessage;
       }
 
       if (
         set.addECToUserMsg && 
-        set.userMessage !== DynamoFM_error_defaults.userMessage && 
+        set.userMessage !== DyFM_error_defaults.userMessage && 
         set.errorCode
       ) {
         set.userMessage += `\nErrorCode: ${set.errorCode}`;
@@ -236,30 +233,30 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
       if (
         -1 < highlightedErrorCodeIndex && 
         this.__userMessages[highlightedErrorCodeIndex] && 
-        this.__userMessages[highlightedErrorCodeIndex] !== DynamoFM_error_defaults.userMessage
+        this.__userMessages[highlightedErrorCodeIndex] !== DyFM_error_defaults.userMessage
       ) {
         this.__userMessage = this.__userMessages[highlightedErrorCodeIndex];
       } else {
         this.__userMessage = this.__userMessages.filter(
-          (msg: string): boolean => msg && msg !== DynamoFM_error_defaults.userMessage
+          (msg: string): boolean => msg && msg !== DyFM_error_defaults.userMessage
         )?.[0];
       }
 
       /** set userMessageTranslateCode */
       set.userMessageTranslateCode = 
         set?.userMessageTranslateCode ?? 
-          (set?.error as DynamoFM_Error)?.__userMessageTranslateCode;
+          (set?.error as DyFM_Error)?.__userMessageTranslateCode;
 
       /** set errors */
-      let previousErrors: DynamoFM_AnyError[] = [];
+      let previousErrors: DyFM_AnyError[] = [];
 
-      if ((set?.error as DynamoFM_Error)?.errors?.length) {
-        previousErrors.push(...(set.error as DynamoFM_Error).errors);
-      } else if (typeof (set?.error as DynamoFM_Error)?.errors == 'object') {
-        this.additionalContent.errors = (set?.error as DynamoFM_Error).errors;
+      if ((set?.error as DyFM_Error)?.errors?.length) {
+        previousErrors.push(...(set.error as DyFM_Error).errors);
+      } else if (typeof (set?.error as DyFM_Error)?.errors == 'object') {
+        this.additionalContent.errors = (set?.error as DyFM_Error).errors;
       }
       previousErrors = previousErrors.filter(
-        (error: DynamoFM_AnyError): boolean => error !== set.error
+        (error: DyFM_AnyError): boolean => error !== set.error
       );
       this.errors = [ ...previousErrors, set?.error ].filter(Boolean);
 
@@ -274,12 +271,12 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
         }
       }
       this.error = this.errors?.[0];
-      this.errors.map((error: DynamoFM_AnyError): any => {
-        if ((error as DynamoFM_Error)?.flag?.includes('DYNAMO')) {
+      this.errors.map((error: DyFM_AnyError): any => {
+        if ((error as DyFM_Error)?.flag?.includes('DYNAMO')) {
           const subError = { ...(error ?? {}) };
           
-          if ((subError as DynamoFM_Error)?.errors) {
-            delete (subError as DynamoFM_Error).errors;
+          if ((subError as DyFM_Error)?.errors) {
+            delete (subError as DyFM_Error).errors;
           }
 
           return subError;
@@ -294,8 +291,8 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
         console.error(this);
       }
     } catch (error) {
-      DynamoFM_Log.error(
-        '\n\nInternal Dynamo ERROR: Failed to create DynamoFM_Error...' +
+      DyFM_Log.error(
+        '\n\nInternal Dynamo ERROR: Failed to create DyFM_Error...' +
         '\nerror:\n', error, 
         '\n\ntrace:', new Error(), 
         '\n\nset:', set, 
@@ -304,46 +301,46 @@ export class DynamoFM_Error extends DynamoFM_Metadata {
     }
   }
 
-  getErrorSimplified(): DynamoFM_Error {
-    const error: DynamoFM_Error = { ...this };
+  getErrorSimplified(): DyFM_Error {
+    const error: DyFM_Error = { ...this };
 
     delete error.errors;
 
-    if ((error.error as DynamoFM_Error)?.error) {
-      delete (error.error as DynamoFM_Error).error;
+    if ((error.error as DyFM_Error)?.error) {
+      delete (error.error as DyFM_Error).error;
     }
 
-    if ((error.error as DynamoFM_Error)?.errors) {
-      delete (error.error as DynamoFM_Error).errors;
+    if ((error.error as DyFM_Error)?.errors) {
+      delete (error.error as DyFM_Error).errors;
     }
 
     return error;
   }
 
-  getErrorsFlat(): DynamoFM_Error {
-    const error: DynamoFM_Error = { ...this };
+  getErrorsFlat(): DyFM_Error {
+    const error: DyFM_Error = { ...this };
     
-    if ((error.error as DynamoFM_Error)?.error) {
-      delete (error.error as DynamoFM_Error).error;
+    if ((error.error as DyFM_Error)?.error) {
+      delete (error.error as DyFM_Error).error;
     }
 
-    if ((error.error as DynamoFM_Error)?.errors) {
-      delete (error.error as DynamoFM_Error).errors;
+    if ((error.error as DyFM_Error)?.errors) {
+      delete (error.error as DyFM_Error).errors;
     }
 
-    error.errors.map((err: DynamoFM_Error): void => {
+    error.errors.map((err: DyFM_Error): void => {
       const subError = { ...(err ?? {}) };
 
       if (subError.errors) {
         delete subError.errors;
       }
 
-      if ((subError.error as DynamoFM_Error)?.errors) {
-        delete (subError.error as DynamoFM_Error).errors;
+      if ((subError.error as DyFM_Error)?.errors) {
+        delete (subError.error as DyFM_Error).errors;
       }
 
-      if ((subError.error as DynamoFM_Error)?.error) {
-        delete (subError.error as DynamoFM_Error).error;
+      if ((subError.error as DyFM_Error)?.error) {
+        delete (subError.error as DyFM_Error).error;
       }
     });
 

package/src/_models/control-models/poll.control-model.ts

@@ -1,13 +1,13 @@
 import { Subscription, timer } from 'rxjs';
-import { DynamoFM_Error } from './error.control-model';
+import { DyFM_Error } from './error.control-model';
+
 
-export type DFM_Poll<T> = DynamoFM_Poll<T>;
 /**
  * DynamoFSM_Poll is a predefined class is
  * for polling a specific endpoint
  * waiting a specific result
  */
-export class DynamoFM_Poll<T> {
+export class DyFM_Poll<T> {
   poll: Subscription;
   running: boolean;
   private pollDo: (...args) => Promise<T>;
@@ -53,8 +53,8 @@ export class DynamoFM_Poll<T> {
       this.stopOnFail = set.stopOnFail;
       this.startPoll(this.args);
     } catch (error) {
-      throw new DynamoFM_Error({
-        message: 'DynamoFM_Poll construcion failed.'
+      throw new DyFM_Error({
+        message: 'DyFM_Poll construcion failed.'
       });
     }
   }
@@ -71,14 +71,14 @@ export class DynamoFM_Poll<T> {
             this.stop();
           }
 
-          throw new DynamoFM_Error({
+          throw new DyFM_Error({
             message: 'DYNAMO ERROR: \nDynamoPoll: pollDo was UNSUCCESSFUL',
           });
         });
       });
       this.running = true;
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         message: 'DYNAMO ERROR: \nDynamoPoll: startPoll was UNSUCCESSFUL',
         error: error,
       });
@@ -93,7 +93,7 @@ export class DynamoFM_Poll<T> {
         this.startPoll(this.args);
       }
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         message: 'DYNAMO ERROR: \nDynamoPoll: restartPoll was UNSUCCESSFUL',
         error: error,
       });

package/src/_models/control-models/range-value.control-model.ts

@@ -1,20 +1,20 @@
 
 
-export type DFM_RangeValue<T> = DynamoFM_RangeValue<T>;
-export type DFM_RangeV<T> = DynamoFM_RangeValue<T>;
-export class DynamoFM_RangeValue<T = number> {
+export type DyFM_RangeV<T> = DyFM_RangeValue<T>;
+
+export class DyFM_RangeValue<T = number> {
   readonly isRange: boolean = true;
 
   from: T;
   to: T;
 
   constructor(
-    from: T | DynamoFM_RangeValue<T>,
+    from: T | DyFM_RangeValue<T>,
     to?: T,
   ) {
-    if ((from as DynamoFM_RangeValue<T>)?.isRange) {
-      this.from = (from as DynamoFM_RangeValue<T>).from;
-      this.to = (from as DynamoFM_RangeValue<T>).to;
+    if ((from as DyFM_RangeValue<T>)?.isRange) {
+      this.from = (from as DyFM_RangeValue<T>).from;
+      this.to = (from as DyFM_RangeValue<T>).to;
 
       return;
     } else {
@@ -27,57 +27,57 @@ export class DynamoFM_RangeValue<T = number> {
     return true; 
   }
 
-  newValues?(value: DynamoFM_RangeValue<T>): void {
+  newValues?(value: DyFM_RangeValue<T>): void {
     this.from = value.from;
     this.to = value.to;
   }
 
-  addRange?(range: DynamoFM_RangeValue<number>): void {
-    (this as DynamoFM_RangeValue<number>).from += range.from;
-    (this as DynamoFM_RangeValue<number>).to += range.to;
+  addRange?(range: DyFM_RangeValue<number>): void {
+    (this as DyFM_RangeValue<number>).from += range.from;
+    (this as DyFM_RangeValue<number>).to += range.to;
   }
   
-  subtractRange?(range: DynamoFM_RangeValue<number>): void {
-    (this as DynamoFM_RangeValue<number>).from -= range.from;
-    (this as DynamoFM_RangeValue<number>).to -= range.to;
+  subtractRange?(range: DyFM_RangeValue<number>): void {
+    (this as DyFM_RangeValue<number>).from -= range.from;
+    (this as DyFM_RangeValue<number>).to -= range.to;
   }
 
-  multiplyRange?(range: DynamoFM_RangeValue<number>): void {
-    (this as DynamoFM_RangeValue<number>).from *= range.from;
-    (this as DynamoFM_RangeValue<number>).to *= range.to;
+  multiplyRange?(range: DyFM_RangeValue<number>): void {
+    (this as DyFM_RangeValue<number>).from *= range.from;
+    (this as DyFM_RangeValue<number>).to *= range.to;
   }
 
-  divideRange?(range: DynamoFM_RangeValue<number>): void {
-    (this as DynamoFM_RangeValue<number>).from /= range.from;
-    (this as DynamoFM_RangeValue<number>).to /= range.to;
+  divideRange?(range: DyFM_RangeValue<number>): void {
+    (this as DyFM_RangeValue<number>).from /= range.from;
+    (this as DyFM_RangeValue<number>).to /= range.to;
   }
 
   add?(value: number): void {
-    (this as DynamoFM_RangeValue<number>).from += value;
-    (this as DynamoFM_RangeValue<number>).to += value;
+    (this as DyFM_RangeValue<number>).from += value;
+    (this as DyFM_RangeValue<number>).to += value;
   }
 
   subtract?(value: number): void {
-    (this as DynamoFM_RangeValue<number>).from -= value;
-    (this as DynamoFM_RangeValue<number>).to -= value;
+    (this as DyFM_RangeValue<number>).from -= value;
+    (this as DyFM_RangeValue<number>).to -= value;
   }
 
   multiply?(value: number): void {
-    (this as DynamoFM_RangeValue<number>).from *= value;
-    (this as DynamoFM_RangeValue<number>).to *= value;
+    (this as DyFM_RangeValue<number>).from *= value;
+    (this as DyFM_RangeValue<number>).to *= value;
   }
 
   divide?(value: number): void {
-    (this as DynamoFM_RangeValue<number>).from /= value;
-    (this as DynamoFM_RangeValue<number>).to /= value;
+    (this as DyFM_RangeValue<number>).from /= value;
+    (this as DyFM_RangeValue<number>).to /= value;
   }
 
-  clone?(): DynamoFM_RangeValue<T> {
-    return new DynamoFM_RangeValue<T>(this.from, this.to);
+  clone?(): DyFM_RangeValue<T> {
+    return new DyFM_RangeValue<T>(this.from, this.to);
   }
 
-  applyTransform?<K = T>(transform: (value: T) => K): DynamoFM_RangeValue<K> {
-    return new DynamoFM_RangeValue<K>(transform(this.from), transform(this.to));
+  applyTransform?<K = T>(transform: (value: T) => K): DyFM_RangeValue<K> {
+    return new DyFM_RangeValue<K>(transform(this.from), transform(this.to));
   }
 
   toString? = this.stringify;
@@ -91,52 +91,52 @@ export class DynamoFM_RangeValue<T = number> {
     }
   }
 
-  static reType<T>(value: DynamoFM_RangeValue<T>): DynamoFM_RangeValue<T> {
-    return new DynamoFM_RangeValue<T>(value.from, value.to);
+  static reType<T>(value: DyFM_RangeValue<T>): DyFM_RangeValue<T> {
+    return new DyFM_RangeValue<T>(value.from, value.to);
   }
 
   static addRange(
-    a: DynamoFM_RangeValue<number>, 
-    b: DynamoFM_RangeValue<number>
-  ): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(a.from + b.from, a.to + b.to);
+    a: DyFM_RangeValue<number>, 
+    b: DyFM_RangeValue<number>
+  ): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(a.from + b.from, a.to + b.to);
   }
   
   static subtractRange(
-    from: DynamoFM_RangeValue<number>, 
-    value: DynamoFM_RangeValue<number>
-  ): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(from.from - value.from, from.to - value.to);
+    from: DyFM_RangeValue<number>, 
+    value: DyFM_RangeValue<number>
+  ): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(from.from - value.from, from.to - value.to);
   }
 
   static multiplyRange(
-    from: DynamoFM_RangeValue<number>, 
-    value: DynamoFM_RangeValue<number>
-  ): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(from.from * value.from, from.to * value.to);
+    from: DyFM_RangeValue<number>, 
+    value: DyFM_RangeValue<number>
+  ): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(from.from * value.from, from.to * value.to);
   }
 
   static divideRange(
-    from: DynamoFM_RangeValue<number>, 
-    value: DynamoFM_RangeValue<number>
-  ): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(from.from / value.from, from.to / value.to);
+    from: DyFM_RangeValue<number>, 
+    value: DyFM_RangeValue<number>
+  ): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(from.from / value.from, from.to / value.to);
   }
 
-  static add(a: DynamoFM_RangeValue<number>, b: number): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(a.from + b, a.to + b);
+  static add(a: DyFM_RangeValue<number>, b: number): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(a.from + b, a.to + b);
   }
 
-  static subtract(a: DynamoFM_RangeValue<number>, b: number): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(a.from - b, a.to - b);
+  static subtract(a: DyFM_RangeValue<number>, b: number): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(a.from - b, a.to - b);
   }
 
-  static multiply(a: DynamoFM_RangeValue<number>, b: number): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(a.from * b, a.to * b);
+  static multiply(a: DyFM_RangeValue<number>, b: number): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(a.from * b, a.to * b);
   }
 
-  static divide(a: DynamoFM_RangeValue<number>, b: number): DynamoFM_RangeValue<number> {
-    return new DynamoFM_RangeValue<number>(a.from / b, a.to / b);
+  static divide(a: DyFM_RangeValue<number>, b: number): DyFM_RangeValue<number> {
+    return new DyFM_RangeValue<number>(a.from / b, a.to / b);
   }
 }
 

package/src/_models/control-models/usage-action.control-model.ts

@@ -1,11 +1,11 @@
 
-export type DFM_UsageAction = DynamoFM_UsageAction;
-export class DynamoFM_UsageAction {
+
+export class DyFM_UsageAction {
   action?: string;
   time?: Date;
 
   constructor(
-    set?: DynamoFM_UsageAction
+    set?: DyFM_UsageAction
   ) {
     if (set) {
       Object.assign(this, set);

package/src/_models/control-models/usage-data.control-model.ts

@@ -1,16 +1,15 @@
 
-import { DynamoFM_UsageAction } from './usage-action.control-model';
+import { DyFM_UsageAction } from './usage-action.control-model';
 
-export type DFM_UsageData = DynamoFM_UsageData;
-export type DFM_UsageD = DynamoFM_UsageData;
-export class DynamoFM_UsageData {
+export type DyFM_UsageD = DyFM_UsageData;
+export class DyFM_UsageData {
   page?: string;
   opened?: Date;
   timeSpentOnPage?: number;
-  actions?: DynamoFM_UsageAction[] = [];
+  actions?: DyFM_UsageAction[] = [];
 
   constructor(
-    set?: DynamoFM_UsageData
+    set?: DyFM_UsageData
   ) {
     if (set) {
       Object.assign(this, set);

package/src/_models/data-models/custom-data.data-model.ts

@@ -1,14 +1,13 @@
 
-import { DynamoFM_DataModel_Params } from '../control-models/data-model-params.control-model';
-import { DynamoFM_Metadata } from './metadata.data-model';
+import { DyFM_DataModel_Params } from '../control-models/data-model-params.control-model';
+import { DyFM_Metadata } from './metadata.data-model';
 
-export type DFM_CustomData = DynamoFM_CustomData;
-export type DFM_CustomD = DynamoFM_CustomData;
-export class DynamoFM_CustomData<T = any> extends DynamoFM_Metadata {
+export type DyFM_CustomD = DyFM_CustomData;
+export class DyFM_CustomData<T = any> extends DyFM_Metadata {
   data?: T;
 
   constructor(
-    set?: DynamoFM_CustomData<T>
+    set?: DyFM_CustomData<T>
   ) {
     super(set);
 
@@ -18,8 +17,8 @@ export class DynamoFM_CustomData<T = any> extends DynamoFM_Metadata {
   }
 }
 
-export const DynamoFM_customDataModel_params: DynamoFM_DataModel_Params = 
-  new DynamoFM_DataModel_Params({
+export const DyFM_customDataModel_params: DyFM_DataModel_Params = 
+  new DyFM_DataModel_Params({
     dataName: 'customData',
     properties: [
       { key: 'data', type: 'string', required: true },