@grapadigital/shared-schemas 1.0.65 → 1.0.67

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './schemas/influencer.schema';
 export * from './schemas/supplier.schema';
 export * from './schemas/campaign.schema';
 export * from './schemas/payment.schema';
+export * from './schemas/payment_new.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/token.schema';

package/dist/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./schemas/influencer.schema"), exports);
 __exportStar(require("./schemas/supplier.schema"), exports);
 __exportStar(require("./schemas/campaign.schema"), exports);
 __exportStar(require("./schemas/payment.schema"), exports);
+__exportStar(require("./schemas/payment_new.schema"), exports);
 __exportStar(require("./schemas/profile.schema"), exports);
 __exportStar(require("./schemas/recruitment.schema"), exports);
 __exportStar(require("./schemas/token.schema"), exports);

package/dist/schemas/invoice.schema.d.ts

@@ -52,6 +52,7 @@ declare class Canceled {
 declare class Note {
     text: string;
     owner: string;
+    createdAt: Date;
 }
 export declare class Invoice {
     _id?: Types.ObjectId;

package/dist/schemas/invoice.schema.js

@@ -99,6 +99,10 @@ __decorate([
     (0, mongoose_1.Prop)({ required: true }),
     __metadata("design:type", String)
 ], Note.prototype, "owner", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: true }),
+    __metadata("design:type", Date)
+], Note.prototype, "createdAt", void 0);
 Note = __decorate([
     (0, mongoose_1.Schema)({ _id: false })
 ], Note);

package/dist/schemas/payment_new.schema.d.ts

@@ -0,0 +1,187 @@
+/// <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" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import { HydratedDocument, Schema as MongooseSchema, Types } from 'mongoose';
+import { Influencer } from './influencer.schema';
+import { Supplier } from './supplier.schema';
+import { Action } from './action.schema';
+import { Recruitment } from './recruitment.schema';
+import { Sale } from './sale.schema';
+export type PaymentNewDocument = HydratedDocument<PaymentNew>;
+declare class Requester {
+    name: string;
+    email: string;
+    team: string;
+}
+export declare class Review {
+    type: 'influencer' | 'advisor' | 'supplier' | 'employee';
+    beneficiary: Types.ObjectId | Influencer | Supplier;
+    value: number;
+    description: string;
+    emissionNotes: string;
+}
+export declare const ReviewSchema: MongooseSchema<Review, import("mongoose").Model<Review, any, any, any, import("mongoose").Document<unknown, any, Review> & Review & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Review, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Review>> & import("mongoose").FlatRecord<Review> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Processing {
+    emissionNotes: string;
+    revisedDueDate: Date;
+    revisedIssueDate: Date;
+}
+export declare const ProcessingSchema: MongooseSchema<Processing, import("mongoose").Model<Processing, any, any, any, import("mongoose").Document<unknown, any, Processing> & Processing & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Processing, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Processing>> & import("mongoose").FlatRecord<Processing> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Approval {
+    name: string;
+    approvedAt: Date;
+}
+export declare const ApprovalSchema: MongooseSchema<Approval, import("mongoose").Model<Approval, any, any, any, import("mongoose").Document<unknown, any, Approval> & Approval & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Approval, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Approval>> & import("mongoose").FlatRecord<Approval> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Requested {
+    date: Date;
+}
+export declare const RequestedSchema: MongooseSchema<Requested, import("mongoose").Model<Requested, any, any, any, import("mongoose").Document<unknown, any, Requested> & Requested & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Requested, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Requested>> & import("mongoose").FlatRecord<Requested> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Queued {
+    issueDate: Date;
+    dueDate: Date;
+    code: string;
+}
+export declare const QueuedSchema: MongooseSchema<Queued, import("mongoose").Model<Queued, any, any, any, import("mongoose").Document<unknown, any, Queued> & Queued & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Queued, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Queued>> & import("mongoose").FlatRecord<Queued> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Paid {
+    date: Date;
+}
+export declare const PaidSchema: MongooseSchema<Paid, import("mongoose").Model<Paid, any, any, any, import("mongoose").Document<unknown, any, Paid> & Paid & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Paid, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Paid>> & import("mongoose").FlatRecord<Paid> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Canceled {
+    reason: string;
+    notes: string;
+}
+export declare const CanceledSchema: MongooseSchema<Canceled, import("mongoose").Model<Canceled, any, any, any, import("mongoose").Document<unknown, any, Canceled> & Canceled & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Canceled, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Canceled>> & import("mongoose").FlatRecord<Canceled> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Note {
+    text: string;
+    owner: string;
+    createdAt: Date;
+}
+export declare const NoteSchema: MongooseSchema<Note, import("mongoose").Model<Note, any, any, any, import("mongoose").Document<unknown, any, Note> & Note & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Note, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Note>> & import("mongoose").FlatRecord<Note> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class PaymentNew {
+    _id?: Types.ObjectId;
+    title: string;
+    requester: Requester;
+    review?: Review;
+    processing?: Processing;
+    approval?: Approval;
+    requested?: Requested;
+    queued?: Queued;
+    paid?: Paid;
+    canceled?: Canceled;
+    notes?: Note[];
+    installmentNumber: number;
+    additionalComments?: string;
+    phase: 'review' | 'processing' | 'approval' | 'awaiting' | 'requested' | 'queued' | 'paid' | 'client' | 'canceled';
+    sale: Types.ObjectId | Sale;
+    action: Types.ObjectId | Action;
+    recruitment: Types.ObjectId | Recruitment;
+}
+export declare const PaymentNewSchema: MongooseSchema<PaymentNew, import("mongoose").Model<PaymentNew, any, any, any, import("mongoose").Document<unknown, any, PaymentNew> & PaymentNew & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PaymentNew, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PaymentNew>> & import("mongoose").FlatRecord<PaymentNew> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare const PaymentNewModel: import("mongoose").Model<PaymentNew, {}, {}, {}, import("mongoose").Document<unknown, {}, PaymentNew> & PaymentNew & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, MongooseSchema<PaymentNew, import("mongoose").Model<PaymentNew, any, any, any, import("mongoose").Document<unknown, any, PaymentNew> & PaymentNew & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PaymentNew, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PaymentNew>> & import("mongoose").FlatRecord<PaymentNew> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>>;
+export {};

package/dist/schemas/payment_new.schema.js

@@ -0,0 +1,257 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentNewModel = exports.PaymentNewSchema = exports.PaymentNew = exports.NoteSchema = exports.Note = exports.CanceledSchema = exports.Canceled = exports.PaidSchema = exports.Paid = exports.QueuedSchema = exports.Queued = exports.RequestedSchema = exports.Requested = exports.ApprovalSchema = exports.Approval = exports.ProcessingSchema = exports.Processing = exports.ReviewSchema = exports.Review = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+let Requester = class Requester {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Requester.prototype, "name", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Requester.prototype, "email", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Requester.prototype, "team", void 0);
+Requester = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Requester);
+const RequesterSchema = mongoose_1.SchemaFactory.createForClass(Requester);
+let Review = class Review {
+};
+__decorate([
+    (0, mongoose_1.Prop)({ type: String, enum: ['influencer', 'advisor', 'supplier', 'employee'] }),
+    __metadata("design:type", String)
+], Review.prototype, "type", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, refPath: 'review.type' }),
+    __metadata("design:type", Object)
+], Review.prototype, "beneficiary", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], Review.prototype, "value", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Review.prototype, "description", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Review.prototype, "emissionNotes", void 0);
+Review = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Review);
+exports.Review = Review;
+exports.ReviewSchema = mongoose_1.SchemaFactory.createForClass(Review);
+let Processing = class Processing {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Processing.prototype, "emissionNotes", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Processing.prototype, "revisedDueDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Processing.prototype, "revisedIssueDate", void 0);
+Processing = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Processing);
+exports.Processing = Processing;
+exports.ProcessingSchema = mongoose_1.SchemaFactory.createForClass(Processing);
+let Approval = class Approval {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Approval.prototype, "name", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Approval.prototype, "approvedAt", void 0);
+Approval = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Approval);
+exports.Approval = Approval;
+exports.ApprovalSchema = mongoose_1.SchemaFactory.createForClass(Approval);
+let Requested = class Requested {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Requested.prototype, "date", void 0);
+Requested = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Requested);
+exports.Requested = Requested;
+exports.RequestedSchema = mongoose_1.SchemaFactory.createForClass(Requested);
+let Queued = class Queued {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Queued.prototype, "issueDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Queued.prototype, "dueDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Queued.prototype, "code", void 0);
+Queued = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Queued);
+exports.Queued = Queued;
+exports.QueuedSchema = mongoose_1.SchemaFactory.createForClass(Queued);
+let Paid = class Paid {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Paid.prototype, "date", void 0);
+Paid = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Paid);
+exports.Paid = Paid;
+exports.PaidSchema = mongoose_1.SchemaFactory.createForClass(Paid);
+let Canceled = class Canceled {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Canceled.prototype, "reason", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Canceled.prototype, "notes", void 0);
+Canceled = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Canceled);
+exports.Canceled = Canceled;
+exports.CanceledSchema = mongoose_1.SchemaFactory.createForClass(Canceled);
+let Note = class Note {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Note.prototype, "text", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Note.prototype, "owner", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Note.prototype, "createdAt", void 0);
+Note = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Note);
+exports.Note = Note;
+exports.NoteSchema = mongoose_1.SchemaFactory.createForClass(Note);
+let PaymentNew = class PaymentNew {
+};
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, auto: true }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], PaymentNew.prototype, "_id", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], PaymentNew.prototype, "title", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: RequesterSchema, required: true }),
+    __metadata("design:type", Requester)
+], PaymentNew.prototype, "requester", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.ReviewSchema, required: false }),
+    __metadata("design:type", Review)
+], PaymentNew.prototype, "review", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.ProcessingSchema, required: false }),
+    __metadata("design:type", Processing)
+], PaymentNew.prototype, "processing", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.ApprovalSchema, required: false }),
+    __metadata("design:type", Approval)
+], PaymentNew.prototype, "approval", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.RequestedSchema, required: false }),
+    __metadata("design:type", Requested)
+], PaymentNew.prototype, "requested", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.QueuedSchema, required: false }),
+    __metadata("design:type", Queued)
+], PaymentNew.prototype, "queued", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.PaidSchema, required: false }),
+    __metadata("design:type", Paid)
+], PaymentNew.prototype, "paid", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.CanceledSchema, required: false }),
+    __metadata("design:type", Canceled)
+], PaymentNew.prototype, "canceled", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: [exports.NoteSchema], default: [] }),
+    __metadata("design:type", Array)
+], PaymentNew.prototype, "notes", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], PaymentNew.prototype, "installmentNumber", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: false }),
+    __metadata("design:type", String)
+], PaymentNew.prototype, "additionalComments", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({
+        type: String,
+        enum: [
+            'review',
+            'processing',
+            'approval',
+            'awaiting',
+            'requested',
+            'queued',
+            'paid',
+            'client',
+            'canceled',
+        ],
+    }),
+    __metadata("design:type", String)
+], PaymentNew.prototype, "phase", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Sale' }),
+    __metadata("design:type", Object)
+], PaymentNew.prototype, "sale", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Action' }),
+    __metadata("design:type", Object)
+], PaymentNew.prototype, "action", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Recruitment' }),
+    __metadata("design:type", Object)
+], PaymentNew.prototype, "recruitment", void 0);
+PaymentNew = __decorate([
+    (0, mongoose_1.Schema)({ timestamps: true })
+], PaymentNew);
+exports.PaymentNew = PaymentNew;
+exports.PaymentNewSchema = mongoose_1.SchemaFactory.createForClass(PaymentNew);
+exports.PaymentNewModel = (0, mongoose_2.model)('PaymentNew', exports.PaymentNewSchema);

package/dist/schemas/sale.schema.d.ts

@@ -95,6 +95,7 @@ export declare class Lost {
 declare class Note {
     text: string;
     owner: string;
+    createdAt: Date;
 }
 export declare class Sale {
     _id?: Types.ObjectId;

package/dist/schemas/sale.schema.js

@@ -250,6 +250,10 @@ __decorate([
     (0, mongoose_1.Prop)({ required: true }),
     __metadata("design:type", String)
 ], Note.prototype, "owner", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: true }),
+    __metadata("design:type", Date)
+], Note.prototype, "createdAt", void 0);
 Note = __decorate([
     (0, mongoose_1.Schema)({ _id: false })
 ], Note);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grapadigital/shared-schemas",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "description": "Shared Mongoose Schemas",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './schemas/influencer.schema';
 export * from './schemas/supplier.schema';
 export * from './schemas/campaign.schema';
 export * from './schemas/payment.schema';
+export * from './schemas/payment_new.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/token.schema';

package/src/schemas/invoice.schema.ts

@@ -49,6 +49,7 @@ class Canceled {
 class Note {
   @Prop({ required: true }) text: string;
   @Prop({ required: true }) owner: string;
+  @Prop({ required: true }) createdAt: Date;
 }
 
 @Schema({ timestamps: true })

package/src/schemas/payment_new.schema.ts

@@ -0,0 +1,154 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
+import { Influencer } from './influencer.schema';
+import { Supplier } from './supplier.schema';
+import { Action } from './action.schema';
+import { Recruitment } from './recruitment.schema';
+import { Sale } from './sale.schema';
+
+export type PaymentNewDocument = HydratedDocument<PaymentNew>;
+
+@Schema({ _id: false })
+class Requester {
+  @Prop() name: string;
+  @Prop() email: string;
+  @Prop() team: string;
+}
+const RequesterSchema = SchemaFactory.createForClass(Requester);
+
+@Schema({ _id: false })
+export class Review {
+  @Prop({ type: String, enum: ['influencer', 'advisor', 'supplier', 'employee'] })
+  type: 'influencer' | 'advisor' | 'supplier' | 'employee';
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, refPath: 'review.type' })
+  beneficiary: Types.ObjectId | Influencer | Supplier;
+
+  @Prop() value: number;
+  @Prop() description: string;
+  @Prop() emissionNotes: string;
+}
+export const ReviewSchema = SchemaFactory.createForClass(Review);
+
+@Schema({ _id: false })
+export class Processing {
+  @Prop() emissionNotes: string;
+  @Prop() revisedDueDate: Date;
+  @Prop() revisedIssueDate: Date;
+}
+export const ProcessingSchema = SchemaFactory.createForClass(Processing);
+
+@Schema({ _id: false })
+export class Approval {
+  @Prop() name: string;
+  @Prop() approvedAt: Date;
+}
+export const ApprovalSchema = SchemaFactory.createForClass(Approval);
+
+@Schema({ _id: false })
+export class Requested { @Prop() date: Date; }
+export const RequestedSchema = SchemaFactory.createForClass(Requested);
+
+@Schema({ _id: false })
+export class Queued {
+  @Prop() issueDate: Date;
+  @Prop() dueDate: Date;
+  @Prop() code: string;
+}
+export const QueuedSchema = SchemaFactory.createForClass(Queued);
+
+@Schema({ _id: false })
+export class Paid { @Prop() date: Date; }
+export const PaidSchema = SchemaFactory.createForClass(Paid);
+
+@Schema({ _id: false })
+export class Canceled {
+  @Prop() reason: string;
+  @Prop() notes: string;
+}
+export const CanceledSchema = SchemaFactory.createForClass(Canceled);
+
+@Schema({ _id: false })
+export class Note {
+  @Prop() text: string;
+  @Prop() owner: string;
+  @Prop() createdAt: Date;
+}
+export const NoteSchema = SchemaFactory.createForClass(Note);
+
+@Schema({ timestamps: true })
+export class PaymentNew {
+  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true })
+  _id?: Types.ObjectId;
+
+  @Prop() title: string;
+
+  @Prop({ type: RequesterSchema, required: true })
+  requester: Requester;
+
+  @Prop({ type: ReviewSchema, required: false })
+  review?: Review;
+
+  @Prop({ type: ProcessingSchema, required: false })
+  processing?: Processing;
+
+  @Prop({ type: ApprovalSchema, required: false })
+  approval?: Approval;
+
+  @Prop({ type: RequestedSchema, required: false })
+  requested?: Requested;
+
+  @Prop({ type: QueuedSchema, required: false })
+  queued?: Queued;
+
+  @Prop({ type: PaidSchema, required: false })
+  paid?: Paid;
+
+  @Prop({ type: CanceledSchema, required: false })
+  canceled?: Canceled;
+
+  @Prop({ type: [NoteSchema], default: [] })
+  notes?: Note[];
+
+  @Prop() installmentNumber: number;
+
+  @Prop({ required: false })
+  additionalComments?: string;
+
+  @Prop({
+    type: String,
+    enum: [
+      'review',
+      'processing',
+      'approval',
+      'awaiting',
+      'requested',
+      'queued',
+      'paid',
+      'client',
+      'canceled',
+    ],
+  })
+  phase:
+    | 'review'
+    | 'processing'
+    | 'approval'
+    | 'awaiting'
+    | 'requested'
+    | 'queued'
+    | 'paid'
+    | 'client'
+    | 'canceled';
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Sale' })
+  sale: Types.ObjectId | Sale;
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Action' })
+  action: Types.ObjectId | Action;
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Recruitment' })
+  recruitment: Types.ObjectId | Recruitment;
+}
+
+export const PaymentNewSchema = SchemaFactory.createForClass(PaymentNew);
+export const PaymentNewModel = MongooseModel('PaymentNew', PaymentNewSchema);

package/src/schemas/sale.schema.ts

@@ -101,6 +101,7 @@ export class Lost {
 class Note {
   @Prop({ required: true }) text: string;
   @Prop({ required: true }) owner: string;
+  @Prop({ required: true }) createdAt: Date;
 }
 
 @Schema({ timestamps: true })