@futdevpro/fsm-dynamo 1.8.4 → 1.9.1

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

@@ -1,11 +1,11 @@
-import { Dynamo_error_defaults } from '../../_constants/error-defaults.const';
-import { Dynamo_ErrorLevel } from '../../_enums';
-import { Dynamo_Log } from '../../_utils/log.util';
-import { Dynamo_Metadata } from '../data-models/metadata.data-model';
+import { DynamoFM_error_defaults } from '../../_constants/error-defaults.const';
+import { DynamoFM_ErrorLevel } from '../../_enums';
+import { DynamoFM_Log } from '../../_utils/log.util';
+import { DynamoFM_Metadata } from '../data-models/metadata.data-model';
 
-export type D_Error = Dynamo_Error;
+export type DFM_Error = DynamoFM_Error;
 
-export interface Dynamo_Error_Settings {
+export interface DynamoFM_Error_Settings {
   _id?: string;
 
   handled?: boolean;
@@ -17,14 +17,14 @@ export interface Dynamo_Error_Settings {
   userMessageTranslateCode?: string;
   addECToUserMsg?: boolean;
 
-  error?: Dynamo_AnyError;
-  errors?: Dynamo_AnyError[];
+  error?: DynamoFM_AnyError;
+  errors?: DynamoFM_AnyError[];
 
   issuer?: string;
   issuerSystem?: string;
   issuerService?: string;
 
-  level?: Dynamo_ErrorLevel;
+  level?: DynamoFM_ErrorLevel;
 
   levelUpThis?: boolean;
   additionalContent?: any;
@@ -39,7 +39,7 @@ export interface Dynamo_Error_Settings {
   __v?: number;
 }
 
-/* export class Dynamo_Error_SettingsBuilder {
+/* export class DynamoFM_Error_SettingsBuilder {
 
   constructor(
     private serviceName: string,
@@ -50,15 +50,15 @@ export interface Dynamo_Error_Settings {
     set: {
       functionName: string,
 
-      error?: Dynamo_AnyError,
+      error?: DynamoFM_AnyError,
       errorMessage?: string,
       userMessge?: string,
-      errorLevel?: Dynamo_ErrorLevel,
+      errorLevel?: DynamoFM_ErrorLevel,
       errorCode?: string,
       defaultErrorUserMsg: string,
       issuer: string,
     }
-  ): Dynamo_Error_Settings {
+  ): DynamoFM_Error_Settings {
     return {
       status:  417,
       message: 
@@ -67,11 +67,11 @@ export interface Dynamo_Error_Settings {
         `${set.functionName} was UNSUCCESFUL (WB)`,
       userMessage: 
         set.userMessge ??
-          set.errorLevel === Dynamo_ErrorLevel.user ? 
+          set.errorLevel === DynamoFM_ErrorLevel.user ? 
           (set.error as Error)?.message :
-          (set.error as Dynamo_Error)?.__userMessage ?? set.defaultErrorUserMsg,
+          (set.error as DynamoFM_Error)?.__userMessage ?? set.defaultErrorUserMsg,
       addECToUserMsg: 
-        !(set.error as Dynamo_Error)?.__userMessage && 
+        !(set.error as DynamoFM_Error)?.__userMessage && 
         !set.errorLevel,
       issuer: this.issuer,
       issuerService: this.serviceName,
@@ -80,9 +80,9 @@ export interface Dynamo_Error_Settings {
   }
 } */
 
-export type Dynamo_AnyError = Error | Dynamo_Error;
+export type DynamoFM_AnyError = Error | DynamoFM_Error;
 
-export class Dynamo_Error extends Dynamo_Metadata {
+export class DynamoFM_Error extends DynamoFM_Metadata {
   readonly flag = 'DYNAMO-ERROR-OBJECT-v2';
 
   _errorCode?: string;
@@ -104,23 +104,23 @@ export class Dynamo_Error extends Dynamo_Metadata {
   ___issuerSystem?: string;
   ___issuerService?: string;
 
-  error?: Dynamo_AnyError;
-  errors?: Dynamo_AnyError[] = [];
+  error?: DynamoFM_AnyError;
+  errors?: DynamoFM_AnyError[] = [];
 
-  level?: Dynamo_ErrorLevel;
+  level?: DynamoFM_ErrorLevel;
   
   levelUpThis?: boolean;
   additionalContent?: any;
 
   constructor(
-    set?: Dynamo_Error_Settings
+    set?: DynamoFM_Error_Settings
   ) {
     super(
       set, 
       { 
         issuer: set?.issuerService ?? 
-          (set?.error as Dynamo_Error)?.___issuerService ?? 
-            Dynamo_error_defaults.issuerService 
+          (set?.error as DynamoFM_Error)?.___issuerService ?? 
+            DynamoFM_error_defaults.issuerService 
       }
     );
     
@@ -130,27 +130,27 @@ export class Dynamo_Error extends Dynamo_Metadata {
       }
 
       /** set simple properties */
-      this.___handled = Boolean(set?.handled ?? (set?.error as Dynamo_Error)?.___handled);
-      this.___status = set?.status ?? (set?.error as Dynamo_Error)?.___status;
+      this.___handled = Boolean(set?.handled ?? (set?.error as DynamoFM_Error)?.___handled);
+      this.___status = set?.status ?? (set?.error as DynamoFM_Error)?.___status;
       this.___issuer = set?.issuer ?? 
-        (set?.error as Dynamo_Error)?.___issuer ?? 
-          Dynamo_error_defaults.issuer;
+        (set?.error as DynamoFM_Error)?.___issuer ?? 
+          DynamoFM_error_defaults.issuer;
       this.___issuerSystem = set?.issuerSystem ??
-        (set?.error as Dynamo_Error)?.___issuerSystem ?? 
-          Dynamo_error_defaults.issuerSystem;
+        (set?.error as DynamoFM_Error)?.___issuerSystem ?? 
+          DynamoFM_error_defaults.issuerSystem;
       this.___issuerService = set?.issuerService ?? 
-        (set?.error as Dynamo_Error)?.___issuerService ?? 
-          Dynamo_error_defaults.issuerService;
+        (set?.error as DynamoFM_Error)?.___issuerService ?? 
+          DynamoFM_error_defaults.issuerService;
       
-      this.level = set?.level ?? (set?.error as Dynamo_Error)?.level ?? Dynamo_ErrorLevel.error;
+      this.level = set?.level ?? (set?.error as DynamoFM_Error)?.level ?? DynamoFM_ErrorLevel.error;
 
       this.levelUpThis = set?.levelUpThis;
       this.additionalContent = set?.additionalContent ?? 
-        (set?.error as Dynamo_Error)?.additionalContent ?? {};
+        (set?.error as DynamoFM_Error)?.additionalContent ?? {};
 
       /** set default error code */
       if (!set.errorCode) {
-        set.errorCode = Dynamo_error_defaults.errorCode;
+        set.errorCode = DynamoFM_error_defaults.errorCode;
       }
 
       /** set default error (self defined) */
@@ -165,12 +165,12 @@ export class Dynamo_Error extends Dynamo_Metadata {
       /** set errorCodes */
       let previousErrorCodes: string[] = [];
 
-      if ((set?.error as Dynamo_Error)?._errorCodes) {
-        previousErrorCodes.push(...((set?.error as Dynamo_Error)?._errorCodes ?? []));
+      if ((set?.error as DynamoFM_Error)?._errorCodes) {
+        previousErrorCodes.push(...((set?.error as DynamoFM_Error)?._errorCodes ?? []));
       }
 
       if (!set.errorCode) {
-        set.errorCode = Dynamo_error_defaults.errorCode;
+        set.errorCode = DynamoFM_error_defaults.errorCode;
       }
       previousErrorCodes = previousErrorCodes.filter(
         (code: string): boolean => code !== set.errorCode
@@ -180,7 +180,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
       /** bring up non NTS and non default first error */
       const filteredErrorCodes: string[] = this._errorCodes.filter(
         (code: string): boolean => 
-          code && code !== Dynamo_error_defaults.errorCode && !code.includes('NTS-')
+          code && code !== DynamoFM_error_defaults.errorCode && !code.includes('NTS-')
       );
 
       this._errorCode = filteredErrorCodes[0] ?? this._errorCodes?.[0];
@@ -192,7 +192,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if (!set.message) {
         /** simple - non-dynamo - error */
         if (
-          !(set?.error as Dynamo_Error)?.flag?.includes('DYNAMO') && 
+          !(set?.error as DynamoFM_Error)?.flag?.includes('DYNAMO') && 
           (set?.error as Error)?.message
         ) {
           set.message = (set?.error as Error)?.message;
@@ -200,14 +200,14 @@ export class Dynamo_Error extends Dynamo_Metadata {
         /** error not defined - self defining */
           const posFull = (set.error as Error).stack.split('\n')?.[1]?.split('\\');
 
-          set.message = Dynamo_error_defaults.message + '; ' + posFull[posFull.length - 1];
+          set.message = DynamoFM_error_defaults.message + '; ' + posFull[posFull.length - 1];
         }
       }
       /** set messages */
       let previousMessages: string[] = [];
       
-      if ((set?.error as Dynamo_Error)?._messages) {
-        previousMessages.push(...((set?.error as Dynamo_Error)?._messages ?? []));
+      if ((set?.error as DynamoFM_Error)?._messages) {
+        previousMessages.push(...((set?.error as DynamoFM_Error)?._messages ?? []));
       } else if ((set?.error as Error)?.message) {
         previousErrorCodes.push((set?.error as Error)?.message);
       }
@@ -219,7 +219,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if (
         -1 < highlightedErrorCodeIndex && 
         this._messages[highlightedErrorCodeIndex] && 
-        this._messages[highlightedErrorCodeIndex] !== Dynamo_error_defaults.message
+        this._messages[highlightedErrorCodeIndex] !== DynamoFM_error_defaults.message
       ) {
         this._message = this._messages[highlightedErrorCodeIndex];
       } else {
@@ -229,17 +229,17 @@ export class Dynamo_Error extends Dynamo_Metadata {
       /** set userMessages */
       let previousUserMessages: string[] = [];
 
-      if ((set?.error as Dynamo_Error)?.__userMessages) {
-        previousUserMessages.push(...((set?.error as Dynamo_Error)?.__userMessages ?? []));
+      if ((set?.error as DynamoFM_Error)?.__userMessages) {
+        previousUserMessages.push(...((set?.error as DynamoFM_Error)?.__userMessages ?? []));
       }
 
       if (!set.userMessage) {
-        set.userMessage = Dynamo_error_defaults.userMessage;
+        set.userMessage = DynamoFM_error_defaults.userMessage;
       }
 
       if (
         set.addECToUserMsg && 
-        set.userMessage !== Dynamo_error_defaults.userMessage && 
+        set.userMessage !== DynamoFM_error_defaults.userMessage && 
         set.errorCode
       ) {
         set.userMessage += `\nErrorCode: ${set.errorCode}`;
@@ -252,30 +252,30 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if (
         -1 < highlightedErrorCodeIndex && 
         this.__userMessages[highlightedErrorCodeIndex] && 
-        this.__userMessages[highlightedErrorCodeIndex] !== Dynamo_error_defaults.userMessage
+        this.__userMessages[highlightedErrorCodeIndex] !== DynamoFM_error_defaults.userMessage
       ) {
         this.__userMessage = this.__userMessages[highlightedErrorCodeIndex];
       } else {
         this.__userMessage = this.__userMessages.filter(
-          (msg: string): boolean => msg && msg !== Dynamo_error_defaults.userMessage
+          (msg: string): boolean => msg && msg !== DynamoFM_error_defaults.userMessage
         )?.[0];
       }
 
       /** set userMessageTranslateCode */
       set.userMessageTranslateCode = 
         set?.userMessageTranslateCode ?? 
-          (set?.error as Dynamo_Error)?.__userMessageTranslateCode;
+          (set?.error as DynamoFM_Error)?.__userMessageTranslateCode;
 
       /** set errors */
-      let previousErrors: Dynamo_AnyError[] = [];
+      let previousErrors: DynamoFM_AnyError[] = [];
 
-      if ((set?.error as Dynamo_Error)?.errors?.length) {
-        previousErrors.push(...(set.error as Dynamo_Error).errors);
-      } else if (typeof (set?.error as Dynamo_Error)?.errors == 'object') {
-        this.additionalContent.errors = (set?.error as Dynamo_Error).errors;
+      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;
       }
       previousErrors = previousErrors.filter(
-        (error: Dynamo_AnyError): boolean => error !== set.error
+        (error: DynamoFM_AnyError): boolean => error !== set.error
       );
       this.errors = [ ...previousErrors, set?.error ].filter(Boolean);
 
@@ -290,12 +290,12 @@ export class Dynamo_Error extends Dynamo_Metadata {
         }
       }
       this.error = this.errors?.[0];
-      this.errors.map((error: Dynamo_AnyError): any => {
-        if ((error as Dynamo_Error)?.flag?.includes('DYNAMO')) {
+      this.errors.map((error: DynamoFM_AnyError): any => {
+        if ((error as DynamoFM_Error)?.flag?.includes('DYNAMO')) {
           const subError = { ...(error ?? {}) };
           
-          if ((subError as Dynamo_Error)?.errors) {
-            delete (subError as Dynamo_Error).errors;
+          if ((subError as DynamoFM_Error)?.errors) {
+            delete (subError as DynamoFM_Error).errors;
           }
 
           return subError;
@@ -310,8 +310,8 @@ export class Dynamo_Error extends Dynamo_Metadata {
         console.error(this);
       }
     } catch (error) {
-      Dynamo_Log.error(
-        '\n\nInternal Dynamo ERROR: Failed to create Dynamo_Error...' +
+      DynamoFM_Log.error(
+        '\n\nInternal Dynamo ERROR: Failed to create DynamoFM_Error...' +
         '\nerror:\n', error, 
         '\n\ntrace:', new Error(), 
         '\n\nset:', set, 
@@ -320,46 +320,46 @@ export class Dynamo_Error extends Dynamo_Metadata {
     }
   }
 
-  getErrorSimplified(): Dynamo_Error {
-    const error: Dynamo_Error = { ...this };
+  getErrorSimplified(): DynamoFM_Error {
+    const error: DynamoFM_Error = { ...this };
 
     delete error.errors;
 
-    if ((error.error as Dynamo_Error)?.error) {
-      delete (error.error as Dynamo_Error).error;
+    if ((error.error as DynamoFM_Error)?.error) {
+      delete (error.error as DynamoFM_Error).error;
     }
 
-    if ((error.error as Dynamo_Error)?.errors) {
-      delete (error.error as Dynamo_Error).errors;
+    if ((error.error as DynamoFM_Error)?.errors) {
+      delete (error.error as DynamoFM_Error).errors;
     }
 
     return error;
   }
 
-  getErrorsFlat(): Dynamo_Error {
-    const error: Dynamo_Error = { ...this };
+  getErrorsFlat(): DynamoFM_Error {
+    const error: DynamoFM_Error = { ...this };
     
-    if ((error.error as Dynamo_Error)?.error) {
-      delete (error.error as Dynamo_Error).error;
+    if ((error.error as DynamoFM_Error)?.error) {
+      delete (error.error as DynamoFM_Error).error;
     }
 
-    if ((error.error as Dynamo_Error)?.errors) {
-      delete (error.error as Dynamo_Error).errors;
+    if ((error.error as DynamoFM_Error)?.errors) {
+      delete (error.error as DynamoFM_Error).errors;
     }
 
-    error.errors.map((err: Dynamo_Error): void => {
+    error.errors.map((err: DynamoFM_Error): void => {
       const subError = { ...(err ?? {}) };
 
       if (subError.errors) {
         delete subError.errors;
       }
 
-      if ((subError.error as Dynamo_Error)?.errors) {
-        delete (subError.error as Dynamo_Error).errors;
+      if ((subError.error as DynamoFM_Error)?.errors) {
+        delete (subError.error as DynamoFM_Error).errors;
       }
 
-      if ((subError.error as Dynamo_Error)?.error) {
-        delete (subError.error as Dynamo_Error).error;
+      if ((subError.error as DynamoFM_Error)?.error) {
+        delete (subError.error as DynamoFM_Error).error;
       }
     });
 

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

@@ -1,13 +1,13 @@
 import { Subscription, timer } from 'rxjs';
-import { Dynamo_Error } from './error.control-model';
+import { DynamoFM_Error } from './error.control-model';
 
-export type D_Poll<T> = Dynamo_Poll<T>;
+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 Dynamo_Poll<T> {
+export class DynamoFM_Poll<T> {
   poll: Subscription;
   running: boolean;
   private pollDo: (...args) => Promise<T>;
@@ -53,8 +53,8 @@ export class Dynamo_Poll<T> {
       this.stopOnFail = set.stopOnFail;
       this.startPoll(this.args);
     } catch (error) {
-      throw new Dynamo_Error({
-        message: 'Dynamo_Poll construcion failed.'
+      throw new DynamoFM_Error({
+        message: 'DynamoFM_Poll construcion failed.'
       });
     }
   }
@@ -71,14 +71,14 @@ export class Dynamo_Poll<T> {
             this.stop();
           }
 
-          throw new Dynamo_Error({
+          throw new DynamoFM_Error({
             message: 'DYNAMO ERROR: \nDynamoPoll: pollDo was UNSUCCESSFUL',
           });
         });
       });
       this.running = true;
     } catch (error) {
-      throw new Dynamo_Error({
+      throw new DynamoFM_Error({
         message: 'DYNAMO ERROR: \nDynamoPoll: startPoll was UNSUCCESSFUL',
         error: error,
       });
@@ -93,7 +93,7 @@ export class Dynamo_Poll<T> {
         this.startPoll(this.args);
       }
     } catch (error) {
-      throw new Dynamo_Error({
+      throw new DynamoFM_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 D_RangeValue<T> = Dynamo_RangeValue<T>;
-export type D_RangeV<T> = Dynamo_RangeValue<T>;
-export class Dynamo_RangeValue<T = number> {
+export type DFM_RangeValue<T> = DynamoFM_RangeValue<T>;
+export type DFM_RangeV<T> = DynamoFM_RangeValue<T>;
+export class DynamoFM_RangeValue<T = number> {
   readonly isRange: boolean = true;
 
   from: T;
   to: T;
 
   constructor(
-    from: T | Dynamo_RangeValue<T>,
+    from: T | DynamoFM_RangeValue<T>,
     to?: T,
   ) {
-    if ((from as Dynamo_RangeValue<T>).isRange) {
-      this.from = (from as Dynamo_RangeValue<T>).from;
-      this.to = (from as Dynamo_RangeValue<T>).to;
+    if ((from as DynamoFM_RangeValue<T>)?.isRange) {
+      this.from = (from as DynamoFM_RangeValue<T>).from;
+      this.to = (from as DynamoFM_RangeValue<T>).to;
 
       return;
     } else {
@@ -27,57 +27,57 @@ export class Dynamo_RangeValue<T = number> {
     return true; 
   }
 
-  newValues?(value: Dynamo_RangeValue<T>): void {
+  newValues?(value: DynamoFM_RangeValue<T>): void {
     this.from = value.from;
     this.to = value.to;
   }
 
-  addRange?(range: Dynamo_RangeValue<number>): void {
-    (this as Dynamo_RangeValue<number>).from += range.from;
-    (this as Dynamo_RangeValue<number>).to += range.to;
+  addRange?(range: DynamoFM_RangeValue<number>): void {
+    (this as DynamoFM_RangeValue<number>).from += range.from;
+    (this as DynamoFM_RangeValue<number>).to += range.to;
   }
   
-  subtractRange?(range: Dynamo_RangeValue<number>): void {
-    (this as Dynamo_RangeValue<number>).from -= range.from;
-    (this as Dynamo_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;
   }
 
-  multiplyRange?(range: Dynamo_RangeValue<number>): void {
-    (this as Dynamo_RangeValue<number>).from *= range.from;
-    (this as Dynamo_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;
   }
 
-  divideRange?(range: Dynamo_RangeValue<number>): void {
-    (this as Dynamo_RangeValue<number>).from /= range.from;
-    (this as Dynamo_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;
   }
 
   add?(value: number): void {
-    (this as Dynamo_RangeValue<number>).from += value;
-    (this as Dynamo_RangeValue<number>).to += value;
+    (this as DynamoFM_RangeValue<number>).from += value;
+    (this as DynamoFM_RangeValue<number>).to += value;
   }
 
   subtract?(value: number): void {
-    (this as Dynamo_RangeValue<number>).from -= value;
-    (this as Dynamo_RangeValue<number>).to -= value;
+    (this as DynamoFM_RangeValue<number>).from -= value;
+    (this as DynamoFM_RangeValue<number>).to -= value;
   }
 
   multiply?(value: number): void {
-    (this as Dynamo_RangeValue<number>).from *= value;
-    (this as Dynamo_RangeValue<number>).to *= value;
+    (this as DynamoFM_RangeValue<number>).from *= value;
+    (this as DynamoFM_RangeValue<number>).to *= value;
   }
 
   divide?(value: number): void {
-    (this as Dynamo_RangeValue<number>).from /= value;
-    (this as Dynamo_RangeValue<number>).to /= value;
+    (this as DynamoFM_RangeValue<number>).from /= value;
+    (this as DynamoFM_RangeValue<number>).to /= value;
   }
 
-  clone?(): Dynamo_RangeValue<T> {
-    return new Dynamo_RangeValue<T>(this.from, this.to);
+  clone?(): DynamoFM_RangeValue<T> {
+    return new DynamoFM_RangeValue<T>(this.from, this.to);
   }
 
-  applyTransform?<K = T>(transform: (value: T) => K): Dynamo_RangeValue<K> {
-    return new Dynamo_RangeValue<K>(transform(this.from), transform(this.to));
+  applyTransform?<K = T>(transform: (value: T) => K): DynamoFM_RangeValue<K> {
+    return new DynamoFM_RangeValue<K>(transform(this.from), transform(this.to));
   }
 
   toString? = this.stringify;
@@ -91,52 +91,52 @@ export class Dynamo_RangeValue<T = number> {
     }
   }
 
-  static reType<T>(value: Dynamo_RangeValue<T>): Dynamo_RangeValue<T> {
-    return new Dynamo_RangeValue<T>(value.from, value.to);
+  static reType<T>(value: DynamoFM_RangeValue<T>): DynamoFM_RangeValue<T> {
+    return new DynamoFM_RangeValue<T>(value.from, value.to);
   }
 
   static addRange(
-    a: Dynamo_RangeValue<number>, 
-    b: Dynamo_RangeValue<number>
-  ): Dynamo_RangeValue<number> {
-    return new Dynamo_RangeValue<number>(a.from + b.from, a.to + b.to);
+    a: DynamoFM_RangeValue<number>, 
+    b: DynamoFM_RangeValue<number>
+  ): DynamoFM_RangeValue<number> {
+    return new DynamoFM_RangeValue<number>(a.from + b.from, a.to + b.to);
   }
   
   static subtractRange(
-    from: Dynamo_RangeValue<number>, 
-    value: Dynamo_RangeValue<number>
-  ): Dynamo_RangeValue<number> {
-    return new Dynamo_RangeValue<number>(from.from - value.from, from.to - value.to);
+    from: DynamoFM_RangeValue<number>, 
+    value: DynamoFM_RangeValue<number>
+  ): DynamoFM_RangeValue<number> {
+    return new DynamoFM_RangeValue<number>(from.from - value.from, from.to - value.to);
   }
 
   static multiplyRange(
-    from: Dynamo_RangeValue<number>, 
-    value: Dynamo_RangeValue<number>
-  ): Dynamo_RangeValue<number> {
-    return new Dynamo_RangeValue<number>(from.from * value.from, from.to * value.to);
+    from: DynamoFM_RangeValue<number>, 
+    value: DynamoFM_RangeValue<number>
+  ): DynamoFM_RangeValue<number> {
+    return new DynamoFM_RangeValue<number>(from.from * value.from, from.to * value.to);
   }
 
   static divideRange(
-    from: Dynamo_RangeValue<number>, 
-    value: Dynamo_RangeValue<number>
-  ): Dynamo_RangeValue<number> {
-    return new Dynamo_RangeValue<number>(from.from / value.from, from.to / value.to);
+    from: DynamoFM_RangeValue<number>, 
+    value: DynamoFM_RangeValue<number>
+  ): DynamoFM_RangeValue<number> {
+    return new DynamoFM_RangeValue<number>(from.from / value.from, from.to / value.to);
   }
 
-  static add(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
-    return new Dynamo_RangeValue<number>(a.from + b, a.to + b);
+  static add(a: DynamoFM_RangeValue<number>, b: number): DynamoFM_RangeValue<number> {
+    return new DynamoFM_RangeValue<number>(a.from + b, a.to + b);
   }
 
-  static subtract(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
-    return new Dynamo_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 multiply(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
-    return new Dynamo_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 divide(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
-    return new Dynamo_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);
   }
 }
 

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

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

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

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