ia-common 1.0.1-beta.99 → 1.1.0

package/build/src/misc/model/dto-validation-type.d.ts

@@ -0,0 +1,13 @@
+export declare class Result<T, E> {
+    private readonly isOk;
+    private readonly _value?;
+    private readonly _error?;
+    private constructor();
+    static ok<T, E = never>(value: T): Result<T, E>;
+    static err<T = never, E = unknown>(error: E): Result<T, E>;
+    static void<E = never>(): Result<void, E>;
+    unwrap(): T;
+    unwrapErr(): E;
+    is_ok(): boolean;
+    is_err(): boolean;
+}

package/build/src/misc/model/dto-validation-type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+class Result {
+    constructor(isOk, _value, _error) {
+        this.isOk = isOk;
+        this._value = _value;
+        this._error = _error;
+    }
+    static ok(value) {
+        return new Result(true, value);
+    }
+    static err(error) {
+        return new Result(false, undefined, error);
+    }
+    static void() {
+        return new Result(true, undefined);
+    }
+    unwrap() {
+        if (!this.isOk) {
+            throw new Error(`Tried to unwrap an Err result: ${JSON.stringify(this._error)}`);
+        }
+        return this._value;
+    }
+    unwrapErr() {
+        if (this.isOk) {
+            throw new Error(`Tried to unwrapErr an Ok result: ${JSON.stringify(this._value)}`);
+        }
+        return this._error;
+    }
+    is_ok() {
+        return this.isOk;
+    }
+    is_err() {
+        return !this.isOk;
+    }
+}
+exports.Result = Result;

package/build/src/misc/type/arrayed.type.d.ts

@@ -0,0 +1,3 @@
+export type ConvertToArray<T> = {
+    [K in keyof T]: T[K][];
+};

package/build/src/misc/type/arrayed.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/{model → src/model}/bank-details-entity-model.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BankDetailsEntityModel = void 0;
-var BankDetailsEntityModel = /** @class */ (function () {
-    function BankDetailsEntityModel(bankDetailEntity) {
+class BankDetailsEntityModel {
+    constructor(bankDetailEntity) {
         Object.assign(this, bankDetailEntity);
     }
-    BankDetailsEntityModel.prototype.getQrCodeFolderName = function () {
+    getQrCodeFolderName() {
         var _a;
         return (_a = this.qrCode) === null || _a === void 0 ? void 0 : _a.split("/").slice(3, 5)[0];
-    };
-    BankDetailsEntityModel.prototype.getQrCodeFileName = function () {
+    }
+    getQrCodeFileName() {
         var _a;
         return (_a = this.qrCode) === null || _a === void 0 ? void 0 : _a.split("/").slice(3, 5)[1];
-    };
-    return BankDetailsEntityModel;
-}());
+    }
+}
 exports.BankDetailsEntityModel = BankDetailsEntityModel;

package/build/src/model/base.entity.model.d.ts

@@ -0,0 +1,14 @@
+import { EntityEnum, EntityIndexMap, VirtualEntityEnum } from "../interface/entity.utils.interface";
+export declare enum RelationType {
+    ONE = "one",
+    MANY = "many"
+}
+export declare abstract class BaseEntityModel<T extends EntityEnum | VirtualEntityEnum> {
+    protected entityName: T;
+    constructor(entityName: T);
+    abstract getRelationConfigs(): any[];
+    populateRelationsByIndex(entityIndexMap: EntityIndexMap): void;
+    static populateRelationsForEntities(entityIndexMap: EntityIndexMap, entityType: EntityEnum): void;
+    populateRelations(entityIndexMap: EntityIndexMap): void;
+    overwrite(entityIndexMap: EntityIndexMap, indexKey?: string): this;
+}

package/build/src/model/base.entity.model.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntityModel = exports.RelationType = void 0;
+var RelationType;
+(function (RelationType) {
+    RelationType["ONE"] = "one";
+    RelationType["MANY"] = "many";
+})(RelationType || (exports.RelationType = RelationType = {}));
+class BaseEntityModel {
+    constructor(entityName) {
+        this.entityName = entityName;
+    }
+    populateRelationsByIndex(entityIndexMap) {
+        for (const relationConfig of this.getRelationConfigs() || []) {
+            const thisMappingKey = relationConfig.mapKeyConfig.key;
+            const relatedMappingKey = relationConfig.mapKeyConfig.relationKey;
+            const thisKey = relationConfig.key;
+            // console.log('Populating relation for', relationConfig.name, 'on', this.entityName, relationConfig);
+            // debugger;
+            if (relationConfig.relation === RelationType.ONE) {
+                const relatedEntities = entityIndexMap[relationConfig.name] || {};
+                if (Object.is(relatedEntities, null))
+                    continue;
+                let foundRelatedEntities = [];
+                if (thisMappingKey.includes(".")) {
+                    const [parentKey, childKey] = thisMappingKey.split(".");
+                    console.log(`[populateRelationsByIndex] Checking nested relation "${relationConfig.name}" on entity "${this.entityName}" → parentKey="${parentKey}", childKey="${childKey}"`);
+                    if (!this[parentKey]) {
+                        console.warn(`[populateRelationsByIndex] Missing parent key "${parentKey}" on entity "${this.entityName}". Current entity:`, this);
+                        continue;
+                    }
+                    if (!this[parentKey][childKey]) {
+                        console.warn(`[populateRelationsByIndex] Missing child key "${childKey}" in parent "${parentKey}" on entity "${this.entityName}". Parent value:`, this[parentKey]);
+                        continue;
+                    }
+                    foundRelatedEntities = [relatedEntities[this[parentKey][childKey]]];
+                }
+                else {
+                    // foundRelatedEntities = relatedEntities[this[thisKey]] ? [relatedEntities[this[thisKey]]] : [];
+                    const relatedEntity = relatedEntities[this[thisMappingKey]];
+                    if (relatedEntity) {
+                        foundRelatedEntities = [relatedEntity];
+                    }
+                    else if (relatedMappingKey !== "id") {
+                        foundRelatedEntities = Object.values(relatedEntities).filter((entity) => entity[relatedMappingKey] === this[thisMappingKey]);
+                    }
+                    else {
+                        foundRelatedEntities = [];
+                    }
+                }
+                if (foundRelatedEntities.length > 1) {
+                    throw new Error(`Expected one related entity for ${relationConfig.name} but found ${foundRelatedEntities.length}`);
+                }
+                if (foundRelatedEntities.length === 0) {
+                    console.warn(`No related entity found for ${relationConfig.name} with ${thisMappingKey}=${this[relationConfig.mapKeyConfig.foreignKey]}`);
+                }
+                this[thisKey] = foundRelatedEntities[0];
+            }
+            else if (relationConfig.relation === RelationType.MANY) {
+                this[thisKey] = [];
+                const relatedEntities = entityIndexMap[relationConfig.name] || {};
+                for (const relatedEntity of Object.values(relatedEntities)) {
+                    if (relatedEntity[relatedMappingKey] === this[thisMappingKey]) {
+                        this[thisKey].push(relatedEntity);
+                    }
+                }
+            }
+        }
+    }
+    static populateRelationsForEntities(entityIndexMap, entityType) {
+        for (const key of Object.keys(entityIndexMap[entityType] || {})) {
+            const entity = entityIndexMap[entityType][key];
+            entity.populateRelationsByIndex(entityIndexMap);
+        }
+    }
+    populateRelations(entityIndexMap) {
+        this.populateRelationsByIndex(entityIndexMap);
+    }
+    overwrite(entityIndexMap, indexKey = "id") {
+        if (this[indexKey] === undefined) {
+            console.warn(`Entity of type ${this.entityName} does not have ${indexKey}, cannot merge`);
+            return this;
+        }
+        entityIndexMap[this.entityName][this[indexKey]] = this;
+        return this;
+    }
+}
+exports.BaseEntityModel = BaseEntityModel;

package/build/src/model/configurations-entity-model.d.ts

@@ -0,0 +1,16 @@
+import { IConfigurationsEntity } from "../@type";
+import { Configuration } from "../enum/configuration.enum";
+export declare class ConfigurationsModel implements IConfigurationsEntity {
+    id: number;
+    key: Configuration;
+    value: string;
+    description: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    text: string;
+    constructor(data: IConfigurationsEntity);
+    isCronJobKey(): boolean;
+    static findByKey(configurationEntities: IConfigurationsEntity[], key: Configuration): IConfigurationsEntity | undefined;
+}

package/build/src/model/configurations-entity-model.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationsModel = void 0;
+const configuration_enum_1 = require("../enum/configuration.enum");
+class ConfigurationsModel {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    isCronJobKey() {
+        return configuration_enum_1.Configuration.CronJobsConfigurationsKeys(this.key);
+    }
+    static findByKey(configurationEntities, key) {
+        return configurationEntities.find((configurationEntity) => configurationEntity.key === key);
+    }
+}
+exports.ConfigurationsModel = ConfigurationsModel;

package/build/src/model/corporate-actions/bonus-corporate-action-model.d.ts

@@ -0,0 +1,17 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { IBonusCorporateAction, ICorporateActionsEntity, ICorporateEntityOmitData } from "../../@type";
+export declare class BonusCorporateActionModel implements IBonusCorporateAction, ICorporateEntityOmitData {
+    ratio: string;
+    ratioInWords: string;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/bonus-corporate-action-model.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BonusCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class BonusCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.BONUS);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = Object.assign(Object.assign({}, this), { data: JSON.stringify({
+                ratio: this.ratio,
+                ratioInWords: this.ratioInWords,
+            }) });
+        return corporateActionEntity;
+    }
+}
+exports.BonusCorporateActionModel = BonusCorporateActionModel;

package/build/src/model/corporate-actions/buy-back-corporate-action-model.d.ts

@@ -0,0 +1,19 @@
+import { BuyBackType, CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { IBuyBackCorporateAction, ICorporateActionsEntity, ICorporateEntityOmitData } from "../../@type";
+export declare class BuyBackCorporateActionModel implements IBuyBackCorporateAction, ICorporateEntityOmitData {
+    priceRange: string;
+    startDate: number;
+    endDate: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    buyBackType: BuyBackType;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/buy-back-corporate-action-model.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuyBackCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class BuyBackCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.BUY_BACK);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = {
+            id: this.id,
+            data: JSON.stringify({
+                priceRange: this.priceRange,
+                startDate: this.startDate,
+                endDate: this.endDate,
+                buyBackType: this.buyBackType,
+            }),
+            companyName: this.companyName,
+            recordDate: this.recordDate,
+            type: this.type,
+            status: this.status,
+            createdOn: this.createdOn,
+            updatedOn: this.updatedOn,
+            createdBy: this.createdBy,
+            updatedBy: this.updatedBy,
+        };
+        return corporateActionEntity;
+    }
+}
+exports.BuyBackCorporateActionModel = BuyBackCorporateActionModel;

package/build/src/model/corporate-actions/corporate-action-model.d.ts

@@ -0,0 +1,37 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity } from "../../@type";
+import { BonusCorporateActionModel } from "./bonus-corporate-action-model";
+import { BuyBackCorporateActionModel } from "./buy-back-corporate-action-model";
+import { DelistingCorporateActionModel } from "./delisting-corporate-action-model";
+import { DividendCorporateActionModel } from "./dividend-corporate-action-model";
+import { FPOCorporateActionModel } from "./fpo-corporate-action-model";
+import { IPOCorporateActionModel } from "./ipo-corporate-action-model";
+import { OFSCorporateActionModel } from "./ofs-corporate-action-model";
+import { OpenOfferCorporateActionModel } from "./open-offer-corporate-action-model";
+import { RightIssueCorporateActionModel } from "./right-issue-corporate-action-model";
+import { SplitBonusCorporateActionModel } from "./split-bonus-corporate-action-model";
+import { SplitCorporateActionModel } from "./split-corporate-action-model";
+export declare class CorporateActionsModel implements ICorporateActionsEntity {
+    id: number;
+    data: string;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    status: CorporateActionsStatus;
+    constructor(data: ICorporateActionsEntity);
+    getFPOModel(): FPOCorporateActionModel;
+    getDividendModel(): DividendCorporateActionModel;
+    getBuyBackModel(): BuyBackCorporateActionModel;
+    getOpenOfferModel(): OpenOfferCorporateActionModel;
+    getDelistingModel(): DelistingCorporateActionModel;
+    getRightIssuesModel(): RightIssueCorporateActionModel;
+    getSplitStockModel(): SplitCorporateActionModel;
+    getBonusModel(): BonusCorporateActionModel;
+    getIPOModel(): IPOCorporateActionModel;
+    getSplitAndBonusStockModel(): SplitBonusCorporateActionModel;
+    getOFSModel(): OFSCorporateActionModel;
+}

package/build/src/model/corporate-actions/corporate-action-model.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorporateActionsModel = void 0;
+const bonus_corporate_action_model_1 = require("./bonus-corporate-action-model");
+const buy_back_corporate_action_model_1 = require("./buy-back-corporate-action-model");
+const delisting_corporate_action_model_1 = require("./delisting-corporate-action-model");
+const dividend_corporate_action_model_1 = require("./dividend-corporate-action-model");
+const fpo_corporate_action_model_1 = require("./fpo-corporate-action-model");
+const ipo_corporate_action_model_1 = require("./ipo-corporate-action-model");
+const ofs_corporate_action_model_1 = require("./ofs-corporate-action-model");
+const open_offer_corporate_action_model_1 = require("./open-offer-corporate-action-model");
+const right_issue_corporate_action_model_1 = require("./right-issue-corporate-action-model");
+const split_bonus_corporate_action_model_1 = require("./split-bonus-corporate-action-model");
+const split_corporate_action_model_1 = require("./split-corporate-action-model");
+class CorporateActionsModel {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    getFPOModel() {
+        return new fpo_corporate_action_model_1.FPOCorporateActionModel(this);
+    }
+    getDividendModel() {
+        return new dividend_corporate_action_model_1.DividendCorporateActionModel(this);
+    }
+    getBuyBackModel() {
+        return new buy_back_corporate_action_model_1.BuyBackCorporateActionModel(this);
+    }
+    getOpenOfferModel() {
+        return new open_offer_corporate_action_model_1.OpenOfferCorporateActionModel(this);
+    }
+    getDelistingModel() {
+        return new delisting_corporate_action_model_1.DelistingCorporateActionModel(this);
+    }
+    getRightIssuesModel() {
+        return new right_issue_corporate_action_model_1.RightIssueCorporateActionModel(this);
+    }
+    getSplitStockModel() {
+        return new split_corporate_action_model_1.SplitCorporateActionModel(this);
+    }
+    getBonusModel() {
+        return new bonus_corporate_action_model_1.BonusCorporateActionModel(this);
+    }
+    getIPOModel() {
+        return new ipo_corporate_action_model_1.IPOCorporateActionModel(this);
+    }
+    getSplitAndBonusStockModel() {
+        return new split_bonus_corporate_action_model_1.SplitBonusCorporateActionModel(this);
+    }
+    getOFSModel() {
+        return new ofs_corporate_action_model_1.OFSCorporateActionModel(this);
+    }
+}
+exports.CorporateActionsModel = CorporateActionsModel;

package/build/src/model/corporate-actions/delisting-corporate-action-model.d.ts

@@ -0,0 +1,18 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IDelistingCorporateAction } from "../../@type";
+export declare class DelistingCorporateActionModel implements IDelistingCorporateAction, ICorporateEntityOmitData {
+    floorPrice: number;
+    startDate: number;
+    endDate: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/delisting-corporate-action-model.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelistingCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class DelistingCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.DELISTING);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = Object.assign(Object.assign({}, this), { data: JSON.stringify({
+                floorPrice: this.floorPrice,
+                startDate: this.startDate,
+                endDate: this.endDate,
+            }) });
+        return corporateActionEntity;
+    }
+}
+exports.DelistingCorporateActionModel = DelistingCorporateActionModel;

package/build/src/model/corporate-actions/dividend-corporate-action-model.d.ts

@@ -0,0 +1,18 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IDividendCorporateAction } from "../../@type";
+export declare class DividendCorporateActionModel implements IDividendCorporateAction, ICorporateEntityOmitData {
+    type: CorporateActionsType;
+    percentageOnFaceValue: number;
+    dividendPerShare: number;
+    companyName: string;
+    recordDate: number;
+    faceValue: number;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/dividend-corporate-action-model.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DividendCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class DividendCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.DIVIDEND);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const createCorporateActionEntity = {
+            id: this.id,
+            data: JSON.stringify({
+                faceValue: this.faceValue,
+                percentageOnFaceValue: this.percentageOnFaceValue,
+                dividendPerShare: this.dividendPerShare,
+            }),
+            companyName: this.companyName,
+            recordDate: this.recordDate,
+            type: this.type,
+            status: this.status,
+            createdOn: this.createdOn,
+            updatedOn: this.updatedOn,
+            createdBy: this.createdBy,
+            updatedBy: this.updatedBy,
+        };
+        return createCorporateActionEntity;
+    }
+}
+exports.DividendCorporateActionModel = DividendCorporateActionModel;

package/build/src/model/corporate-actions/fpo-corporate-action-model.d.ts

@@ -0,0 +1,21 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity, IFPOCorporateAction } from "../../@type";
+export declare class FPOCorporateActionModel implements IFPOCorporateAction, ICorporateActionsEntity {
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    priceRange: string;
+    startDate: number;
+    endDate: number;
+    lotSize: number;
+    recommendation: string;
+    id: number;
+    data: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    status: CorporateActionsStatus;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/fpo-corporate-action-model.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FPOCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class FPOCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.FPO);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = Object.assign(Object.assign({}, this), { data: JSON.stringify({
+                lotSize: this.lotSize,
+                priceRange: this.priceRange,
+                startDate: this.startDate,
+                endDate: this.endDate,
+            }) });
+        return corporateActionEntity;
+    }
+}
+exports.FPOCorporateActionModel = FPOCorporateActionModel;

package/build/src/model/corporate-actions/ipo-corporate-action-model.d.ts

@@ -0,0 +1,20 @@
+import { CorporateActionsStatus, CorporateActionsType, IPOListingExchange } from "../../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IIPOCorporateAction } from "../../@type";
+export declare class IPOCorporateActionModel implements IIPOCorporateAction, ICorporateEntityOmitData {
+    startDate: number;
+    endDate: number;
+    priceRange: string;
+    listingAt: IPOListingExchange[];
+    lotSize: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/ipo-corporate-action-model.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPOCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class IPOCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.IPO);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = Object.assign(Object.assign({}, this), { data: JSON.stringify({
+                priceRange: this.priceRange,
+                listingAt: this.listingAt,
+                lotSize: this.lotSize,
+                startDate: this.startDate,
+                endDate: this.endDate,
+            }) });
+        return corporateActionEntity;
+    }
+}
+exports.IPOCorporateActionModel = IPOCorporateActionModel;

package/build/src/model/corporate-actions/ofs-corporate-action-model.d.ts

@@ -0,0 +1,18 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IOFSCorporateAction } from "../../@type";
+export declare class OFSCorporateActionModel implements IOFSCorporateAction, ICorporateEntityOmitData {
+    floorPrice: number;
+    startDate: number;
+    endDate: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/src/model/corporate-actions/ofs-corporate-action-model.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFSCorporateActionModel = void 0;
+const _enum_1 = require("../../@enum");
+const _utils_1 = require("../../@utils");
+class OFSCorporateActionModel {
+    constructor(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.OFS);
+        Object.assign(this, Object.assign(Object.assign({}, entity), JSON.parse(entity.data)));
+    }
+    getCorporateActionEntity() {
+        const corporateActionEntity = Object.assign(Object.assign({}, this), { data: JSON.stringify({
+                floorPrice: this.floorPrice,
+                startDate: this.startDate,
+                endDate: this.endDate,
+            }) });
+        return corporateActionEntity;
+    }
+}
+exports.OFSCorporateActionModel = OFSCorporateActionModel;

package/build/src/model/corporate-actions/open-offer-corporate-action-model.d.ts

@@ -0,0 +1,18 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IOpenOfferCorporateAction } from "../../@type";
+export declare class OpenOfferCorporateActionModel implements IOpenOfferCorporateAction, ICorporateEntityOmitData {
+    price: number;
+    startDate: number;
+    endDate: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}