@peabody-soft/mbs-model-ts 1.4.0 → 1.6.0

package/dist/Order.js

@@ -2,12 +2,14 @@ import { MessageType as proto_MessageType } from "./generated/MessageType";
 import { amountFromScaledValue } from "./Constants";
 import Message from "./Message";
 // An order a customer has placed: a message carrying a sales order payload.
-// deliveryAddressId is an id into the customer's address list, not an address; deliveryAddress is
-// a full address sent directly instead, and takes precedence over deliveryAddressId when both are
-// present. paymentReceived is set only by an operator of the business, never by this library.
+// The business completes an order (fulfilling or cancelling it) by deleting its message, so
+// isDeleted is true of a completed order. That message is still the whole order: status and what
+// the customer ordered are there to show, as for an open one. status says how far the business
+// got with it.
+// deliveryAddressId is an id into the customer's address list. deliveryAddress is a full address
+// sent directly, and takes precedence over deliveryAddressId when both are present.
 export default class Order extends Message {
-    // Only ProtoMap calls this: it is the one place that sees a total still multiplied by
-    // Constants.AMOUNT_FACTOR.
+    // For ProtoMap, which sees a total still multiplied by Constants.AMOUNT_FACTOR.
     static fromScaledValues(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, scaledShoppingListTotal, shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived) {
         return new Order(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, amountFromScaledValue(scaledShoppingListTotal), shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived === undefined ? null : amountFromScaledValue(scaledPaymentReceived));
     }
@@ -24,34 +26,35 @@ export default class Order extends Message {
         this._paymentReceived = _paymentReceived;
         this._creationDate = Number(creationDate);
     }
-    // How far the business has got with fulfilling this order, as opposed to taskStatus, which is
-    // how far it has got with reading the message
+    // How far the business has got with fulfilling this order. taskStatus is how far it has got with
+    // reading the message.
     get status() {
         return this._status;
     }
     get fulfillmentMode() {
         return this._fulfillmentMode;
     }
-    // What was ordered. A fulfilled order can have had its list cleared, in which case the totals
-    // below are all that is left of it.
+    // What was ordered. An order completed before the business kept the list with it (an older
+    // merchant app moved the list into a record of the sale, which a customer never sees) holds
+    // ShoppingList.EMPTY, which has no lines. The totals below are then all that is left.
     get shoppingList() {
         return this._shoppingList;
     }
-    // The authoritative total to display; survives the shopping list being cleared, unlike a total
-    // read off the list itself.
+    // The authoritative total to display. Unlike a total read off the list, it survives the order
+    // having no list.
     get shoppingListTotal() {
         return this._shoppingListTotal;
     }
     get shoppingListCount() {
         return this._shoppingListCount;
     }
-    // Names an address in the address list of the customer, and Constants.ENTITY_ID_NULL when the
-    // order has no delivery address - which is normal for one to be picked up
+    // Names an address in the customer's address list. Constants.ENTITY_ID_NULL when the order has no
+    // delivery address, as is normal for a pickup.
     get deliveryAddressId() {
         return this._deliveryAddressId;
     }
-    // A full address sent directly rather than by id, and null when none was. Takes precedence over
-    // deliveryAddressId for display when it is not null - see the comment on this class.
+    // A full address sent directly rather than by id. Null when none was. Takes precedence over
+    // deliveryAddressId when not null.
     get deliveryAddress() {
         return this._deliveryAddress;
     }
@@ -62,8 +65,8 @@ export default class Order extends Message {
     get note() {
         return this._note;
     }
-    // What the business has recorded as received against this order so far, and null when it has
-    // recorded nothing - only a business operator sets this, never this library.
+    // What the business has recorded as received against this order so far. Null when nothing is
+    // recorded. Only a business operator sets it.
     get paymentReceived() {
         return this._paymentReceived;
     }

package/dist/Package.js

@@ -1,6 +1,6 @@
 import Item from "./Item";
-// A package, or variant, of a product - a 500 gram bottle of mango pickle, for example - and the
-// thing a customer actually buys. Built complete, with photos and price already resolved, so everything here is readonly.
+// A package, or variant, of a product (a 500 gram bottle of mango pickle, say) and the thing a
+// customer buys. Built complete, with photos and price resolved, so everything here is readonly.
 export default class Package extends Item {
     constructor(header, name, description, productId, isDisabled, _isSoldLoose, _itemCode, _identifiers, _dimensions, _weight, _photos, _price) {
         super(header, name, description, productId, isDisabled);
@@ -37,15 +37,14 @@ export default class Package extends Item {
     get photos() {
         return this._photos;
     }
-    // What this package costs; null when the business has not priced it, in which case it cannot be
-    // bought.
+    // What this package costs, with the taxes of its product included (Product.taxes). Null when the
+    // business has not priced it, so it cannot be bought.
     get price() {
         return this._price;
     }
-    // True when this package is enabled and has a price that is itself enabled. isDisabled is
-    // checked directly rather than trusted to have been filtered out: a product-level filter does
-    // not, by itself, guarantee that every package - or every price - of an otherwise visible
-    // product is itself enabled.
+    // True when this package is enabled and has an enabled price. Checked here because a
+    // product-level filter does not guarantee that every package, or every price, of an otherwise
+    // visible product is enabled.
     get isBuyable() {
         return !this.isDisabled && this._price !== null && !this._price.isDisabled;
     }

package/dist/PackageIdentifier.js

@@ -1,5 +1,5 @@
-// An identifier of a package - a GTIN, for example - and the kind of identifier it is. Java keys
-// these by string id, not ordinal, so map through PackageIdentifierType.proto's comments, never the enum ordinal.
+// An identifier of a package, such as a GTIN, and its kind. Java keys kinds by string id, so map
+// through the comments in PackageIdentifierType.proto, never the enum ordinal.
 export default class PackageIdentifier {
     constructor(_type, _value) {
         this._type = _type;

package/dist/PaymentMethodDetail.js

@@ -1,8 +1,8 @@
-// A payment method a business accepts, and what a customer needs in order to use it - the UPI id
-// of the business, for example.
+// A payment method a business accepts, and what a customer needs to use it (the UPI id of the
+// business, say).
 //
-// The data is null rather than empty when the business has given none, which is normal for a
-// method that needs nothing, such as cash.
+// The data is null, not empty, when the business has given none. That is normal for a method that
+// needs nothing, such as cash.
 export default class PaymentMethodDetail {
     constructor(_method, _data) {
         this._method = _method;

package/dist/Photo.js

@@ -1,9 +1,8 @@
-// A photo of a business, product or package: which one it belongs to, and where to fetch it from.
-// All that's exposed of an Attachment - nothing else on it is useful to a UI.
+// A photo of a business, product or package: its attachment type and where to fetch it from.
+// All that a UI needs of an Attachment.
 export default class Photo {
-    // The base url is the one in effect when this photo was built, not looked up at read time - a
-    // photo is rebuilt by the next sync rather than edited in place, so there is nothing to keep in
-    // sync with a later renewal.
+    // The base url is the one in effect when this photo was built. A photo is rebuilt by the next
+    // sync, not edited in place, so a later renewal needs no handling.
     constructor(_attachment, _attachmentBaseUrl) {
         this._attachment = _attachment;
         this._attachmentBaseUrl = _attachmentBaseUrl;
@@ -12,8 +11,8 @@ export default class Photo {
     get attachmentType() {
         return this._attachment.attachmentType;
     }
-    // Where to fetch this photo from, or null if there's nothing to fetch (deleted attachment, or the
-    // owning business's base url hadn't arrived when this photo was built). May be expired; cached
+    // Where to fetch this photo from. Null if there is nothing to fetch (deleted attachment, or the
+    // owning business's base url had not arrived when this photo was built). May be expired. Cached
     // once built.
     get url() {
         if (this._url !== null)

package/dist/Price.js

@@ -2,9 +2,12 @@ import { amountFromScaledValue } from "./Constants";
 import Item from "./Item";
 // What one package costs: the regular price and the offer price. Exposed unscaled as numbers; they
 // travel multiplied by Constants.AMOUNT_FACTOR and stay well below 2^53, so nothing is lost.
+//
+// BOTH INCLUDE TAXES: the taxes of the package's product (Product.taxes) are in the price, not
+// added to it, so this is what a customer pays and what a catalog shows. A shopping list stores a
+// price without them, so a cart takes the taxes out (CartEditor).
 export default class Price extends Item {
-    // Only ProtoMap calls this: it is the one place that sees prices still multiplied by
-    // Constants.AMOUNT_FACTOR.
+    // For ProtoMap, which sees prices still multiplied by Constants.AMOUNT_FACTOR.
     static fromScaledValues(header, name, description, priceListId, isDisabled, packageId, scaledRegularPrice, scaledOfferPrice) {
         return new Price(header, name, description, priceListId, isDisabled, packageId, amountFromScaledValue(scaledRegularPrice), amountFromScaledValue(scaledOfferPrice));
     }
@@ -30,8 +33,8 @@ export default class Price extends Item {
     get offerPrice() {
         return this._offerPrice;
     }
-    // What a customer actually pays: the offer price when there is one, else the regular price.
-    // Computed here (not sent), matching the "on offer" definition from Price.proto.
+    // What a customer pays, taxes included: the offer price when there is one, else the regular
+    // price. Computed here, not sent, using the "on offer" definition from Price.proto.
     get finalPrice() {
         return this.isOnOffer ? this._offerPrice : this._regularPrice;
     }
@@ -42,8 +45,8 @@ export default class Price extends Item {
     get discount() {
         return this._regularPrice - this.finalPrice;
     }
-    // Discount as an exact, unrounded percentage of the regular price - rounding is left to the UI.
-    // Zero when the regular price is zero.
+    // Discount as an unrounded percentage of the regular price. Rounding is left to the UI. Zero
+    // when the regular price is zero.
     get discountPercent() {
         if (this._regularPrice <= 0)
             return 0;

package/dist/PriceList.js

@@ -1,5 +1,5 @@
 import Item from "./Item";
-// A named list of prices. A storefront sells from exactly one, so no package ever has two prices
-// to choose between; it's carried (not just a bare id) because a client naming a cart needs it.
+// A named list of prices. A storefront sells from one, so no package has two prices to choose
+// between. Carried as an object, not a bare id, because a client naming a cart needs it.
 export default class PriceList extends Item {
 }

package/dist/Product.d.ts

@@ -14,20 +14,22 @@ export default class Product extends Item {
     private readonly _manufacturerAddress;
     private readonly _taxes;
     private readonly _features;
+    private readonly _isForOfflineSaleOnly;
     private readonly _photos;
-    private readonly _packages;
-    constructor(header: EntityHeader, name: string, description: string | null, productCategoryId: bigint, isDisabled: boolean, _productType: proto_ProductType, _brand: string | null, _isManufacturedByBusiness: boolean | null, _manufacturer: string | null, _manufacturerAddress: Address | null, _taxes: ReadonlyArray<Tax>, _features: ReadonlyArray<string>, _photos: ReadonlyArray<Photo>, _packages: ReadonlyArray<Package>);
+    constructor(header: EntityHeader, name: string, description: string | null, productCategoryId: bigint, isDisabled: boolean, _productType: proto_ProductType, _brand: string | null, _isManufacturedByBusiness: boolean, _manufacturer: string | null, _manufacturerAddress: Address | null, _taxes: ReadonlyArray<Tax>, _features: ReadonlyArray<string>, _isForOfflineSaleOnly: boolean, _photos: ReadonlyArray<Photo>, packages: ReadonlyArray<Package>);
     get productCategoryId(): bigint;
     get productType(): proto_ProductType;
     get brand(): string | null;
-    get isManufacturedByBusiness(): boolean | null;
+    get isManufacturedByBusiness(): boolean;
     get manufacturer(): string | null;
     get manufacturerAddress(): Address | null;
     get taxes(): ReadonlyArray<Tax>;
     get features(): ReadonlyArray<string>;
+    get isForOfflineSaleOnly(): boolean;
     get photos(): ReadonlyArray<Photo>;
     get packages(): ReadonlyArray<Package>;
     get lowestPrice(): Price | null;
     get isOnOffer(): boolean;
     get isBuyable(): boolean;
+    private readonly _packages;
 }

package/dist/Product.js

@@ -1,8 +1,8 @@
 import Item from "./Item";
 // A product in the catalog: goods, a service, a raw material or a fixed asset. Built complete
-// (photos/packages resolved first) so everything here is readonly except category (via parentItemId).
+// (photos and packages resolved first), so everything here is readonly.
 export default class Product extends Item {
-    constructor(header, name, description, productCategoryId, isDisabled, _productType, _brand, _isManufacturedByBusiness, _manufacturer, _manufacturerAddress, _taxes, _features, _photos, _packages) {
+    constructor(header, name, description, productCategoryId, isDisabled, _productType, _brand, _isManufacturedByBusiness, _manufacturer, _manufacturerAddress, _taxes, _features, _isForOfflineSaleOnly, _photos, packages) {
         super(header, name, description, productCategoryId, isDisabled);
         this._productType = _productType;
         this._brand = _brand;
@@ -11,8 +11,10 @@ export default class Product extends Item {
         this._manufacturerAddress = _manufacturerAddress;
         this._taxes = _taxes;
         this._features = _features;
+        this._isForOfflineSaleOnly = _isForOfflineSaleOnly;
         this._photos = _photos;
-        this._packages = _packages;
+        // A package that cannot be bought is not kept, whoever builds the product and whatever they pass in
+        this._packages = Object.freeze(packages.filter((pkg) => pkg.isBuyable));
     }
     // The category this product is in, or Constants.ENTITY_ID_NULL when it is in none
     get productCategoryId() {
@@ -24,8 +26,8 @@ export default class Product extends Item {
     get brand() {
         return this._brand;
     }
-    // Null when the business hasn't said either way - the three states are why this isn't a plain
-    // boolean.
+    // False only when the business says it does not make this product itself. Absent on the wire
+    // means true (Product.proto).
     get isManufacturedByBusiness() {
         return this._isManufacturedByBusiness;
     }
@@ -35,6 +37,8 @@ export default class Product extends Item {
     get manufacturerAddress() {
         return this._manufacturerAddress;
     }
+    // The taxes included in the price of every package of this product (see Price), not added to it.
+    // A UI shows a price as is, and shows these only as part of what a bill's total includes.
     get taxes() {
         return this._taxes;
     }
@@ -42,22 +46,29 @@ export default class Product extends Item {
     get features() {
         return this._features;
     }
+    // True when the business sells this product only offline. The server sends such a product like
+    // any other, flagged, and this model must not offer it to a customer (see isBuyable). A catalog
+    // never holds one, so only a hand-built product can report true.
+    get isForOfflineSaleOnly() {
+        return this._isForOfflineSaleOnly;
+    }
     get photos() {
         return this._photos;
     }
-    // Every variant of this product, in the order they arrived - ordering them for display is a UI
-    // decision, see Catalog.comparePackages. A product with no packages cannot be bought.
+    // Every buyable variant of this product, in the order they arrived. Ordering for display is a UI
+    // decision, see Catalog.comparePackages. A product with no buyable variant cannot be bought.
     get packages() {
         return this._packages;
     }
-    // The cheapest final price across variants (what a listing shows as "from"), or null if none has
-    // a price. Compares final price, not regular, since that's what a customer would actually pay.
+    // The cheapest final price across variants (what a listing shows as "from"), or null if there
+    // are no variants. Compares final price, since that is what a customer pays. Every variant is
+    // taxed at this product's rates, so prices with taxes order the variants as prices without would.
     get lowestPrice() {
         let result = null;
         for (const pkg of this._packages) {
             const price = pkg.price;
             if (price === null)
-                continue; // This variant cannot be bought
+                continue; // Not so of a buyable variant, though the type does not say
             if (result === null || price.finalPrice < result.finalPrice)
                 result = price;
         }
@@ -70,15 +81,11 @@ export default class Product extends Item {
                 return true;
         return false;
     }
-    // True when this product itself is enabled and at least one variant is buyable. The server
-    // still filters out draft and non-public products before they ever arrive, but isDisabled can
-    // change after an item exists, so it is checked here rather than trusted to have been filtered.
+    // True when this product is enabled, is not sold only offline, and has at least one variant (it
+    // keeps only buyable ones). The server filters out draft and non-public products before they
+    // arrive. isDisabled can change after an item exists and offline-only products are sent flagged,
+    // so both are checked here.
     get isBuyable() {
-        if (this.isDisabled)
-            return false;
-        for (const pkg of this._packages)
-            if (pkg.isBuyable)
-                return true;
-        return false;
+        return !this.isDisabled && !this._isForOfflineSaleOnly && this._packages.length > 0;
     }
 }

package/dist/ProductCategory.js

@@ -1,8 +1,7 @@
 import Item from "./Item";
-// A category that groups products, real or the dummy one a Catalog builds to stand in for a
-// product with no category of its own. Products are set once by the Catalog that builds this, not
-// passed to the constructor - the full set isn't known until every product has been read. A
-// Catalog never builds one of these with an empty products array - see Catalog for why.
+// A category that groups products, real or the dummy one a Catalog builds for products with no
+// category. The Catalog sets the products once, after reading every product, so they are not
+// constructor arguments. A Catalog never builds one with an empty products array (see Catalog).
 export default class ProductCategory extends Item {
     constructor() {
         super(...arguments);

package/dist/Profile.d.ts

@@ -18,3 +18,4 @@ export default class Profile {
     private readonly _businessMap;
     private readonly _businessLinkMap;
 }
+export declare function canonicalizeBusinessId(businessId: string): string;

package/dist/Profile.js

@@ -6,8 +6,8 @@ export default class Profile {
         this._user = _user;
         this._businessMap = new Map();
         this._businessLinkMap = new Map();
-        // A business is listed only when its link is still held; a revoked link is removed by the
-        // sync but the business it named is not, so filtering here hides it without discarding it.
+        // A business is listed only when its link is still held. A revoked link is removed by the sync
+        // but its business is not, so filtering here hides the business without discarding it.
         const linkedBusinessIds = new Set();
         for (const businessLink of businessLinks)
             linkedBusinessIds.add(businessLink.businessId);
@@ -15,8 +15,16 @@ export default class Profile {
         this._businesses = Object.freeze(businesses.filter((business) => linkedBusinessIds.has(business.id)));
         for (const business of this._businesses)
             this._businessMap.set(business.id, business);
-        for (const businessLink of this._businessLinks)
-            this._businessLinkMap.set(businessLink.businessId, businessLink);
+        // One link is kept per business: the one that names this customer. A profile can hold several
+        // links to a business, and another user's link is not what this customer writes with. A link
+        // that does not name this customer never replaces one that does, whichever comes last. If none
+        // names them (no user is held yet), the last is kept.
+        const isOwn = (link) => this._user !== null && link.linkedEntityId === this._user.id;
+        for (const businessLink of this._businessLinks) {
+            const held = this._businessLinkMap.get(businessLink.businessId);
+            if (held === undefined || isOwn(businessLink) || !isOwn(held))
+                this._businessLinkMap.set(businessLink.businessId, businessLink);
+        }
     }
     // The id of the profile container this was built from, and what Model.signIn was given
     get profileId() {
@@ -37,15 +45,18 @@ export default class Profile {
     getBusiness(businessEntityId) {
         return this._businessMap.get(businessEntityId) ?? null;
     }
-    // BusinessLink.businessId is an entity id, matching Business.entity.id and not the url friendly
-    // businessId - this join spares a caller from having to remember which one it is holding
+    // Takes the entity id (BusinessLink.businessId, matching Business.entity.id), not the url friendly
+    // businessId. See getBusinessLinkFor.
     getBusinessLink(businessEntityId) {
         return this._businessLinkMap.get(businessEntityId) ?? null;
     }
-    // The same, by the url friendly business id a storefront is reached by
+    // The same, by the url friendly business id a storefront is reached by, however it is written in
+    // the url. The server finds a business whatever the case, so this must too, or a customer who
+    // has joined would be asked to join again.
     getBusinessLinkFor(businessId) {
+        const wanted = canonicalizeBusinessId(businessId);
         for (const business of this._businesses)
-            if (business.businessId === businessId)
+            if (canonicalizeBusinessId(business.businessId) === wanted)
                 return this.getBusinessLink(business.id);
         return null;
     }
@@ -53,3 +64,78 @@ export default class Profile {
         return `Profile(profileId=${this._profileId}, user=${this._user?.formattedName ?? "none"}, businesses=${this._businesses.length})`;
     }
 }
+// A business id in the canonical form the server finds it by (Java Business.canonicalizeBusinessId):
+// spaces normalized as Java StringHelper.normalizeSpace does, then lower case. So a url typed in any
+// case or spacing names one business. Inner spaces count, as an id can hold some (Java builds one
+// from the display name, "Warm Loaf_1a2b3c4d", or takes what is typed).
+// normalizeSpace is followed step for step, quirks included: a string with no whitespace at either
+// end and none twice in a row is left alone, and a non-breaking space is not whitespace to it, so
+// one between words stays unless something else in the string is normalized.
+// Java refuses an id not four to sixty-four characters long. This is only a comparison and does
+// not. The server answers a read of such an id with NotFoundException, as for a missing business.
+export function canonicalizeBusinessId(businessId) {
+    return normalizeSpace(businessId).toLowerCase();
+}
+// Java StringHelper.normalizeSpace. Where Java answers null (a string of only whitespace), this answers an empty string.
+function normalizeSpace(input) {
+    if (!needsNormalization(input))
+        return input;
+    let result = "";
+    let whitespaceCount = 0;
+    let isAtStart = true;
+    for (let index = 0; index < input.length; ++index) {
+        const unit = input.charCodeAt(index);
+        if (isWhitespace(unit)) {
+            if (whitespaceCount === 0 && !isAtStart)
+                result += " ";
+            ++whitespaceCount;
+        }
+        else {
+            isAtStart = false;
+            result += unit === NO_BREAK_SPACE ? " " : input.charAt(index);
+            whitespaceCount = 0;
+        }
+    }
+    if (isAtStart)
+        return "";
+    // Java String.trim removes every character up to a space from either end, unlike a script's trim, which removes
+    // Unicode spaces. The space standing for trailing whitespace goes with it (Java drops that one first, same result)
+    let first = 0;
+    let last = result.length;
+    while (first < last && result.charCodeAt(first) <= SPACE)
+        ++first;
+    while (last > first && result.charCodeAt(last - 1) <= SPACE)
+        --last;
+    return result.slice(first, last);
+}
+// Java StringHelper.needsNormalization: whitespace at either end, or two together between
+function needsNormalization(input) {
+    if (input.length === 0)
+        return false;
+    if (isWhitespace(input.charCodeAt(0)) || isWhitespace(input.charCodeAt(input.length - 1)))
+        return true;
+    let wasWhitespace = false;
+    for (let index = 1; index < input.length - 1; ++index) {
+        const isNowWhitespace = isWhitespace(input.charCodeAt(index));
+        if (isNowWhitespace && wasWhitespace)
+            return true;
+        wasWhitespace = isNowWhitespace;
+    }
+    return false;
+}
+// Java Character.isWhitespace: the Unicode spaces that do not hold a place (not the no-break ones U+00A0, U+2007 and
+// U+202F) and the control characters that are spaces. A regular expression's \s differs: it includes the no-break
+// spaces and the byte order mark, and excludes U+001C to U+001F
+function isWhitespace(unit) {
+    if (unit === SPACE)
+        return true;
+    if (unit >= 0x09 && unit <= 0x0d)
+        return true; // Tab, line feed, vertical tab, form feed and carriage return
+    if (unit >= 0x1c && unit <= 0x1f)
+        return true; // The four separators
+    if (unit >= 0x2000 && unit <= 0x200a)
+        return unit !== 0x2007;
+    return unit === 0x1680 || unit === 0x2028 || unit === 0x2029 || unit === 0x205f || unit === 0x3000;
+}
+const SPACE = 0x20;
+const NO_BREAK_SPACE = 0xa0;

package/dist/ProtoMap.d.ts

@@ -34,25 +34,35 @@ export declare function getProfileResponseEntities(response: proto_ProfileSyncOu
 export declare function businessResponseToCacheWrite(response: proto_BusinessSyncOutResponse): CacheWrite;
 export declare function profileResponseToCacheWrite(response: proto_ProfileSyncOutResponse): CacheWrite;
 export declare function getBusinessResponseAttachmentBaseUrlExpiry(response: proto_BusinessSyncOutResponse | null): bigint;
-export declare function orderToBlob(order: proto_Message): StoredBlob;
+export declare function orderToBlob(order: proto_Message, heldETag: bigint | null): StoredBlob;
 export declare function isPartyPreferencesMessage(message: proto_Message): boolean;
 export declare function getMessageUpdatedAt(message: proto_Message): bigint;
-export declare function partyPreferencesToBlob(partyPreferences: proto_Message): StoredBlob;
+export declare function getMessageId(message: proto_Message): bigint;
+export declare function partyPreferencesToBlob(partyPreferences: proto_Message, heldETag: bigint | null): StoredBlob;
 export declare function businessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
 export declare function profileResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_ProfileSyncOutResponse | null;
+export declare function deletedBusinessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
+export declare function deletedProfileResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_ProfileSyncOutResponse | null;
 export declare function orderMessagesFromBlobs(blobs: ReadonlyArray<StoredBlob>): ReadonlyArray<proto_Message>;
+export declare function deletedOrderMessagesFromBlobs(blobs: ReadonlyArray<StoredBlob>): ReadonlyArray<proto_Message>;
 export declare function partyPreferencesMessageFromMessages(messages: ReadonlyArray<proto_Message>): proto_Message | null;
 export declare function partyPreferencesMessageFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_Message | null;
-export declare function buildBusinessSyncOutRequest(businessId: string, syncInState: SyncState, attachmentBaseUrlExpiry: bigint): proto_BusinessSyncOutRequest;
-export declare function buildBusinessSyncOutRequestFromCache(businessId: string, cached: proto_BusinessSyncOutResponse | null): proto_BusinessSyncOutRequest;
+export declare function buildBusinessSyncOutRequest(business: string | bigint, syncInState: SyncState, attachmentBaseUrlExpiry: bigint): proto_BusinessSyncOutRequest;
+export declare function cursorsToBlobs(cursors: SyncState, movedKeys: ReadonlySet<number>): Array<StoredBlob>;
+export declare function cursorsFromBlobs(keys: ReadonlyArray<number>, blobs: ReadonlyArray<StoredBlob | null>): SyncState;
+export declare function raiseBusinessCursors(cursors: SyncState, response: proto_BusinessSyncOutResponse): ReadonlySet<number>;
 export declare function buildBusinessSyncInRequest(messageUpdateNumber: bigint, messages: ReadonlyArray<proto_Message>): proto_BusinessSyncInRequest;
 export declare function getSyncInResponseMessages(response: proto_BusinessSyncInResponse): ReadonlyArray<proto_Message>;
 export declare function buildProfileSyncOutRequest(syncInState: SyncState, joinBusinessId?: bigint): proto_ProfileSyncOutRequest;
-export declare function buildProfileSyncOutRequestFromCache(cached: proto_ProfileSyncOutResponse | null, joinBusinessId?: bigint): proto_ProfileSyncOutRequest;
+export declare function raiseProfileCursors(cursors: SyncState, response: proto_ProfileSyncOutResponse): ReadonlySet<number>;
 export declare function buildUser(userProfile: UserProfile): proto_User;
 export declare function buildUpdateUser(userProfile: UserProfile): proto_User;
 export declare function hasJoinedBusinessLink(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
 export declare function hasJoinedBusiness(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
+export declare function getBusinessResponseCountryCode(response: proto_BusinessSyncOutResponse | null): number | undefined;
+export declare function getBusinessResponseBusinessEntityId(response: proto_BusinessSyncOutResponse | null): bigint | null;
+export declare function getBusinessResponseBusinessId(response: proto_BusinessSyncOutResponse | null): string | null;
+export declare function isBusinessResponseOnlineShoppingOn(response: proto_BusinessSyncOutResponse | null): boolean;
 export declare function buildAuthTokens(authTokens: AuthTokens): proto_AuthTokens;
 export declare function authTokensFromProto(authTokens: proto_AuthTokens): AuthTokens;
 export declare function buildAuthTokensBytes(authTokens: proto_AuthTokens): Uint8Array;
@@ -65,10 +75,10 @@ export declare function nextBusinessSyncOutRequest(request: proto_BusinessSyncOu
 export declare function nextProfileSyncOutRequest(request: proto_ProfileSyncOutRequest, response: proto_ProfileSyncOutResponse): proto_ProfileSyncOutRequest | null;
 export declare function buildBusiness(response: proto_BusinessSyncOutResponse): Business | null;
 export declare function buildProfile(profileId: string, response: proto_ProfileSyncOutResponse): Profile | null;
-export declare function buildOrder(message: proto_Message): Order | null;
-export declare function buildShoppingList(message: proto_Message): ShoppingList;
+export declare function buildOrder(message: proto_Message, countryCode: number): Order | null;
+export declare function buildShoppingList(message: proto_Message, countryCode: number): ShoppingList;
 export declare function buildPartyPreferencesMessage(messageId: bigint, existing: proto_Message | null, senderId: bigint, shoppingList: ShoppingList | null, fulfillmentMode: proto_FulfillmentMode | null, now: bigint): proto_Message;
 export declare function buildOrderMessage(orderId: bigint, senderId: bigint, shoppingList: ShoppingList, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null, creationDate: bigint): proto_Message;
 export declare function messagesToCacheWrite(messages: ReadonlyArray<proto_Message>): CacheWrite;
-export declare function highestCachedMessageUpdateNumber(blobs: ReadonlyArray<StoredBlob>): bigint;
 export declare function hasShoppingListChanged(stored: proto_Message | null, shoppingList: ShoppingList): boolean;
+export declare function entityETag(updateNumber: bigint, updatedAt: bigint): bigint;