@aptly-as/types/models/order.d.ts

Aptly types and enums

import { AptlyOrderStatus } from '../enums/index.js';
import { AptlyAddress } from './address.js';
import { AptlyAllowanceChargeSchema, AptlyLegalMonetaryTotal } from './algorithm.js';
import { AptlyAppImplementationSetting, AptlyAppSchema } from './app.js';
import { AptlyCustomerSchema } from './customer.js';
import { AptlyDocumentSchema } from './document.js';
import { AptlyEmailSchema } from './email.js';
import { AptlyOfferSchema } from './offer.js';
import { AptlyOrganizationAppConfigSchema, AptlyOrganizationSchema } from './organization.js';
import { AptlyPaymentSchema } from './payment.js';
import { AptlyPickConfirmedSchema } from './pick.js';
import { AptlyProductSchema } from './product.js';
import { AptlyProject, AptlyProjectPeriodSchema, AptlyProjectSchema } from './project.js';
import { AptlyUnit, AptlyUnitItemParamSchema, AptlyUnitSchema } from './unit.js';
import { AptlyBaseSchema } from './extends.js';
import { AptlyUser, AptlyUserSchema } from './user.js';
import { Populated } from '../core';
export declare enum AptlyOrderPaymentStatus {
    Pending = "PENDING",
    Authorized = "AUTHORIZED",
    OnHold = "ON_HOLD",
    Captured = "CAPTURED",
    Expired = "EXPIRED"
}
export type AptlyOrder = AptlyOrderSchema<string, string>;
export interface AptlyOrderSchema<ID, DATE> extends Omit<AptlyBaseSchema<ID, DATE>, 'name'> {
    orderNumber: string;
    invoiceNumber?: number;
    organization: ID | AptlyOrganizationSchema<ID, DATE>;
    project: ID | AptlyProjectSchema<ID, DATE>;
    period?: ID | AptlyProjectPeriodSchema<ID, DATE>;
    unit: ID | AptlyUnitSchema<ID, DATE>;
    offer: ID | AptlyOfferSchema<ID, DATE> | null;
    signers: (ID | AptlyUserSchema<ID, DATE>)[];
    status: AptlyOrderStatus;
    receipt: ID | AptlyDocumentSchema<ID, DATE>;
    signedReceipt?: ID | AptlyDocumentSchema<ID, DATE>;
    attachments: ID[];
    signage: AptlyOrderSignageSchema<ID, DATE>;
    items: AptlyOrderItemSchema<ID, DATE>[];
    picks: (ID | AptlyPickConfirmedSchema<ID, DATE>)[];
    documents: (ID | AptlyDocumentSchema<ID, DATE>)[];
    amount?: number;
    vatAmount?: number;
    totalVat?: number;
    totalCost: number;
    total?: AptlyLegalMonetaryTotal | null;
    allowanceCharges: AptlyAllowanceChargeSchema<ID, boolean>[];
    customer?: AptlyCustomerSchema<ID, DATE>;
    shipping?: AptlyAddress;
    billing?: AptlyAddress;
    pricePipeline: AptlyOrderPricePipelineItemSchema<ID>[];
    signees?: AptlyOrderSigneeSchema<ID, DATE>[];
    signedAt?: DATE | null;
    emailText?: string;
    approved?: {
        action?: AptlyOrderAction;
        user?: ID | AptlyUserSchema<ID, DATE>;
        at?: DATE;
    };
    paymentSession?: AptlyOrderPaymentSessionSchema<ID, DATE> | null;
    payment?: ID | AptlyPaymentSchema<ID, DATE>;
    shippingDate?: DATE;
    shippingDescription?: string;
    completedAt?: DATE | null;
    createdBy?: Populated<AptlyUserSchema<ID, DATE>> | null;
    createdByAdmin?: boolean;
    created: DATE;
}
export type AptlyOrderPaymentSession = AptlyOrderPaymentSessionSchema<string, string>;
export interface AptlyOrderPaymentSessionSchema<ID, DATE> {
    app?: ID | AptlyAppSchema<ID, DATE>;
    status?: AptlyOrderPaymentStatus;
    user?: ID | null;
    id?: string;
    at?: DATE | null;
    url?: string;
    notifiedAt?: DATE | null;
    expiresAt?: DATE | null;
    paidAt?: DATE | null;
    capturedAt?: DATE | null;
}
export type AptlyOrderSignee = AptlyOrderSigneeSchema<string, string>;
export interface AptlyOrderSigneeSchema<ID, DATE> {
    _id: ID;
    user: ID | AptlyUserSchema<ID, DATE>;
    type: AptlyOrderSigneeType;
    url: string;
    signedAt?: DATE;
}
export declare enum AptlyOrderSigneeType {
    Unit = 0,
    Admin = 1
}
export type AptlyOrderPricePipelineItem = AptlyOrderPricePipelineItemSchema<string>;
export interface AptlyOrderPricePipelineItemSchema<ID> {
    _id: ID;
    label: string;
    value: number;
}
export type AptlyOrderSignage = AptlyOrderSignageSchema<string, string>;
export interface AptlyOrderSignageSchema<ID, DATE> {
    signed: boolean;
    app?: ID | AptlyAppSchema<ID, DATE>;
    createdAt?: DATE | null;
    expiresAt?: DATE | null;
    signedAt?: DATE | null;
    notifiedAt?: DATE | null;
    document?: ID | AptlyDocumentSchema<ID, DATE>;
    hasReceivedFile?: boolean;
    signedFile?: ID | AptlyDocumentSchema<ID, DATE>;
    documentId?: ID;
    documentCreationDate?: DATE;
    expireDate?: DATE;
    customerSignerId?: string;
    organizationSignerId?: string;
    organizationSignedAt?: DATE;
    customerSignedAt?: DATE;
}
export type AptlyOrderItem = AptlyOrderItemSchema<string, string>;
export interface AptlyOrderItemSchema<ID, DATE> {
    _id: ID;
    text?: string;
    product: ID | AptlyProductSchema<ID, DATE>;
    variant: ID;
    producer: ID;
    params: AptlyUnitItemParamSchema<ID, DATE>[];
    quantity: number;
    baseCost?: number;
    unitCost: number;
    unitVat?: number;
    vat?: number;
    pricePipeline: AptlyOrderItemPricePipelineSchema<ID>[];
}
export type AptlyOrderItemPricePipeline = AptlyOrderItemPricePipelineSchema<string>;
export interface AptlyOrderItemPricePipelineSchema<ID> {
    _id: ID;
    label: string;
    value: number;
}
export declare enum AptlyOrderAction {
    Complete = "complete",
    Delivery = "delivery",
    Payment = "payment",
    SignManually = "sign-manually",
    Sign = "sign"
}
export interface AptlyOrderActionPostBody {
    action: AptlyOrderAction | null;
    document?: string | null;
    app?: string;
    emailSubject: string;
    emailText: string;
    emailMarkdown: string;
    users: AptlyOrderActionPostBodyUser[];
    deadlineInDays?: number;
    shippingDate?: string | null;
    shippingDescription?: string | null;
}
export interface AptlyOrderActionPostBodyUser {
    user: string;
    signMethod?: string;
    isAdmin?: boolean;
}
export type AptlyOrderActionItem<S extends object = object> = AptlyOrderActionItemSchema<string, string, S>;
export interface AptlyOrderActionItemSchema<ID, DATE, S extends object> {
    action: AptlyOrderAction;
    path: string;
    app?: Pick<AptlyAppSchema<ID, DATE>, '_id' | 'name' | 'sign' | 'logo' | 'settings'>;
    appSettings?: AptlyOrganizationAppConfigSchema<ID, DATE, S>['settings'];
    email?: AptlyEmailSchema<ID, DATE>;
}
export interface AptlyOrderActionItemSignSettings {
    [AptlyAppImplementationSetting.SignCostPer]: number;
    [AptlyAppImplementationSetting.SignMethod]: string;
}
export interface AptlyOrderActionSignData {
    project: Pick<AptlyProject, '_id' | 'name'> & {
        theme: Pick<AptlyProject['theme'], 'contact'>;
    };
    unit: Pick<AptlyUnit, '_id' | 'name'>;
    order: Pick<AptlyOrder, '_id' | 'orderNumber' | 'receipt' | 'period'>;
    user: AptlyUser;
    signees: AptlyOrderActionSignDataSignee[];
    deadlineInDays?: number;
}
export interface AptlyOrderActionSignDataSignee {
    user: AptlyUser;
    signMethod?: string;
    isAdmin?: boolean;
}
export interface AptlyOrderDeliveryBody {
    shippingDate: string;
    shippingDescription?: string;
}
export interface AptlyOrderCompleteBody {
    emailSubject?: string;
    emailText?: string;
    emailMarkdown?: string;
    skipEmail?: boolean;
}