gemcap-be-common 1.2.140 → 1.3.0

package/models/UploadedFile.model.ts

@@ -0,0 +1,57 @@
+import mongoose, { Document } from 'mongoose';
+
+import { EUploadTypes } from '../enums/upload-types.enum';
+import { MODEL_NAMES } from './_models';
+
+const mongooseLeanId = require('../plugins/id.plugin');
+
+export interface IUploadedFile {
+  filename: string;
+  originalName: string;
+  borrowerId: mongoose.Types.ObjectId;
+  userId: mongoose.Types.ObjectId;
+  converted?: boolean;
+  type: EUploadTypes;
+}
+
+export interface IUploadedFileDoc extends IUploadedFile, Document {
+}
+
+const UploadedFileSchema = new mongoose.Schema(
+  {
+    filename: {
+      type: String,
+      required: false,
+      trim: false,
+    },
+    originalName: {
+      type: String,
+      required: false,
+      trim: false,
+    },
+    borrowerId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: MODEL_NAMES.borrowers,
+      required: false,
+    },
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: MODEL_NAMES.users,
+      required: false,
+    },
+    converted: {
+      type: Boolean,
+      default: false,
+    },
+    type: {
+      type: String,
+      required: true,
+    },
+    __v: { type: Number, select: false },
+  },
+  { timestamps: true }
+);
+
+UploadedFileSchema.plugin(mongooseLeanId);
+
+export default mongoose.model<IUploadedFileDoc>(MODEL_NAMES.uploadedFile, UploadedFileSchema);

package/models/UploadedSheet.model.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose, { Document } from 'mongoose';
+import { IUploadedFileDoc } from './UploadedFile.model';
+export interface IUploadedSheetView {
+    _id: mongoose.Types.ObjectId;
+    fileId: mongoose.Types.ObjectId;
+    sheetName: string;
+    fileName: string;
+}
+export interface IUploadedSheet {
+    fileId: mongoose.Types.ObjectId;
+    sheetName: string;
+    total: number;
+}
+export interface IUploadedSheetDoc extends IUploadedSheet, Document {
+}
+export interface IUploadedSheetDocWithFile extends IUploadedSheetDoc {
+    file: IUploadedFileDoc;
+}
+declare const _default: mongoose.Model<IUploadedSheetDoc, {}, {}, {}, mongoose.Document<unknown, {}, IUploadedSheetDoc> & IUploadedSheetDoc & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default _default;

package/models/UploadedSheet.model.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const _models_1 = require("./_models");
+const mongooseLeanId = require('../plugins/id.plugin');
+const UploadedSheetSchema = new mongoose_1.default.Schema({
+    fileId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: _models_1.MODEL_NAMES.uploadedFile,
+        required: true,
+    },
+    sheetName: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    total: {
+        type: Number,
+        required: true,
+    },
+    __v: { type: Number, select: false },
+}, { timestamps: true });
+UploadedSheetSchema.plugin(mongooseLeanId);
+exports.default = mongoose_1.default.model(_models_1.MODEL_NAMES.uploadedSheets, UploadedSheetSchema);

package/models/UploadedSheet.model.ts

@@ -0,0 +1,51 @@
+import mongoose, { Document } from 'mongoose';
+
+import { IUploadedFileDoc } from './UploadedFile.model';
+import { MODEL_NAMES } from './_models';
+
+const mongooseLeanId = require('../plugins/id.plugin');
+
+export interface IUploadedSheetView {
+  _id: mongoose.Types.ObjectId;
+  fileId: mongoose.Types.ObjectId;
+  sheetName: string;
+  fileName: string;
+}
+
+export interface IUploadedSheet {
+  fileId: mongoose.Types.ObjectId;
+  sheetName: string;
+  total: number;
+}
+
+export interface IUploadedSheetDoc extends IUploadedSheet, Document {
+}
+
+export interface IUploadedSheetDocWithFile extends IUploadedSheetDoc {
+  file: IUploadedFileDoc;
+}
+
+const UploadedSheetSchema = new mongoose.Schema(
+  {
+    fileId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: MODEL_NAMES.uploadedFile,
+      required: true,
+    },
+    sheetName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    total: {
+      type: Number,
+      required: true,
+    },
+    __v: { type: Number, select: false },
+  },
+  { timestamps: true }
+);
+
+UploadedSheetSchema.plugin(mongooseLeanId);
+
+export default mongoose.model<IUploadedSheetDoc>(MODEL_NAMES.uploadedSheets, UploadedSheetSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemcap-be-common",
-  "version": "1.2.140",
+  "version": "1.3.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -10,6 +10,8 @@
   "author": "Nick Elovsky",
   "license": "ISC",
   "dependencies": {
+    "@sentry/node": "^8.55.0",
+    "aws-sdk": "^2.1691.0",
     "class-transformer": "^0.5.1",
     "dayjs": "^1.11.13",
     "decimal.js": "^10.4.3",
@@ -20,6 +22,10 @@
     "keycloak-connect": "^24.0.5",
     "lodash": "^4.17.21",
     "mongoose": "^8.3.1",
+    "nodemailer": "^6.9.15",
+    "pdfmake": "^0.2.12",
+    "redis": "^4.7.0",
+    "uuid": "^10.0.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
     "xlsx-js-style": "^1.2.0"
   },
@@ -27,6 +33,9 @@
     "@types/express": "^4.17.21",
     "@types/joi": "^17.2.3",
     "@types/lodash": "^4.17.10",
+    "@types/nodemailer": "^6.4.17",
+    "@types/pdfmake": "^0.2.9",
+    "@types/uuid": "^10.0.0",
     "typescript": "^5.3.3"
   }
 }

package/repositories/globals.repository.d.ts

@@ -0,0 +1,8 @@
+export declare class GlobalsRepository {
+    update(setting: {
+        [key: string]: any;
+    }, userId?: string): Promise<void>;
+    getSetting(setting: string): Promise<{
+        [x: string]: any;
+    }>;
+}

package/repositories/globals.repository.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalsRepository = void 0;
+const Globals_model_1 = require("../models/Globals.model");
+class GlobalsRepository {
+    async update(setting, userId) {
+        await Promise.all(Object.entries(setting).map(async ([setting, value]) => {
+            if (!!userId) {
+                await Globals_model_1.GlobalsModel.findOneAndUpdate({ setting }, { value, userId }, { upsert: true });
+            }
+            else {
+                await Globals_model_1.GlobalsModel.findOneAndUpdate({ setting }, { value }, { upsert: true });
+            }
+        }));
+    }
+    async getSetting(setting) {
+        const settingsValues = await Globals_model_1.GlobalsModel.findOne({ setting }).lean();
+        if (!settingsValues) {
+            return null;
+        }
+        return { [setting]: settingsValues.value };
+    }
+}
+exports.GlobalsRepository = GlobalsRepository;

package/repositories/globals.repository.ts

@@ -0,0 +1,21 @@
+import { GlobalsModel } from '../models/Globals.model';
+
+export class GlobalsRepository {
+  async update(setting: { [key: string]: any }, userId?: string) {
+    await Promise.all(Object.entries(setting).map(async ([setting, value]) => {
+      if (!!userId) {
+        await GlobalsModel.findOneAndUpdate({ setting }, { value, userId }, { upsert: true });
+      } else {
+        await GlobalsModel.findOneAndUpdate({ setting }, { value }, { upsert: true });
+      }
+    }));
+  }
+
+  async getSetting(setting: string) {
+    const settingsValues = await GlobalsModel.findOne({ setting }).lean();
+    if (!settingsValues) {
+      return null;
+    }
+    return { [setting]: settingsValues.value };
+  }
+}

package/services/attached-files.service.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose from 'mongoose';
+import AWS from 'aws-sdk';
+import { ITransactionAttachedFileDoc } from '../models/TransactionAttachedFile.Model';
+interface IAttachedFilesServiceDependencies {
+    saveFilesToAws: boolean;
+    rootDir: string;
+    s3Read: AWS.S3;
+    bucketName: string;
+}
+export declare class AttachedFilesService {
+    private readonly saveFilesToAws;
+    private readonly rootDir;
+    private readonly s3Read;
+    private readonly bucketName;
+    constructor(deps: IAttachedFilesServiceDependencies);
+    downloadAttachedFile(fileId: string): Promise<ITransactionAttachedFileDoc>;
+    getEffectiveDateList(borrowerId: string): Promise<string[]>;
+    getLatestEffectiveDate(borrowerId: string): Promise<string>;
+    getAttachedFilesByEffectiveDate(effectiveDate: string): Promise<(mongoose.Document<unknown, {}, ITransactionAttachedFileDoc> & ITransactionAttachedFileDoc & {
+        _id: mongoose.Types.ObjectId;
+    })[]>;
+    getAttachedFilesByEffectiveDatAndBorrowerId(effectiveDate: string, borrowerId: string): Promise<(mongoose.Document<unknown, {}, ITransactionAttachedFileDoc> & ITransactionAttachedFileDoc & {
+        _id: mongoose.Types.ObjectId;
+    })[]>;
+    createAttachedFile(file: {
+        filename: string;
+        originalName: string;
+    }, userId: string, effectiveDate: string, borrowerId: string): Promise<mongoose.Document<unknown, {}, ITransactionAttachedFileDoc> & ITransactionAttachedFileDoc & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getAttachedRealFilesByTransactionFileId(borrowerId: string, effectiveDate: string): Promise<any[]>;
+}
+export {};

package/services/attached-files.service.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachedFilesService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const path_1 = __importDefault(require("path"));
+const TransactionAttachedFile_Model_1 = require("../models/TransactionAttachedFile.Model");
+class AttachedFilesService {
+    saveFilesToAws;
+    rootDir;
+    s3Read;
+    bucketName;
+    constructor(deps) {
+        this.saveFilesToAws = deps.saveFilesToAws;
+        this.rootDir = deps.rootDir;
+        this.s3Read = deps.s3Read;
+        this.bucketName = deps.bucketName;
+    }
+    async downloadAttachedFile(fileId) {
+        const DBFile = await TransactionAttachedFile_Model_1.TransactionAttachedFileModel.findById(fileId).lean();
+        if (!DBFile) {
+            return null;
+        }
+        return DBFile;
+    }
+    async getEffectiveDateList(borrowerId) {
+        const result = await TransactionAttachedFile_Model_1.TransactionAttachedFileModel.aggregate([
+            {
+                $match: {
+                    borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+                },
+            },
+            {
+                $group: {
+                    _id: null,
+                    effectiveDates: { $addToSet: '$effectiveDate' },
+                },
+            },
+            {
+                $unwind: '$effectiveDates',
+            },
+            {
+                $sort: { 'effectiveDates': -1 },
+            },
+            {
+                $group: {
+                    _id: null,
+                    effectiveDates: { $push: '$effectiveDates' },
+                },
+            },
+        ]);
+        return result.reduce((acc, item) => [...acc, ...item.effectiveDates], []);
+    }
+    async getLatestEffectiveDate(borrowerId) {
+        const latsEffectiveDateDoc = await TransactionAttachedFile_Model_1.TransactionAttachedFileModel.find({ borrowerId }).sort({ effectiveDate: -1 }).limit(1).lean();
+        if (!latsEffectiveDateDoc.length) {
+            return null;
+        }
+        return latsEffectiveDateDoc[0].effectiveDate;
+    }
+    async getAttachedFilesByEffectiveDate(effectiveDate) {
+        return TransactionAttachedFile_Model_1.TransactionAttachedFileModel.find({ effectiveDate }).sort({ originalName: 1 });
+    }
+    async getAttachedFilesByEffectiveDatAndBorrowerId(effectiveDate, borrowerId) {
+        return TransactionAttachedFile_Model_1.TransactionAttachedFileModel.find({ effectiveDate, borrowerId }).sort({ originalName: 1 });
+    }
+    async createAttachedFile(file, userId, effectiveDate, borrowerId) {
+        const newFile = {
+            userId: new mongoose_1.default.Types.ObjectId(userId),
+            filename: file.filename,
+            originalName: file.originalName,
+            effectiveDate,
+            borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+        };
+        return await TransactionAttachedFile_Model_1.TransactionAttachedFileModel.create(newFile);
+    }
+    async getAttachedRealFilesByTransactionFileId(borrowerId, effectiveDate) {
+        const DBFiles = await TransactionAttachedFile_Model_1.TransactionAttachedFileModel.find({ effectiveDate, borrowerId }).lean();
+        if (this.saveFilesToAws) {
+            const downloadedFiles = [];
+            await Promise.all(DBFiles.map(async (file) => {
+                const fileData = await this.s3Read.getObject({
+                    Bucket: this.bucketName,
+                    Key: file.filename,
+                }).promise();
+                downloadedFiles.push({
+                    filename: file.originalName,
+                    content: fileData.Body,
+                });
+            }));
+            return downloadedFiles;
+        }
+        else {
+            return DBFiles.map((file) => ({
+                filename: file.originalName,
+                path: path_1.default.resolve(this.rootDir, file.filename),
+            }));
+        }
+    }
+}
+exports.AttachedFilesService = AttachedFilesService;

package/services/attached-files.service.ts

@@ -0,0 +1,123 @@
+import mongoose from 'mongoose';
+import path from 'path';
+import AWS from 'aws-sdk';
+
+import {
+  ITransactionAttachedFile,
+  ITransactionAttachedFileDoc,
+  TransactionAttachedFileModel,
+} from '../models/TransactionAttachedFile.Model';
+
+interface IAttachedFilesServiceDependencies {
+  saveFilesToAws: boolean;
+  rootDir: string;
+  s3Read: AWS.S3;
+  bucketName: string;
+}
+
+export class AttachedFilesService {
+  private readonly saveFilesToAws: boolean;
+  private readonly rootDir: string;
+  private readonly s3Read: AWS.S3;
+  private readonly bucketName: string;
+
+  constructor(
+    deps: IAttachedFilesServiceDependencies,
+  ) {
+    this.saveFilesToAws = deps.saveFilesToAws;
+    this.rootDir = deps.rootDir;
+    this.s3Read = deps.s3Read;
+    this.bucketName = deps.bucketName;
+  }
+
+
+  async downloadAttachedFile(fileId: string) {
+    const DBFile: ITransactionAttachedFileDoc = await TransactionAttachedFileModel.findById(fileId).lean();
+    if (!DBFile) {
+      return null;
+    }
+    return DBFile;
+  }
+
+  async getEffectiveDateList(borrowerId: string) {
+    const result = await TransactionAttachedFileModel.aggregate<{ _id: null, effectiveDates: string[] }>([
+      {
+        $match: {
+          borrowerId: new mongoose.Types.ObjectId(borrowerId),
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          effectiveDates: { $addToSet: '$effectiveDate' },
+        },
+      },
+      {
+        $unwind: '$effectiveDates',
+      },
+      {
+        $sort: { 'effectiveDates': -1 },
+      },
+      {
+        $group: {
+          _id: null,
+          effectiveDates: { $push: '$effectiveDates' },
+        },
+      },
+    ]);
+    return result.reduce((acc, item) => [...acc, ...item.effectiveDates], <string[]>[]);
+  }
+
+  async getLatestEffectiveDate(borrowerId: string) {
+    const latsEffectiveDateDoc = await TransactionAttachedFileModel.find({ borrowerId }).sort({ effectiveDate: -1 }).limit(1).lean();
+    if (!latsEffectiveDateDoc.length) {
+      return null;
+    }
+    return latsEffectiveDateDoc[0].effectiveDate;
+  }
+
+  async getAttachedFilesByEffectiveDate(effectiveDate: string) {
+    return TransactionAttachedFileModel.find({ effectiveDate }).sort({ originalName: 1 });
+  }
+
+  async getAttachedFilesByEffectiveDatAndBorrowerId(effectiveDate: string, borrowerId: string) {
+    return TransactionAttachedFileModel.find({ effectiveDate, borrowerId }).sort({ originalName: 1 });
+  }
+
+  async createAttachedFile(file: {
+    filename: string,
+    originalName: string
+  }, userId: string, effectiveDate: string, borrowerId: string) {
+    const newFile: ITransactionAttachedFile = {
+      userId: new mongoose.Types.ObjectId(userId),
+      filename: file.filename,
+      originalName: file.originalName,
+      effectiveDate,
+      borrowerId: new mongoose.Types.ObjectId(borrowerId),
+    };
+    return await TransactionAttachedFileModel.create(newFile);
+  }
+
+  async getAttachedRealFilesByTransactionFileId(borrowerId: string, effectiveDate: string) {
+    const DBFiles = await TransactionAttachedFileModel.find({ effectiveDate, borrowerId }).lean();
+    if (this.saveFilesToAws) {
+      const downloadedFiles = [];
+      await Promise.all(DBFiles.map(async (file) => {
+        const fileData = await this.s3Read.getObject({
+          Bucket: this.bucketName,
+          Key: file.filename,
+        }).promise();
+        downloadedFiles.push({
+          filename: file.originalName,
+          content: fileData.Body,
+        });
+      }));
+      return downloadedFiles;
+    } else {
+      return DBFiles.map((file) => ({
+        filename: file.originalName,
+        path: path.resolve(this.rootDir, file.filename),
+      }));
+    }
+  }
+}

package/services/availability.service.d.ts

@@ -0,0 +1,77 @@
+import { ELimitSettings, IReceivableAvailability, IAvailabilityLimits, IAvailabilitySettings, IAvailabilitySummary, IReceivableAvailabilityView } from '../models/ReceivableAvailability.model';
+import { IUserDocument } from '../models/User.model';
+import { IReceivableAvailabilityItemView } from '../models/ReceivableAvailabilityItem.model';
+import { IPaginatorOptions } from '../interfaces/collaterals.interface';
+import { IInventoryAvailabilitySummary, InventoryAvailabilityPaginators } from '../models/InventoryAvailability.model';
+import { IReserveSummary } from '../models/Reserve.model';
+import { IEquipmentSummary } from '../models/Equipment.model';
+import { ICollateralAdjustmentSummary } from '../models/CollateralAdjustment.model';
+import { CollateralAdjustmentsService } from './collateral-adjustments.service';
+import { CollateralsService } from './collaterals.service';
+import { EquipmentService } from './equipment.service';
+import { InventoryAvailabilityService } from './inventory-availability.service';
+import { LoanStatementService } from './loan-statement.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { ManualEntryService } from './manual-entry.service';
+import { ReserveService } from './reserve.service';
+import { SignsService } from './signs.service';
+type IMappedSettings = {
+    [_key in ELimitSettings]: number;
+};
+export interface IAvailabilityFullSummary {
+    reserve: IReserveSummary;
+    equipment: IEquipmentSummary;
+    inventory: IInventoryAvailabilitySummary[];
+    receivable: IAvailabilitySummary;
+    loanBalances: {
+        TERM: number;
+        REVOLVER: number;
+    };
+    collateralAdjustment: {
+        summary: ICollateralAdjustmentSummary;
+    };
+    manualInputs: {
+        receivableAvailability: boolean;
+        inventoryAvailability: boolean;
+    };
+    accruedStatement: number;
+}
+export declare const START_PAGINATORS: InventoryAvailabilityPaginators;
+export declare class AvailabilityService {
+    private readonly collateralAdjustmentsService;
+    private readonly collateralsService;
+    private readonly equipmentService;
+    private readonly inventoryAvailabilityService;
+    private readonly loanStatementService;
+    private readonly loanTransactionsService;
+    private readonly manualEntryService;
+    private readonly reserveService;
+    private readonly signsService;
+    constructor(collateralAdjustmentsService: CollateralAdjustmentsService, collateralsService: CollateralsService, equipmentService: EquipmentService, inventoryAvailabilityService: InventoryAvailabilityService, loanStatementService: LoanStatementService, loanTransactionsService: LoanTransactionsService, manualEntryService: ManualEntryService, reserveService: ReserveService, signsService: SignsService);
+    recombineGroups(calculationsSettings: IAvailabilitySettings): Promise<IMappedSettings>;
+    calculateAvailability(bbcDateId: string, paginatorOptions: IPaginatorOptions, user: IUserDocument): Promise<IReceivableAvailabilityView>;
+    getAvailability(bbcDateId: string, paginatorOptions: IPaginatorOptions, user: IUserDocument): Promise<IReceivableAvailabilityView>;
+    getAvailabilityItemsWithFilter(bbcDateId: string, itemsFilter: string): Promise<{
+        itemsFilter: any;
+        invoiceItems: any[];
+        customerItems: any[];
+    }>;
+    foundOrCreateAvailability(bbcDateId: string, paginatorOptions: IPaginatorOptions, user: IUserDocument): Promise<IReceivableAvailabilityView>;
+    findCalculatedAvailability(bbcDateId: string): Promise<IReceivableAvailabilityView>;
+    saveCalculatedAvailabilitySettings(bbcDateId: string, settings: IAvailabilitySettings): Promise<void>;
+    saveLimitSettings(bbcDateId: string, limitSettings: {
+        [limitSettingsName: string]: IAvailabilityLimits[];
+    }): Promise<void>;
+    calculateAvailabilitySummary(newCalculation: IReceivableAvailability): Promise<IAvailabilitySummary>;
+    saveCalculatedAvailability(newCalculation: IReceivableAvailability): Promise<void>;
+    getCalculationSettings(bbcDateId: string): Promise<IAvailabilitySettings>;
+    getAllSettings(bbcDateId?: string): Promise<{}>;
+    getAvailabilityItems(availabilityId: string, paginatorOptions: IPaginatorOptions): Promise<IReceivableAvailabilityItemView[]>;
+    getUniqueCustomers(availabilityId: string): Promise<{
+        customerTitle: string;
+    }[]>;
+    getAllSummaries(bbcDateId: string, user: IUserDocument): Promise<IAvailabilityFullSummary>;
+    isBBCEditable(bbcDateId: string): Promise<boolean>;
+    toggleManualReceivableAvailability(bbcDateId: string, useManualInputs: boolean): Promise<void>;
+}
+export {};