@peabody-soft/mbs-model-ts 1.0.0

package/dist/Address.d.ts

@@ -0,0 +1,33 @@
+import { AddressType as proto_AddressType } from "./generated/AddressType";
+export default class Address {
+    readonly id: bigint;
+    private readonly _addressType;
+    private readonly _unitNumber;
+    private readonly _community;
+    private readonly _line2;
+    private readonly _city;
+    private readonly _state;
+    private readonly _pinCode;
+    private readonly _countryCode;
+    constructor(id: bigint, _addressType: proto_AddressType, _unitNumber: string | null, _community: string | null, _line2: string | null, _city: string | null, _state: string | null, _pinCode: string | null, _countryCode: number);
+    get addressType(): proto_AddressType;
+    get unitNumber(): string | null;
+    get community(): string | null;
+    get line2(): string | null;
+    get city(): string | null;
+    get state(): string | null;
+    get pinCode(): string | null;
+    get countryCode(): number;
+    get formattedAddress(): string;
+}
+export declare class AddressList {
+    private readonly _defaultAddressId;
+    private readonly _addresses;
+    constructor(_defaultAddressId: bigint, _addresses: ReadonlyArray<Address>);
+    get defaultAddressId(): bigint;
+    get addresses(): ReadonlyArray<Address>;
+    get size(): number;
+    get defaultAddress(): Address | null;
+    getAddress(addressId: bigint): Address | null;
+    static readonly EMPTY: AddressList;
+}

package/dist/Address.js

@@ -0,0 +1,97 @@
+// A postal address: a delivery address of a customer, or an address of a business. Not an entity -
+// its id is unique only within the AddressList that holds it.
+export default class Address {
+    constructor(
+    // Unique only within the list that holds it, unlike an entity id
+    id, _addressType, _unitNumber, _community, _line2, _city, _state, _pinCode, _countryCode) {
+        this.id = id;
+        this._addressType = _addressType;
+        this._unitNumber = _unitNumber;
+        this._community = _community;
+        this._line2 = _line2;
+        this._city = _city;
+        this._state = _state;
+        this._pinCode = _pinCode;
+        this._countryCode = _countryCode;
+    }
+    get addressType() {
+        return this._addressType;
+    }
+    // Flat, house or building number
+    get unitNumber() {
+        return this._unitNumber;
+    }
+    // Street, locality or neighbourhood
+    get community() {
+        return this._community;
+    }
+    get line2() {
+        return this._line2;
+    }
+    get city() {
+        return this._city;
+    }
+    get state() {
+        return this._state;
+    }
+    // Postal code / PIN code
+    get pinCode() {
+        return this._pinCode;
+    }
+    // ISO 3166-1 numeric
+    get countryCode() {
+        return this._countryCode;
+    }
+    // The set parts, in envelope order, joined with commas; empty when none are set. Country is
+    // deliberately excluded - turning a code into a name is a UI decision, not this library's.
+    get formattedAddress() {
+        const parts = [];
+        for (const part of [
+            this._unitNumber,
+            this._community,
+            this._line2,
+            this._city,
+            this._state,
+            this._pinCode,
+        ])
+            if (part !== null && part.length > 0)
+                parts.push(part);
+        return parts.join(", ");
+    }
+}
+// The addresses of a user or of a business, one of which is the default.
+export class AddressList {
+    constructor(_defaultAddressId, _addresses) {
+        this._defaultAddressId = _defaultAddressId;
+        this._addresses = _addresses;
+    }
+    get defaultAddressId() {
+        return this._defaultAddressId;
+    }
+    get addresses() {
+        return this._addresses;
+    }
+    // Computed here rather than sent
+    get size() {
+        return this._addresses.length;
+    }
+    // The address named by defaultAddressId, or the first address if that id names none (default was
+    // deleted). Null only when the list is empty.
+    get defaultAddress() {
+        if (this._addresses.length === 0)
+            return null;
+        for (const address of this._addresses)
+            if (address.id === this._defaultAddressId)
+                return address;
+        return this._addresses[0];
+    }
+    getAddress(addressId) {
+        for (const address of this._addresses)
+            if (address.id === addressId)
+                return address;
+        return null;
+    }
+}
+// An empty list, for a user or a business that has no addresses at all. Frozen and shared,
+// because an AddressList holds nothing that can change.
+AddressList.EMPTY = new AddressList(0n, Object.freeze([]));

package/dist/Attachment.d.ts

@@ -0,0 +1,16 @@
+import { AttachmentType as proto_AttachmentType } from "./generated/AttachmentType";
+import Entity, { EntityHeader } from "./Entity";
+export default class Attachment extends Entity {
+    private readonly _attachmentType;
+    private readonly _owningEntityId;
+    private readonly _fileHash;
+    private readonly _fileExtension;
+    private readonly _fileName;
+    constructor(header: EntityHeader, _attachmentType: proto_AttachmentType, _owningEntityId: bigint, _fileHash: Uint8Array | null, _fileExtension: string | null, _fileName: string | null);
+    get attachmentType(): proto_AttachmentType;
+    get owningEntityId(): bigint;
+    get fileName(): string | null;
+    get storageFileName(): string | null;
+    private static pad;
+    private static toUpperCaseHexString;
+}

package/dist/Attachment.js

@@ -0,0 +1,49 @@
+import Entity from "./Entity";
+import Ids from "./Ids";
+// A file attached to an entity - a photo of a business, a product or a package. Not part of this
+// library's public surface; a UI is given a Photo (attachment type + url) built from this instead.
+export default class Attachment extends Entity {
+    constructor(header, _attachmentType, _owningEntityId, _fileHash, _fileExtension, _fileName) {
+        super(header);
+        this._attachmentType = _attachmentType;
+        this._owningEntityId = _owningEntityId;
+        this._fileHash = _fileHash;
+        this._fileExtension = _fileExtension;
+        this._fileName = _fileName;
+    }
+    // Which photo of the owning entity this is: the main catalog image, one of the lifestyle images,
+    // a photo of the store, and so on
+    get attachmentType() {
+        return this._attachmentType;
+    }
+    // The business, product or package this file is attached to. Nothing nests on the wire, so this
+    // is how the sync layer finds which entity a photo belongs to.
+    get owningEntityId() {
+        return this._owningEntityId;
+    }
+    get fileName() {
+        return this._fileName;
+    }
+    // Storage file name, or null if this attachment has no file (deleted). Must exactly match Java
+    // Attachment.getStorageFileName: UTC date with zero-based month, upper-hex id/hash, no 0x prefix.
+    get storageFileName() {
+        if (this._fileHash === null || this._fileExtension === null)
+            return null;
+        const createdAt = this.createdAt;
+        const year = Attachment.pad(createdAt.getUTCFullYear(), 4);
+        const month = Attachment.pad(createdAt.getUTCMonth(), 2); // Zero based, as in Java
+        const day = Attachment.pad(createdAt.getUTCDate(), 2);
+        const id = Ids.toStorageHexString(this.id);
+        const fileHash = Attachment.toUpperCaseHexString(this._fileHash);
+        return `${year}-${month}-${day}-${id}-${fileHash}.${this._fileExtension}`;
+    }
+    static pad(value, length) {
+        return value.toString().padStart(length, "0");
+    }
+    static toUpperCaseHexString(bytes) {
+        let result = "";
+        for (const byte of bytes)
+            result += byte.toString(16).toUpperCase().padStart(2, "0");
+        return result;
+    }
+}

package/dist/AttachmentBaseUrl.d.ts

@@ -0,0 +1,11 @@
+export default class AttachmentBaseUrl {
+    private readonly _resourceUrl;
+    private readonly _sasToken;
+    constructor(_resourceUrl: string, _sasToken: string, expiry: bigint);
+    get resourceUrl(): string;
+    get expiry(): Date;
+    get hasExpired(): boolean;
+    createFileUrl(storageFileName: string): URL;
+    toString(): string;
+    private readonly _expiry;
+}

package/dist/AttachmentBaseUrl.js

@@ -0,0 +1,41 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+import { InvalidArgumentException } from "./Exceptions";
+// Where a business's attachment files live, the signature that reads them, and when both expire.
+// Signature has no getter (only createFileUrl exposes it) - safe in a url only because it is
+// scoped, read-only and short-lived, unlike AuthTokens' userToken/linkToken.
+export default class AttachmentBaseUrl {
+    constructor(_resourceUrl, _sasToken, expiry) {
+        this._resourceUrl = _resourceUrl;
+        this._sasToken = _sasToken;
+        // The protobuf promises no trailing slash and no query string; checked rather than trusted,
+        // since violating either silently produces a url that fetches nothing.
+        if (_resourceUrl.length === 0 || _resourceUrl.endsWith("/"))
+            throw new InvalidArgumentException(`Not a container url: ${_resourceUrl}`);
+        if (_resourceUrl.includes("?"))
+            throw new InvalidArgumentException("A container url cannot carry a query string");
+        this._expiry = Number(expiry);
+    }
+    // The url of the container the files are in, always https and never with a trailing slash
+    get resourceUrl() {
+        return this._resourceUrl;
+    }
+    get expiry() {
+        return new Date(this._expiry);
+    }
+    // True once too close to expiry to be worth using (margin: ATTACHMENT_BASE_URL_EXPIRY_MARGIN),
+    // compared against the client's own clock so a url can't expire between being built and fetched.
+    get hasExpired() {
+        return Date.now() + proto_Constants.ATTACHMENT_BASE_URL_EXPIRY_MARGIN >= this._expiry;
+    }
+    // The url of one file: storage file name as the path, signature as the query string. Name must
+    // be a flat path segment - a container is not a directory tree.
+    createFileUrl(storageFileName) {
+        if (storageFileName.length === 0 || storageFileName.includes("/"))
+            throw new InvalidArgumentException(`Not a storage file name: ${storageFileName}`);
+        return new URL(`${this._resourceUrl}/${storageFileName}?${this._sasToken}`);
+    }
+    // Redacts the signature, so that logging one of these cannot leak it
+    toString() {
+        return `AttachmentBaseUrl(resourceUrl=${this._resourceUrl}, expiry=${this.expiry.toISOString()}, sasToken=<redacted>)`;
+    }
+}

package/dist/AuthTokens.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticationMethod as proto_AuthenticationMethod } from "./generated/AuthenticationMethod";
+export default class AuthTokens {
+    private readonly _authenticationMethod;
+    private readonly _authenticationToken;
+    private readonly _userToken;
+    private readonly _linkToken;
+    constructor(_authenticationMethod: proto_AuthenticationMethod, _authenticationToken: string, _userToken: string | null, _linkToken: string | null);
+    get authenticationMethod(): proto_AuthenticationMethod;
+    get authenticationToken(): string;
+    get userToken(): string | null;
+    get linkToken(): string | null;
+    toString(): string;
+}

package/dist/AuthTokens.js

@@ -0,0 +1,30 @@
+// The credentials one request is signed with: exactly the fields of the AuthTokens message and nothing derived, so that what this library holds and what the wire carries cannot drift.
+// A class of its own rather than the generated message because these are held and cached rather than only sent; ProtoMap turns one into the message a Service is handed. Every value is a bearer credential - never log one.
+export default class AuthTokens {
+    constructor(_authenticationMethod, _authenticationToken, _userToken, _linkToken) {
+        this._authenticationMethod = _authenticationMethod;
+        this._authenticationToken = _authenticationToken;
+        this._userToken = _userToken;
+        this._linkToken = _linkToken;
+    }
+    // Which identity provider issued the authentication token, and so how a server parses it. Always set: zero is FIREBASE, not "unspecified".
+    get authenticationMethod() {
+        return this._authenticationMethod;
+    }
+    // Which person is calling, as their identity provider says. Empty on one read back out of the cache, which deliberately keeps no copy of it - see ProtoMap.authTokensToBlob.
+    get authenticationToken() {
+        return this._authenticationToken;
+    }
+    // Which MeraBills user that person is, issued by this server. Null until a profile sync out has been made once, which is the call that earns one.
+    get userToken() {
+        return this._userToken;
+    }
+    // Which business the caller may act against, from the BusinessLink of that business. Null on a call that names none, which the protocol allows.
+    get linkToken() {
+        return this._linkToken;
+    }
+    // Redacts all three, so that logging one of these cannot leak a credential
+    toString() {
+        return `AuthTokens(authenticationMethod=${this._authenticationMethod}, authenticationToken=<redacted>, userToken=<${this._userToken === null ? "none" : "redacted"}>, linkToken=<${this._linkToken === null ? "none" : "redacted"}>)`;
+    }
+}

package/dist/Business.d.ts

@@ -0,0 +1,44 @@
+import AttachmentBaseUrl from "./AttachmentBaseUrl";
+import CartEditor from "./CartEditor";
+import Catalog from "./Catalog";
+import Entity, { EntityHeader } from "./Entity";
+import GeneralSettings from "./GeneralSettings";
+import Order from "./Order";
+import Photo from "./Photo";
+import ShoppingList from "./ShoppingList";
+export default class Business extends Entity implements UpdatableBusiness {
+    private readonly _businessId;
+    private readonly _displayName;
+    private readonly _countryCode;
+    constructor(header: EntityHeader, _businessId: string, _displayName: string, _countryCode: number);
+    get businessId(): string;
+    get displayName(): string;
+    get countryCode(): number;
+    get settings(): GeneralSettings;
+    private set settings(value);
+    get photos(): ReadonlyArray<Photo>;
+    private set photos(value);
+    get orders(): ReadonlyArray<Order>;
+    private set orders(value);
+    get cart(): ShoppingList | null;
+    private set cart(value);
+    get catalog(): Catalog;
+    private set catalog(value);
+    createCartEditor(): CartEditor;
+    get attachmentBaseUrl(): AttachmentBaseUrl | null;
+    private set attachmentBaseUrl(value);
+    private _settings;
+    private _photos;
+    private _orders;
+    private _cart;
+    private _catalog;
+    private _attachmentBaseUrl;
+}
+export interface UpdatableBusiness {
+    set settings(value: GeneralSettings);
+    set photos(value: ReadonlyArray<Photo>);
+    set orders(value: ReadonlyArray<Order>);
+    set cart(value: ShoppingList | null);
+    set catalog(value: Catalog);
+    set attachmentBaseUrl(value: AttachmentBaseUrl | null);
+}

package/dist/Business.js

@@ -0,0 +1,87 @@
+import CartEditor from "./CartEditor";
+import Catalog from "./Catalog";
+import Entity from "./Entity";
+import GeneralSettings from "./GeneralSettings";
+// The business a customer is browsing: its name, settings, photos, catalog, orders, and cart.
+// Rebuilt by the sync layer from flat wire entities and set via UpdatableBusiness, not a public
+// setter - a UI holding a Business can read all of it and change none of it.
+export default class Business extends Entity {
+    constructor(header, _businessId, _displayName, _countryCode) {
+        super(header);
+        this._businessId = _businessId;
+        this._displayName = _displayName;
+        this._countryCode = _countryCode;
+        this._settings = GeneralSettings.EMPTY;
+        this._photos = Object.freeze([]);
+        this._orders = Object.freeze([]);
+        this._cart = null;
+        this._catalog = Catalog.EMPTY;
+        this._attachmentBaseUrl = null;
+    }
+    // The unique, lower case, url friendly id this storefront was reached by - not the entity id
+    // (see the warning on BusinessLink.businessId, which is this business's entity id)
+    get businessId() {
+        return this._businessId;
+    }
+    // The name shown to customers
+    get displayName() {
+        return this._displayName;
+    }
+    // ISO 3166-1 numeric; the only source of currency for amounts in this business
+    get countryCode() {
+        return this._countryCode;
+    }
+    // GeneralSettings.EMPTY until the business's public configuration arrives
+    get settings() {
+        return this._settings;
+    }
+    set settings(value) {
+        this._settings = value;
+    }
+    // Photos of the store itself, as opposed to a product's or package's
+    get photos() {
+        return this._photos;
+    }
+    set photos(value) {
+        this._photos = value;
+    }
+    // The orders this customer has placed
+    get orders() {
+        return this._orders;
+    }
+    set orders(value) {
+        this._orders = value;
+    }
+    // What this customer has picked and not yet ordered. Null until they have put something in a
+    // cart, and null again once they have ordered what was in it - the message the cart travels in
+    // outlives being emptied, but nothing of it is a customer's business, so what is exposed is the
+    // list alone. The fulfillment mode is not part of it: that is chosen when an order is placed, and
+    // is a field of the Order.
+    get cart() {
+        return this._cart;
+    }
+    set cart(value) {
+        this._cart = value;
+    }
+    // Catalog.EMPTY until the catalog of this business arrives
+    get catalog() {
+        return this._catalog;
+    }
+    set catalog(value) {
+        this._catalog = value;
+    }
+    // A scratch copy of the cart to edit, priced off this business's catalog and charged to its
+    // settings - see CartEditor. It reads all three once, here, so a Business republished mid-edit
+    // needs a fresh one; nothing an editor does touches this business until its built list reaches
+    // Model.updateCartLocalOnly.
+    createCartEditor() {
+        return new CartEditor(this._catalog, this._settings, this._cart);
+    }
+    // Where this business's photo files live; renewed on its own schedule independent of the rest
+    get attachmentBaseUrl() {
+        return this._attachmentBaseUrl;
+    }
+    set attachmentBaseUrl(value) {
+        this._attachmentBaseUrl = value;
+    }
+}

package/dist/BusinessIdentifier.d.ts

@@ -0,0 +1,8 @@
+import { BusinessIdentifierType as proto_BusinessIdentifierType } from "./generated/BusinessIdentifierType";
+export default class BusinessIdentifier {
+    private readonly _type;
+    private readonly _value;
+    constructor(_type: proto_BusinessIdentifierType, _value: string);
+    get type(): proto_BusinessIdentifierType;
+    get value(): string;
+}

package/dist/BusinessIdentifier.js

@@ -0,0 +1,14 @@
+// An identifier of a business - a GSTIN, for example - and its kind. Same pair-not-a-map reason as
+// PackageIdentifier: Java identifies kinds by string id, so this numbering is protocol-only.
+export default class BusinessIdentifier {
+    constructor(_type, _value) {
+        this._type = _type;
+        this._value = _value;
+    }
+    get type() {
+        return this._type;
+    }
+    get value() {
+        return this._value;
+    }
+}

package/dist/BusinessLink.d.ts

@@ -0,0 +1,21 @@
+import { Role as proto_Role } from "./generated/Role";
+import Entity, { EntityHeader } from "./Entity";
+export default class BusinessLink extends Entity {
+    private readonly _linkedEntityId;
+    private readonly _businessId;
+    private readonly _role;
+    private readonly _partyId;
+    private readonly _linkToken;
+    constructor(header: EntityHeader, _linkedEntityId: bigint, _businessId: bigint, _role: proto_Role, _partyId: bigint, _linkToken: string | null, expiry: bigint);
+    get linkedEntityId(): bigint;
+    get businessId(): bigint;
+    get role(): proto_Role;
+    get partyId(): bigint;
+    get linkToken(): string | null;
+    get expiry(): Date;
+    get isExpirySet(): boolean;
+    get hasExpired(): boolean;
+    toString(): string;
+    private static readonly NO_EXPIRY;
+    private readonly _expiry;
+}

package/dist/BusinessLink.js

@@ -0,0 +1,61 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+import Entity from "./Entity";
+// What links a customer to a business and authorizes them to act against it. businessId is an
+// entity id (not the url-friendly Business.businessId); never log or url-embed linkToken.
+class BusinessLink extends Entity {
+    constructor(header, _linkedEntityId, _businessId, _role, _partyId, _linkToken, expiry) {
+        super(header);
+        this._linkedEntityId = _linkedEntityId;
+        this._businessId = _businessId;
+        this._role = _role;
+        this._partyId = _partyId;
+        this._linkToken = _linkToken;
+        this._expiry = Number(expiry);
+    }
+    // The entity this link is for - the User of the customer, in a storefront. Its entity type is
+    // the most significant byte of the id, which is how a client tells a user from a business.
+    get linkedEntityId() {
+        return this._linkedEntityId;
+    }
+    // The entity id of the business, matching Business.entity.id - see the comment on this class
+    get businessId() {
+        return this._businessId;
+    }
+    // What the customer may do, normally Role.CUSTOMER. Group is (role >> 6); actual permissions are
+    // not on the wire, so a UI cannot grey out disallowed actions.
+    get role() {
+        return this._role;
+    }
+    // The party record of this customer, or Constants.ENTITY_ID_NULL when none. Party is not part of
+    // this protocol, so a storefront cannot resolve it - exposed only because the server needs it.
+    get partyId() {
+        return this._partyId;
+    }
+    // The credential that goes into AuthTokens.linkToken of every later request naming this
+    // business. Never log this and never put it in a url.
+    get linkToken() {
+        return this._linkToken;
+    }
+    get expiry() {
+        return new Date(this._expiry);
+    }
+    // False when this link never expires, which is what BusinessLink.NO_EXPIRY means. That constant
+    // is not in Constants.proto - it is zero, and it is the only meaning zero has for this field.
+    get isExpirySet() {
+        return this._expiry !== BusinessLink.NO_EXPIRY;
+    }
+    // True once past expiry by more than Constants.MAX_CLOCK_SKEW - applied opposite to
+    // AttachmentBaseUrl.hasExpired, so a false positive can't lock out a still-entitled customer.
+    get hasExpired() {
+        if (!this.isExpirySet)
+            return false;
+        return Date.now() - proto_Constants.MAX_CLOCK_SKEW > this._expiry;
+    }
+    // Redacts the link token, so that logging a link cannot leak it
+    toString() {
+        return `BusinessLink(id=${this.id}, businessId=${this._businessId}, role=${this._role}, linkToken=<redacted>)`;
+    }
+}
+// Java BusinessLink.NO_EXPIRY
+BusinessLink.NO_EXPIRY = 0;
+export default BusinessLink;

package/dist/BusinessProfile.d.ts

@@ -0,0 +1,11 @@
+import Entity, { EntityHeader } from "./Entity";
+export default class BusinessProfile extends Entity {
+    private readonly _businessId;
+    private readonly _displayName;
+    private readonly _countryCode;
+    constructor(header: EntityHeader, _businessId: string, _displayName: string, _countryCode: number);
+    get businessId(): string;
+    get displayName(): string;
+    get countryCode(): number;
+    toString(): string;
+}

package/dist/BusinessProfile.js

@@ -0,0 +1,27 @@
+import Entity from "./Entity";
+// One business the customer is linked to, as the profile database holds it: url-friendly id, name
+// and country only - deliberately not a Business, which carries data a profile sync can't provide.
+export default class BusinessProfile extends Entity {
+    constructor(header, _businessId, _displayName, _countryCode) {
+        super(header);
+        this._businessId = _businessId;
+        this._displayName = _displayName;
+        this._countryCode = _countryCode;
+    }
+    // The unique, lower case, url-friendly id a storefront is reached by; what Model.setBusinessId
+    // takes. Not the entity id - BusinessLink.businessId is the entity id of the same business.
+    get businessId() {
+        return this._businessId;
+    }
+    // The name shown to customers
+    get displayName() {
+        return this._displayName;
+    }
+    // ISO 3166-1 numeric; the only thing that says what currency this business's amounts are in
+    get countryCode() {
+        return this._countryCode;
+    }
+    toString() {
+        return `BusinessProfile(id=${this.id}, businessId=${this._businessId}, displayName=${this._displayName})`;
+    }
+}

package/dist/CartEditor.d.ts

@@ -0,0 +1,59 @@
+import Catalog from "./Catalog";
+import GeneralSettings from "./GeneralSettings";
+import Package from "./Package";
+import Product from "./Product";
+import ShoppingList, { ShoppingListItem } from "./ShoppingList";
+import Tax from "./Tax";
+export default class CartEditor {
+    private readonly _catalog;
+    private readonly _settings;
+    constructor(_catalog: Catalog, _settings: GeneralSettings, cart: ShoppingList | null);
+    get lines(): ReadonlyArray<CartLine>;
+    get unavailableItems(): ReadonlyArray<ShoppingListItem>;
+    get isEmpty(): boolean;
+    get lineCount(): number;
+    get totalQuantity(): number;
+    getQuantity(item: Package): number;
+    setQuantity(item: Package, quantity: number): CartEditor;
+    add(item: Package, quantity?: number): CartEditor;
+    remove(item: Package): CartEditor;
+    clear(): CartEditor;
+    get itemsTotal(): number;
+    get savings(): number;
+    get itemsTax(): number;
+    get itemsFinalTotal(): number;
+    get isDeliveryOffered(): boolean;
+    get deliveryCharge(): number;
+    get regularDeliveryCharge(): number;
+    get isDeliveryFree(): boolean;
+    get amountToFreeDelivery(): number | null;
+    get deliveryTax(): number;
+    total(withDeliveryCharge?: boolean): number;
+    build(withDeliveryCharge?: boolean): ShoppingList;
+    private buildDeliveryChargeItem;
+    private getDeliveryCharge;
+    private static getTax;
+    private getBuyablePackage;
+    private static readonly MAX_QUANTITY;
+    private readonly _inventoryLocationId;
+    private readonly _unavailableItems;
+    private readonly _quantities;
+}
+export declare class CartLine {
+    private readonly _package;
+    private readonly _product;
+    private readonly _quantity;
+    constructor(_package: Package, _product: Product | null, _quantity: number);
+    get package(): Package;
+    get product(): Product | null;
+    get quantity(): number;
+    get unitPrice(): number;
+    get regularUnitPrice(): number;
+    get isOnOffer(): boolean;
+    get taxes(): ReadonlyArray<Tax>;
+    get amount(): number;
+    get savings(): number;
+    get totalTax(): number;
+    get finalPrice(): number;
+    toShoppingListItem(shoppingListOrder: number): ShoppingListItem;
+}