add missed record declaration

models/BonusProgram.ts

@@ -67,11 +67,10 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
-interface BonusProgram extends attributes, ORM {}
-export default BonusProgram;
+export interface BonusProgramRecord extends attributes, ORM {}
 
 let Model = {
-  beforeCreate(init: BonusProgram, cb:  (err?: string) => void) {
+  beforeCreate(init: BonusProgramRecord, cb:  (err?: string) => void) {
     if (!init.id) {
       init.id = uuid();
     }
@@ -184,7 +183,7 @@ let Model = {
    * Returns an array with currently possible bonus programs by order
    * @return BonusProgram[]
    */
-  async getAvailable(): Promise<BonusProgram[]> {
+  async getAvailable(): Promise<BonusProgramRecord[]> {
     return await BonusProgram.find({
         where: {
           // @ts-ignore TODO: First fix types
@@ -205,5 +204,5 @@ module.exports = {
 };
 
 declare global {
-  const BonusProgram: typeof Model & ORMModel<BonusProgram, null>;
+  const BonusProgram: typeof Model & ORMModel<BonusProgramRecord, null>;
 }

models/City.ts

@@ -29,11 +29,10 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
-interface City extends attributes, ORM {}
-export default City;
+export interface CityRecord extends attributes, ORM {}
 
 let Model = {
-  beforeCreate(streetInit: any, cb:  (err?: string) => void) {
+  beforeCreate(streetInit: CityRecord, cb:  (err?: string) => void) {
     if (!streetInit.id) {
       streetInit.id = uuid();
     }
@@ -49,5 +48,5 @@ module.exports = {
 };
 
 declare global {
-  const City: typeof Model & ORMModel<City, null>;
+  const City: typeof Model & ORMModel<CityRecord, null>;
 }

models/Dish.ts

@@ -279,7 +279,13 @@ interface IVirtualFields {
 }
 
 type attributes = typeof attributes;
+
+/**
+ * @deprecated use `DishRecord` instead
+ */
 interface Dish extends RequiredField<OptionalAll<attributes>, "name" | "price">, IVirtualFields, ORM {}
+export interface DishRecord extends RequiredField<OptionalAll<attributes>, "name" | "price">, IVirtualFields, ORM {}
+
 export default Dish;
 
 let Model = {
@@ -574,5 +580,5 @@ module.exports = {
 };
 
 declare global {
-  const Dish: typeof Model & ORMModel<Dish, "name" | "price">;
+  const Dish: typeof Model & ORMModel<DishRecord, "name" | "price">;
 }

models/Group.ts

@@ -150,11 +150,14 @@ interface IVirtualFields {
 }
 
 type attributes = typeof attributes;
+/**
+ * @deprecated use `GroupRecord` instead
+ */
 interface Group extends OptionalAll<attributes>, IVirtualFields, ORM {}
-export default Group;
+export interface GroupRecord extends OptionalAll<attributes>, IVirtualFields, ORM {}
 
 let Model = {
-  beforeCreate: async function(init: any, cb:  (err?: string) => void) {
+  beforeCreate: async function(init: GroupRecord, cb:  (err?: string) => void) {
     emitter.emit('core:group-before-create', init);
     if (!init.id) {
       init.id = uuid();

models/Maintenance.ts

@@ -37,26 +37,31 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
+
+/**
+ * @deprecated use `MaintenanceRecord` instead
+ */
 interface Maintenance extends attributes, ORM {}
+export interface MaintenanceRecord extends attributes, ORM {}
 export default Maintenance;
 
 let Model = {
-  afterCreate: function (maintenance, cb:  (err?: string) => void) {
+  afterCreate: function (maintenance: MaintenanceRecord, cb:  (err?: string) => void) {
     checkMaintenance()
     cb();
   },
 
-  afterUpdate: function (maintenance, cb:  (err?: string) => void) {
+  afterUpdate: function (maintenance: MaintenanceRecord, cb:  (err?: string) => void) {
     checkMaintenance()
     cb();
   },
 
-  afterDestroy: function (maintenance, cb:  (err?: string) => void) {
+  afterDestroy: function (maintenance: MaintenanceRecord, cb:  (err?: string) => void) {
     checkMaintenance();
     cb();
   },
 
-  beforeCreate: function (maintenance, cb:  (err?: string) => void) {
+  beforeCreate: function (maintenance: { id: string; }, cb:  (err?: string) => void) {
     if(!maintenance.id){
       maintenance.id = uuid();
     }

models/MediaFile.ts

@@ -53,12 +53,15 @@ let attributes = {
   uploadDate: "string",
 };
 type attributes = typeof attributes;
+/**
+ * @deprecated use MediaFileRecord
+ */
 interface MediaFile extends OptionalAll<attributes>, ORM { }
+
 /** @deprecated use `MediaFileRecord` */
 export type IMediaFile = OptionalAll<attributes>;
-export type MediaFileRecord = OptionalAll<attributes>;
 
-// export default IMediaFile;
+export interface MediaFileRecord extends OptionalAll<attributes>, ORM { }
 
 let Model = {
   beforeCreate(imageInit: any, cb: (err?: string) => void) {

models/OneTimePassword.ts

@@ -23,11 +23,16 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
+
+/**
+ * @deprecated use `OneTimePasswordRecord` instead
+ */
 interface OneTimePassword extends RequiredField<OptionalAll<attributes>, "login" >, ORM {}
-export default OneTimePassword;
+export interface OneTimePasswordRecord extends RequiredField<OptionalAll<attributes>, "login" >, ORM {}
+
 
 let Model = {
-  beforeCreate(record: any, cb:  (err?: string) => void) {
+  beforeCreate(record: OneTimePasswordRecord, cb:  (err?: string) => void) {
     if (!record.password) {
       record.password = generateOtp();
     }
@@ -64,22 +69,19 @@ module.exports = {
 };
 
 declare global {
-  const OneTimePassword: typeof Model & ORMModel<OneTimePassword,  "login" >;
+  const OneTimePassword: typeof Model & ORMModel<OneTimePasswordRecord,  "login" >;
 }
 
 
 function generateOtp() {
-
   if (process.env.NODE_ENV !== "production" && process.env.DEFAULT_OTP){
     return process.env.DEFAULT_OTP;
   }
-
-  var digits = '1234567890';
-  var otp = ''
+  
+  let digits = '1234567890';
+  let otp = ''
   for (let i = 0; i < 6; i++) {
       otp += digits[Math.floor(Math.random() * 10)];
   }
-
-
   return otp;
 }

models/Order.ts

@@ -23,6 +23,7 @@ import { OrderHelper } from "../libs/helpers/OrderHelper";
 import { GroupModifier } from "../interfaces/Modifier";
 import { isValue } from "../utils/isValue";
 import { or } from "ajv/dist/compile/codegen";
+
 export interface PromotionState {
   type: string;
   message: string;
@@ -343,9 +344,11 @@ interface stateFlowInstance {
 }
 
 type attributes = typeof attributes & stateFlowInstance;
+/**
+ * @deprecated use `OrderRecord` instead
+ */
 interface Order extends ORM, OptionalAll<attributes> { }
-
-export default Order;
+export interface OrderRecord extends ORM, OptionalAll<attributes> { }
 
 let Model = {
   beforeCreate(orderInit: Order, cb: (err?: string) => void) {
@@ -1752,7 +1755,7 @@ module.exports = {
 
 declare global {
   // Typescript export
-  const Order: typeof Model & ORMModel<Order, null> & StateFlowModel;
+  const Order: typeof Model & ORMModel<OrderRecord, null> & StateFlowModel;
 }
 
 // LOCAL HELPERS

models/OrderDish.ts

@@ -2,7 +2,7 @@ import ORM from "../interfaces/ORM";
 import { ORMModel } from "../interfaces/ORMModel";
 
 import Dish from "../models/Dish";
-import Order from "../models/Order";
+import {OrderRecord} from "../models/Order";
 import { Modifier, OrderModifier } from "../interfaces/Modifier";
 import { OptionalAll, RequiredField } from "../interfaces/toolsTS";
 
@@ -31,7 +31,7 @@ let attributes = {
   /** */
   order: {
     model: "Order",
-  } as unknown as Order | any,
+  } as unknown as OrderRecord | string,
 
   /** Position price*/
   itemTotal: "number" as unknown as number,
@@ -87,8 +87,12 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
+/**
+ * @deprecated use `OrderDishRecord` instead
+ */
 interface OrderDish extends RequiredField<OptionalAll<attributes>, "dish" | "amount" >, ORM {}
-export default OrderDish;
+
+export interface OrderDishRecord extends RequiredField<OptionalAll<attributes>, "dish" | "amount" >, ORM {}
 
 let Model = {
 };
@@ -100,5 +104,5 @@ module.exports = {
 };
 
 declare global {
-  const OrderDish: typeof Model & ORMModel<OrderDish, "dish" | "amount">;
+  const OrderDish: typeof Model & ORMModel<OrderDishRecord, "dish" | "amount">;
 }

models/PaymentDocument.ts

@@ -102,10 +102,14 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
+/**
+ * @deprecated use PaymentDocumentRecord instead
+ */
 interface PaymentDocument extends OptionalAll<attributes>, ORM {}
-export default PaymentDocument;
+export interface PaymentDocumentRecord extends OptionalAll<attributes>, ORM {}
+
 let Model = {
-  beforeCreate(paymentDocumentInit: any, cb:  (err?: string) => void) {
+  beforeCreate(paymentDocumentInit: PaymentDocumentRecord, cb:  (err?: string) => void) {
     if (!paymentDocumentInit.id) {
       paymentDocumentInit.id = uuid();
     }
@@ -119,7 +123,7 @@ let Model = {
     emitter.emit("core:payment-document-check", self);
     try {
       let paymentAdapter: PaymentAdapter = await PaymentMethod.getAdapterById(self.paymentMethod);
-      let checkedPaymentDocument: PaymentDocument = await paymentAdapter.checkPayment(self);
+      let checkedPaymentDocument: PaymentDocumentRecord = await paymentAdapter.checkPayment(self);
       sails.log.silly("checkedPaymentDocument >> ", checkedPaymentDocument)
 
 
@@ -150,7 +154,7 @@ let Model = {
     checkAmount(amount);
     await checkOrigin(originModel, originModelId);
     await checkPaymentMethod(paymentMethodId);
-    var id: string = uuid();
+    let id: string = uuid();
     id = id.replace(/-/g, '').toUpperCase();
     let payment: Payment = {
       id: id,
@@ -164,7 +168,7 @@ let Model = {
 
     emitter.emit("core:payment-document-before-create", payment);
     try {
-      await PaymentDocument.create(payment as PaymentDocument).fetch();
+      await PaymentDocument.create(payment as PaymentDocumentRecord).fetch();
     } catch (e) {
       sails.log.error("Error in paymentAdapter.createPayment :", e);
       throw {
@@ -250,7 +254,7 @@ module.exports = {
 };
 
 declare global {
-  const PaymentDocument: typeof Model & ORMModel<PaymentDocument, null>;
+  const PaymentDocument: typeof Model & ORMModel<PaymentDocumentRecord, null>;
 }
 
 ////////////////////////////// LOCAL

models/PaymentMethod.ts

@@ -5,7 +5,7 @@ import PaymentAdapter from "../adapters/payment/PaymentAdapter";
 import { OptionalAll, RequiredField } from "../interfaces/toolsTS";
 import { PaymentMethodType } from "../libs/enums/PaymentMethodTypes";
 
-var alivePaymentMethods: {} = {};
+let alivePaymentMethods = {} as {[k: string]: PaymentAdapter } ;
 
 interface ExternalPayment {
   name: string;
@@ -58,16 +58,20 @@ let attributes = {
 };
 
 type attributes = typeof attributes;
+/**
+ * @deprecated use `PaymentMethodRecord` instead
+ */
 interface PaymentMethod extends RequiredField<OptionalAll<attributes>, "type" | "adapter" | "enable">, ORM {}
-export default PaymentMethod;
+export interface PaymentMethodRecord extends RequiredField<OptionalAll<attributes>, "type" | "adapter" | "enable">, ORM {}
+
 let Model = {
   /**
    * Returns the authority of payment Adapter by the famous name Adapter
    * @return PaymentAdapter
    * @param adapter
    */
   async getAdapter(adapter?: string): Promise<PaymentAdapter> {
-    var paymentMethod: PaymentMethod;
+    let paymentMethod: PaymentMethodRecord;
     if (!adapter) {
       paymentMethod = this;
     } else {
@@ -83,7 +87,7 @@ let Model = {
     }
   },
 
-  beforeCreate: function (paymentMethod, cb: (err?: string) => void) {
+  beforeCreate: function (paymentMethod: PaymentMethodRecord, cb: (err?: string) => void) {
     if (!paymentMethod.id) {
       paymentMethod.id = uuid();
     }
@@ -96,7 +100,7 @@ let Model = {
    * @return
    */
   async isPaymentPromise(paymentMethodId?: string): Promise<boolean> {
-    var checkingPaymentMethod: PaymentMethod;
+    let checkingPaymentMethod: PaymentMethodRecord;
 
     if (!paymentMethodId) {
       checkingPaymentMethod = this;
@@ -151,7 +155,7 @@ let Model = {
    * Returns an array with possible methods of payment for ORDER
    * @return array of types of payments
    */
-  async getAvailable(): Promise<PaymentMethod[]> {
+  async getAvailable(): Promise<PaymentMethodRecord[]> {
     return await PaymentMethod.find({
       where: {
         or: [
@@ -226,5 +230,5 @@ module.exports = {
 };
 
 declare global {
-  const PaymentMethod: typeof Model & ORMModel<PaymentMethod, "type" | "adapter" | "enable">;
+  const PaymentMethod: typeof Model & ORMModel<PaymentMethodRecord, "type" | "adapter" | "enable">;
 }