@peabody-soft/mbs-model-ts 1.0.0

package/dist/ProtoMap.js

@@ -0,0 +1,1126 @@
+import { Address as proto_Address } from "./generated/Address";
+import { AddressList as proto_AddressList } from "./generated/AddressList";
+import { Attachment as proto_Attachment } from "./generated/Attachment";
+import { AuthTokens as proto_AuthTokens } from "./generated/AuthTokens";
+import { Business as proto_Business } from "./generated/Business";
+import { BusinessLink as proto_BusinessLink } from "./generated/BusinessLink";
+import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generated/BusinessSyncInRequest";
+import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
+import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
+import { Configuration as proto_Configuration } from "./generated/Configuration";
+import { Constants as proto_Constants } from "./generated/Constants";
+import { Entity as proto_Entity } from "./generated/Entity";
+import { Message as proto_Message } from "./generated/Message";
+import { MessageType as proto_MessageType } from "./generated/MessageType";
+import { OrderStatus as proto_OrderStatus } from "./generated/OrderStatus";
+import { Package as proto_Package } from "./generated/Package";
+import { PartyPreferencesPayload as proto_PartyPreferencesPayload } from "./generated/PartyPreferencesPayload";
+import { Price as proto_Price } from "./generated/Price";
+import { PriceList as proto_PriceList } from "./generated/PriceList";
+import { Product as proto_Product } from "./generated/Product";
+import { ProductCategory as proto_ProductCategory } from "./generated/ProductCategory";
+import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
+import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
+import { SalesOrderPayload as proto_SalesOrderPayload } from "./generated/SalesOrderPayload";
+import { ShoppingList as proto_ShoppingList } from "./generated/ShoppingList";
+import { ShoppingListItem as proto_ShoppingListItem } from "./generated/ShoppingListItem";
+import { TaskStatus as proto_TaskStatus } from "./generated/TaskStatus";
+import { Tax as proto_Tax } from "./generated/Tax";
+import { UrlAndToken as proto_UrlAndToken } from "./generated/UrlAndToken";
+import { User as proto_User } from "./generated/User";
+import Address, { AddressList } from "./Address";
+import Attachment from "./Attachment";
+import AttachmentBaseUrl from "./AttachmentBaseUrl";
+import AuthTokens from "./AuthTokens";
+import Business from "./Business";
+import BusinessIdentifier from "./BusinessIdentifier";
+import BusinessLink from "./BusinessLink";
+import BusinessProfile from "./BusinessProfile";
+import Catalog from "./Catalog";
+import { MERABILLS_ONLINE_PRICE_LIST_ID, amountToScaledValue, quantityToScaledValue, taxRateToScaledValue, } from "./Constants";
+import { EntityHeader, UpdatableEntity } from "./Entity";
+import { InvalidArgumentException } from "./Exceptions";
+import GeneralSettings from "./GeneralSettings";
+import LatLong from "./LatLong";
+import Ids from "./Ids";
+import { Dimensions, Weight } from "./Measures";
+import Order from "./Order";
+import Package from "./Package";
+import PackageIdentifier from "./PackageIdentifier";
+import PaymentMethodDetail from "./PaymentMethodDetail";
+import Photo from "./Photo";
+import Price from "./Price";
+import PriceList from "./PriceList";
+import Profile from "./Profile";
+import Product from "./Product";
+import ProductCategory from "./ProductCategory";
+import ShoppingList, { ShoppingListItem } from "./ShoppingList";
+import * as SyncKeys from "./SyncKeys";
+import SyncState from "./SyncState";
+import Tax from "./Tax";
+import UserProfile from "./UserProfile";
+import WorkingDays, { WorkingHours, WorkingHoursRange } from "./WorkingDays";
+// #region A response and the blobs it is cached as
+// Every entity of a response, in declaration order (parents before children). A tombstone is included, flagged.
+export function getBusinessResponseEntities(response) {
+    const result = [];
+    if (response.business !== undefined)
+        result.push(toWireEntity(response.business.entity, proto_Business.toBinary(response.business)));
+    for (const attachment of response.attachments)
+        result.push(toWireEntity(attachment.entity, proto_Attachment.toBinary(attachment)));
+    for (const configuration of response.configurations)
+        result.push(toWireEntity(configuration.entity, proto_Configuration.toBinary(configuration)));
+    for (const message of response.messages)
+        result.push(toWireEntity(message.entity, proto_Message.toBinary(message)));
+    for (const productCategory of response.productCategories)
+        result.push(toItemWireEntity(productCategory.item, proto_ProductCategory.toBinary(productCategory)));
+    for (const product of response.products)
+        result.push(toItemWireEntity(product.item, proto_Product.toBinary(product)));
+    for (const pkg of response.packages)
+        result.push(toItemWireEntity(pkg.item, proto_Package.toBinary(pkg)));
+    for (const priceList of response.priceLists)
+        result.push(toItemWireEntity(priceList.item, proto_PriceList.toBinary(priceList)));
+    for (const price of response.prices)
+        result.push(toItemWireEntity(price.item, proto_Price.toBinary(price)));
+    return result;
+}
+// Every entity of a profile sync out response: the caller, their links, and the businesses those links name.
+// The three have separate cursors, so unlike a business response the order between the arrays does not matter.
+export function getProfileResponseEntities(response) {
+    const result = [];
+    if (response.user !== undefined)
+        result.push(toWireEntity(response.user.entity, proto_User.toBinary(response.user)));
+    for (const businessLink of response.businessLinks)
+        result.push(toWireEntity(businessLink.entity, proto_BusinessLink.toBinary(businessLink)));
+    for (const business of response.businesses)
+        result.push(toWireEntity(business.entity, proto_Business.toBinary(business)));
+    return result;
+}
+// What a business response is cached as: one blob per live entity, the ids its tombstones named,
+// and the attachment base url in a blob of its own, since it belongs to the business rather than to
+// any entity of it.
+export function businessResponseToCacheWrite(response) {
+    const write = toCacheWrite(getBusinessResponseEntities(response));
+    // Its eTag is its expiry, which is exactly its cursor: a client sends back the expiry it holds and is sent a later url only when one exists
+    const attachmentBaseUrl = response.attachmentBaseUrl;
+    if (attachmentBaseUrl !== undefined)
+        write.blobs.push({
+            id: Ids.ATTACHMENT_BASE_URL_BLOB_ID,
+            eTag: attachmentBaseUrl.expiry,
+            bytes: proto_UrlAndToken.toBinary(attachmentBaseUrl),
+        });
+    return write;
+}
+// The same for a profile response, which carries nothing but entities.
+export function profileResponseToCacheWrite(response) {
+    return toCacheWrite(getProfileResponseEntities(response));
+}
+// The expiry of the attachment base url a response carried, and zero when it carried none, which is exactly what the next request sends back.
+// Here rather than at a call site, because reading a field of a response is this file's job.
+export function getBusinessResponseAttachmentBaseUrlExpiry(response) {
+    return response?.attachmentBaseUrl?.expiry ?? 0n;
+}
+// One order as its own blob, for a caller holding a message rather than a whole response. The payload is the only thing that says which a message is, so one carrying the other is refused here rather than stored where a read would never find it.
+export function orderToBlob(order) {
+    if (order.payload.oneofKind !== "salesOrder")
+        throw new InvalidArgumentException("That message carries no sales order, so it is not an order");
+    return messageToBlob(order);
+}
+export function cartToBlob(cart) {
+    if (cart.payload.oneofKind !== "partyPreferences")
+        throw new InvalidArgumentException("That message carries no party preferences, so it is not a cart");
+    return messageToBlob(cart);
+}
+// The response the blobs of a business container make up: everything cached for that business, in the shape the call that brought it returned, and null when they hold nothing of it yet.
+// The entity type in each blob id sorts them, so no stored type tag is needed; one this library does not know is skipped rather than refused, so a newer server cannot break an older client.
+export function businessResponseFromBlobs(blobs) {
+    const response = proto_BusinessSyncOutResponse.create({});
+    let hasContent = false;
+    for (const blob of blobs) {
+        if (blob.id === Ids.ATTACHMENT_BASE_URL_BLOB_ID) {
+            response.attachmentBaseUrl = proto_UrlAndToken.fromBinary(blob.bytes);
+            hasContent = true;
+            continue;
+        }
+        if (blob.id < 0n)
+            continue; // One of the other fixed blobs, not an entity
+        switch (Ids.getEntityTypeId(blob.id)) {
+            case proto_Constants.BUSINESS_ENTITY_TYPE_ID:
+                response.business = proto_Business.fromBinary(blob.bytes);
+                break;
+            case proto_Constants.ATTACHMENT_ENTITY_TYPE_ID:
+                response.attachments.push(proto_Attachment.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.CONFIGURATION_ENTITY_TYPE_ID:
+                response.configurations.push(proto_Configuration.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.MESSAGE_ENTITY_TYPE_ID:
+                response.messages.push(proto_Message.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.PRODUCT_CATEGORY_ENTITY_TYPE_ID:
+                response.productCategories.push(proto_ProductCategory.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.PRODUCT_ENTITY_TYPE_ID:
+                response.products.push(proto_Product.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.PACKAGE_ENTITY_TYPE_ID:
+                response.packages.push(proto_Package.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.PRICE_LIST_ENTITY_TYPE_ID:
+                response.priceLists.push(proto_PriceList.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.PRICE_ENTITY_TYPE_ID:
+                response.prices.push(proto_Price.fromBinary(blob.bytes));
+                break;
+            default:
+                continue; // An entity type this library does not understand
+        }
+        hasContent = true;
+    }
+    return hasContent ? response : null;
+}
+// The same for a profile container, whose three entity types are siblings rather than a hierarchy.
+export function profileResponseFromBlobs(blobs) {
+    const response = proto_ProfileSyncOutResponse.create({});
+    let hasContent = false;
+    for (const blob of blobs) {
+        if (blob.id < 0n)
+            continue; // A fixed blob, not an entity
+        switch (Ids.getEntityTypeId(blob.id)) {
+            case proto_Constants.USER_ENTITY_TYPE_ID:
+                response.user = proto_User.fromBinary(blob.bytes);
+                break;
+            case proto_Constants.BUSINESS_LINK_ENTITY_TYPE_ID:
+                response.businessLinks.push(proto_BusinessLink.fromBinary(blob.bytes));
+                break;
+            case proto_Constants.BUSINESS_ENTITY_TYPE_ID:
+                response.businesses.push(proto_Business.fromBinary(blob.bytes));
+                break;
+            default:
+                continue; // An entity type this library does not understand
+        }
+        hasContent = true;
+    }
+    return hasContent ? response : null;
+}
+// The orders a container holds. The payload a message carries is what says whether it is an order or a cart - Message.messageType is not read, because here the payload is typed.
+export function orderMessagesFromBlobs(blobs) {
+    const result = [];
+    for (const message of messagesFromBlobs(blobs))
+        if (message.payload.oneofKind === "salesOrder")
+            result.push(message);
+    return result;
+}
+// The cart a container holds, or null when the customer has not put anything in one. A customer has one cart per business, so two means two callers' messages are in one container.
+// The most recently updated then wins for want of anything better: nothing in a message says which caller it was sent to - see THE MESSAGES OF A BUSINESS ARE NOT PUBLIC.
+export function cartMessageFromBlobs(blobs) {
+    let result = null;
+    for (const message of messagesFromBlobs(blobs)) {
+        if (message.payload.oneofKind !== "partyPreferences")
+            continue;
+        if (result === null ||
+            getEntity(message.entity).updateNumber > getEntity(result.entity).updateNumber)
+            result = message;
+    }
+    return result;
+}
+// #endregion
+// #region Requests and credentials
+// The request that asks for everything changed since these cursors.
+// attachmentBaseUrlExpiry is not a cursor, just the expiry of the url already held, sent back unchanged (zero when none is held).
+export function buildBusinessSyncOutRequest(businessId, syncInState, attachmentBaseUrlExpiry) {
+    return proto_BusinessSyncOutRequest.create({
+        businessId: businessId,
+        businessUpdateNumber: syncInState.getUpdateNumber(proto_Constants.BUSINESS_ENTITY_TYPE_ID),
+        attachmentUpdateNumber: syncInState.getUpdateNumber(proto_Constants.ATTACHMENT_ENTITY_TYPE_ID),
+        attachmentBaseUrlExpiry: attachmentBaseUrlExpiry,
+        configurationUpdateNumber: syncInState.getUpdateNumber(proto_Constants.CONFIGURATION_ENTITY_TYPE_ID),
+        messageUpdateNumber: syncInState.getUpdateNumber(proto_Constants.MESSAGE_ENTITY_TYPE_ID),
+        itemUpdateNumber: syncInState.getUpdateNumber(proto_Constants.ITEM_ENTITY_TYPE_ID),
+    });
+}
+// The first request of a business sync in, with cursors raised from what is already cached rather
+// than sent from zero - the same way nextBusinessSyncOutRequest raises them from a page just
+// arrived, but from a response already held.
+export function buildBusinessSyncOutRequestFromCache(businessId, cached) {
+    const cursors = new SyncState(SyncKeys.BUSINESS_SYNC_IN);
+    if (cached !== null)
+        for (const entity of getBusinessResponseEntities(cached))
+            cursors.raiseUpdateNumber(entity.entityTypeId, entity.updateNumber);
+    return buildBusinessSyncOutRequest(businessId, cursors, getBusinessResponseAttachmentBaseUrlExpiry(cached));
+}
+// The request that pushes back what this customer has changed. Messages are the only entity type a
+// storefront may push, and one request is one batch: an order and the cart it emptied go together,
+// so that a customer can never be left holding an order and a cart still full of the same items.
+// messageUpdateNumber is the cursor of what this customer already holds cached, so the response
+// brings back only what has changed since - this push's own messages, under the update numbers the
+// server assigns them, and anything else of theirs a later sync out would also pick up.
+export function buildBusinessSyncInRequest(messageUpdateNumber, messages) {
+    return proto_BusinessSyncInRequest.create({
+        messageUpdateNumber: messageUpdateNumber,
+        messages: [...messages],
+    });
+}
+// The messages a sync in response carried - this push's own, now bearing the update numbers the
+// server assigned them, and anything else of this customer's that changed since the cursor sent.
+export function getSyncInResponseMessages(response) {
+    return response.messages;
+}
+// The same, for the profile of the caller - names no business, since a profile sync is not scoped
+// to one and has no sync in.
+// joinBusinessId is the exception, and it is not a scope but an instruction: make the caller a
+// customer of that business, by entity id, while answering. Constants.ENTITY_ID_NULL asks for no
+// join, which is what every ordinary read carries, and it is the default for that reason. A join
+// belongs to one call and not to a read, so nextProfileSyncOutRequest leaves it off the pages that
+// follow - see there.
+export function buildProfileSyncOutRequest(syncInState, joinBusinessId = BigInt(proto_Constants.ENTITY_ID_NULL)) {
+    return proto_ProfileSyncOutRequest.create({
+        userUpdateNumber: syncInState.getUpdateNumber(proto_Constants.USER_ENTITY_TYPE_ID),
+        businessUpdateNumber: syncInState.getUpdateNumber(proto_Constants.BUSINESS_ENTITY_TYPE_ID),
+        businessLinkUpdateNumber: syncInState.getUpdateNumber(proto_Constants.BUSINESS_LINK_ENTITY_TYPE_ID),
+        joinBusinessId: joinBusinessId,
+    });
+}
+// The same, seeded from what the profile container already holds cached rather than from a fresh
+// SyncState - see buildBusinessSyncOutRequestFromCache, which this mirrors.
+export function buildProfileSyncOutRequestFromCache(cached, joinBusinessId = BigInt(proto_Constants.ENTITY_ID_NULL)) {
+    const cursors = new SyncState(SyncKeys.PROFILE_SYNC_IN);
+    if (cached !== null)
+        for (const entity of getProfileResponseEntities(cached))
+            cursors.raiseUpdateNumber(entity.entityTypeId, entity.updateNumber);
+    return buildProfileSyncOutRequest(cursors, joinBusinessId);
+}
+// The user a sign up asks the server to create, as CreateUserRequest.user. Built from the domain
+// object rather than carrying one of its own: this user has no entity yet - the server assigns id,
+// createdAt and updatedAt on creation - so none of EntityHeader goes out here.
+export function buildUser(userProfile) {
+    return proto_User.create({
+        firstName: userProfile.firstName,
+        lastName: stringToProto(userProfile.lastName),
+        mobilePhoneNumber: userProfile.mobilePhoneNumber,
+        addresses: addressListToProto(userProfile.addresses),
+        preferredLanguageCode: stringToProto(userProfile.preferredLanguageCode),
+    });
+}
+// The user Service.updateUser asks the server to overwrite this customer's profile with - the same
+// fields as buildUser, plus the one field that call matches the caller by: its own entity id.
+// Nothing else of EntityHeader goes out, because nothing else of it is read on that call.
+export function buildUpdateUser(userProfile) {
+    return proto_User.create({
+        ...buildUser(userProfile),
+        entity: proto_Entity.create({ id: userProfile.id }),
+    });
+}
+// The two halves of what a join must be answered with, each asked separately so that a caller
+// reporting a server that answered without one can say which was missing - see
+// Model.requireJoinedBusiness. Both take the id rather than the request, because both of the
+// requests that carry a joinBusinessId need them.
+// The membership itself: a live BusinessLink naming that business. A tombstoned one is not a
+// membership - see OBJECT MODEL - so it does not count, and neither does a link to any other
+// business. Its linkToken is the only copy of that credential a profile response carries.
+export function hasJoinedBusinessLink(joinBusinessId, response) {
+    if (joinBusinessId === BigInt(proto_Constants.ENTITY_ID_NULL))
+        return false;
+    for (const businessLink of response.businessLinks)
+        if (businessLink.businessId === joinBusinessId &&
+            !isDeletedEntity(getEntity(businessLink.entity)))
+            return true;
+    return false;
+}
+// The business that link names, matched on Business.entity.id - which is what
+// BusinessLink.businessId is, and not Business.businessId, the url friendly string. A caller needs
+// it as well as the link, because the string is what every later request and container name for
+// that business is built out of, and the link carries only the id.
+export function hasJoinedBusiness(joinBusinessId, response) {
+    if (joinBusinessId === BigInt(proto_Constants.ENTITY_ID_NULL))
+        return false;
+    for (const business of response.businesses)
+        if (getEntity(business.entity).id === joinBusinessId)
+            return true;
+    return false;
+}
+// The credentials of one call, as the wire carries them. An absent token is left off the message
+// rather than sent empty, because the protocol tells the two apart.
+export function buildAuthTokens(authTokens) {
+    const result = proto_AuthTokens.create({
+        authenticationMethod: authTokens.authenticationMethod,
+        authenticationToken: authTokens.authenticationToken,
+    });
+    const userToken = authTokens.userToken;
+    if (userToken !== null)
+        result.userToken = userToken;
+    const linkToken = authTokens.linkToken;
+    if (linkToken !== null)
+        result.linkToken = linkToken;
+    return result;
+}
+// What a server issued while answering a call, in the terms this library holds credentials in
+export function authTokensFromProto(authTokens) {
+    return new AuthTokens(authTokens.authenticationMethod, authTokens.authenticationToken, stringFromProto(authTokens.userToken), stringFromProto(authTokens.linkToken));
+}
+// The authorization header of a request, encoded. Lives here because this is the only file that
+// writes a proto field; a transport puts these bytes in the header however it wants.
+export function buildAuthTokensBytes(authTokens) {
+    return proto_AuthTokens.toBinary(authTokens);
+}
+// How a container keeps the credentials it earned: the two tokens this server issued, with a null eTag because a reissued token is not a later version of an earlier one and greater-wins would refuse it.
+// The authentication token is left out however it was passed in: it belongs to the identity provider, so a stored copy could only be staler than the one held in memory and would outlive the sign out that should have ended it.
+export function authTokensToBlob(authTokens) {
+    const stored = proto_AuthTokens.create({
+        authenticationMethod: authTokens.authenticationMethod,
+    });
+    const userToken = authTokens.userToken;
+    if (userToken !== null)
+        stored.userToken = userToken;
+    const linkToken = authTokens.linkToken;
+    if (linkToken !== null)
+        stored.linkToken = linkToken;
+    return {
+        id: Ids.AUTH_TOKENS_BLOB_ID,
+        eTag: null,
+        bytes: buildAuthTokensBytes(stored),
+    };
+}
+export function authTokensFromBytes(bytes) {
+    return authTokensFromProto(proto_AuthTokens.fromBinary(bytes));
+}
+// #endregion
+// #region Paging
+// What the server issued while answering, which every response of this protocol carries in the same
+// field - the two sync outs and a sync in alike.
+export function getResponseAuthTokens(response) {
+    return response.authTokens;
+}
+export function refreshAuthTokens(authTokens, issued) {
+    if (authTokens === null || issued === undefined)
+        return authTokens;
+    const result = proto_AuthTokens.create(authTokens);
+    if (issued.userToken !== undefined)
+        result.userToken = issued.userToken;
+    if (issued.linkToken !== undefined)
+        result.linkToken = issued.linkToken;
+    return result;
+}
+// The request that asks for the page after this response, or null when this response was the last.
+// A response carrying a full page has been cut short, so the cursors are raised from what arrived
+// and the call is repeated. A full page that raised no cursor at all can only come from a server
+// breaking the ascending order it promises; the loop is unbounded, so it stops rather than trust it.
+export function nextBusinessSyncOutRequest(request, response) {
+    // Anything short of a full page is the server saying it has sent everything it had. Counted
+    // before anything is looked at, so the ordinary answer costs no more than reading nine lengths.
+    if (businessResponseEntityCount(response) < proto_Constants.SYNC_OUT_LIMIT)
+        return null;
+    const cursors = businessSyncOutCursors(request);
+    let haveCursorsRisen = false;
+    const raise = (entity) => {
+        if (raiseCursor(cursors, entity))
+            haveCursorsRisen = true;
+    };
+    if (response.business !== undefined)
+        raise(response.business.entity);
+    for (const attachment of response.attachments)
+        raise(attachment.entity);
+    for (const configuration of response.configurations)
+        raise(configuration.entity);
+    for (const message of response.messages)
+        raise(message.entity);
+    for (const productCategory of response.productCategories)
+        raise(getItem(productCategory.item).entity);
+    for (const product of response.products)
+        raise(getItem(product.item).entity);
+    for (const pkg of response.packages)
+        raise(getItem(pkg.item).entity);
+    for (const priceList of response.priceLists)
+        raise(getItem(priceList.item).entity);
+    for (const price of response.prices)
+        raise(getItem(price.item).entity);
+    if (!haveCursorsRisen)
+        return null;
+    // A page that renewed the url means a later one is now held; otherwise what was sent still stands
+    const renewedExpiry = getBusinessResponseAttachmentBaseUrlExpiry(response);
+    return buildBusinessSyncOutRequest(request.businessId, cursors, renewedExpiry === 0n ? request.attachmentBaseUrlExpiry : renewedExpiry);
+}
+// The same for a profile read. Any joinBusinessId the first request carried is deliberately left
+// off the ones that follow: a join is done once, by the call that asked for it.
+export function nextProfileSyncOutRequest(request, response) {
+    if (profileResponseEntityCount(response) < proto_Constants.SYNC_OUT_LIMIT)
+        return null;
+    const cursors = profileSyncOutCursors(request);
+    let haveCursorsRisen = false;
+    if (raiseCursor(cursors, response.user?.entity))
+        haveCursorsRisen = true;
+    for (const businessLink of response.businessLinks)
+        if (raiseCursor(cursors, businessLink.entity))
+            haveCursorsRisen = true;
+    for (const business of response.businesses)
+        if (raiseCursor(cursors, business.entity))
+            haveCursorsRisen = true;
+    // A full page that raised nothing can only come from a server breaking the ascending order it
+    // promises; the loop is unbounded, so it stops rather than trust it
+    if (!haveCursorsRisen)
+        return null;
+    return buildProfileSyncOutRequest(cursors);
+}
+// How many entities a response carried, without decoding or encoding any of them - a paging loop
+// asks this of every page, and getBusinessResponseEntities answers the same question only by encoding each
+// entity for the cache on the way past.
+function businessResponseEntityCount(response) {
+    return ((response.business === undefined ? 0 : 1) +
+        response.attachments.length +
+        response.configurations.length +
+        response.messages.length +
+        response.productCategories.length +
+        response.products.length +
+        response.packages.length +
+        response.priceLists.length +
+        response.prices.length);
+}
+function profileResponseEntityCount(response) {
+    return ((response.user === undefined ? 0 : 1) +
+        response.businessLinks.length +
+        response.businesses.length);
+}
+// Raises the cursor one entity advances, and answers whether it moved. A tombstone counts exactly
+// as a value does - skipping one would have the server send it again for ever.
+function raiseCursor(cursors, entity) {
+    if (entity === undefined)
+        return false;
+    return cursors.raiseUpdateNumber(Ids.getEntityTypeId(entity.id), entity.updateNumber);
+}
+// The cursors a request is carrying, as a state that can be raised - the inverse of the two builders
+// above, and how a paging loop carries what it has already been sent into the call after it.
+function businessSyncOutCursors(request) {
+    const cursors = new SyncState(SyncKeys.BUSINESS_SYNC_IN);
+    cursors.raiseUpdateNumber(proto_Constants.BUSINESS_ENTITY_TYPE_ID, request.businessUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.ATTACHMENT_ENTITY_TYPE_ID, request.attachmentUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.CONFIGURATION_ENTITY_TYPE_ID, request.configurationUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.MESSAGE_ENTITY_TYPE_ID, request.messageUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.ITEM_ENTITY_TYPE_ID, request.itemUpdateNumber);
+    return cursors;
+}
+function profileSyncOutCursors(request) {
+    const cursors = new SyncState(SyncKeys.PROFILE_SYNC_IN);
+    cursors.raiseUpdateNumber(proto_Constants.USER_ENTITY_TYPE_ID, request.userUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.BUSINESS_ENTITY_TYPE_ID, request.businessUpdateNumber);
+    cursors.raiseUpdateNumber(proto_Constants.BUSINESS_LINK_ENTITY_TYPE_ID, request.businessLinkUpdateNumber);
+    return cursors;
+}
+// #endregion
+// #region A response as an object graph
+// The whole of one business as an object graph, regrouping the flat wire entities by owner id so each class can be constructed with its children.
+// An entity whose parent is missing is dropped, since a paged read can hold a child whose parent has yet to arrive; null when the response carries no Business at all.
+export function buildBusiness(response) {
+    const businessProto = response.business;
+    if (businessProto === undefined || isDeletedEntity(getEntity(businessProto.entity)))
+        return null;
+    const business = businessFromProto(businessProto);
+    const updatableBusiness = business;
+    // Resolved once here and handed to every Photo built below, since a photo takes the base url in
+    // effect when it is built rather than looking one up later - see the comment on Photo's constructor.
+    const attachmentBaseUrlProto = response.attachmentBaseUrl;
+    const attachmentBaseUrl = attachmentBaseUrlProto === undefined ? null : attachmentBaseUrlFromProto(attachmentBaseUrlProto);
+    updatableBusiness.attachmentBaseUrl = attachmentBaseUrl;
+    // Attachments, grouped by owner
+    const attachmentsByOwner = new Map();
+    for (const attachmentProto of response.attachments) {
+        if (isDeletedEntity(getEntity(attachmentProto.entity)))
+            continue;
+        const attachment = attachmentFromProto(attachmentProto);
+        const owned = attachmentsByOwner.get(attachment.owningEntityId);
+        if (owned === undefined)
+            attachmentsByOwner.set(attachment.owningEntityId, [attachment]);
+        else
+            owned.push(attachment);
+    }
+    // The settings, unwrapped from the one public configuration that carries them
+    for (const configuration of response.configurations) {
+        if (isDeletedEntity(getEntity(configuration.entity)))
+            continue;
+        if (configuration.data.oneofKind !== "generalSettings")
+            continue; // Not a configuration this library understands
+        updatableBusiness.settings = generalSettingsFromProto(configuration.data.generalSettings);
+    }
+    // The photos of the store itself
+    updatableBusiness.photos = takePhotos(attachmentsByOwner, business.id, attachmentBaseUrl);
+    // Prices, by the package each applies to. Only the MeraBills Online list is this storefront's -
+    // a business prices the same package in several lists, and a price from any other one is not
+    // what it sells at here, so it is passed over rather than allowed to win a package. Within that
+    // one list a package has one price; if a second arrives anyway, the first is kept.
+    const pricesByPackage = new Map();
+    for (const priceProto of response.prices) {
+        if (isDeletedItem(priceProto.item))
+            continue;
+        const price = priceFromProto(priceProto);
+        if (price.priceListId !== MERABILLS_ONLINE_PRICE_LIST_ID)
+            continue;
+        if (!pricesByPackage.has(price.packageId))
+            pricesByPackage.set(price.packageId, price);
+    }
+    // Packages, by the product each belongs to, built with their photos and their price. A package
+    // that is not buyable - disabled, unpriced, or priced with a price that is itself disabled - is
+    // left out here rather than handed to the UI unbuyable: a product-level filter does not, by
+    // itself, guarantee every package of an otherwise visible product is itself enabled.
+    const packagesByProduct = new Map();
+    for (const packageProto of response.packages) {
+        if (isDeletedItem(packageProto.item))
+            continue;
+        const packageId = getItemId(packageProto.item);
+        const packagePhotos = takePhotos(attachmentsByOwner, packageId, attachmentBaseUrl);
+        const pkg = packageFromProto(packageProto, packagePhotos, pricesByPackage.get(packageId) ?? null);
+        if (!pkg.isBuyable)
+            continue;
+        const price = pkg.price;
+        if (price !== null)
+            UpdatableEntity.setParent(price, pkg);
+        const siblings = packagesByProduct.get(pkg.productId);
+        if (siblings === undefined)
+            packagesByProduct.set(pkg.productId, [pkg]);
+        else
+            siblings.push(pkg);
+    }
+    // Products, built with their photos and their buyable packages, and parented to the business
+    // (not their category, which only groups them). A product that is not buyable - disabled, or
+    // left with no buyable package by the filtering above - is left out for the same reason.
+    const products = [];
+    for (const productProto of response.products) {
+        if (isDeletedItem(productProto.item))
+            continue;
+        const productId = getItemId(productProto.item);
+        const packages = packagesByProduct.get(productId) ?? [];
+        const productPhotos = takePhotos(attachmentsByOwner, productId, attachmentBaseUrl);
+        const product = productFromProto(productProto, productPhotos, Object.freeze([...packages]));
+        if (!product.isBuyable)
+            continue;
+        UpdatableEntity.setParent(product, business);
+        for (const pkg of packages)
+            UpdatableEntity.setParent(pkg, product);
+        products.push(product);
+    }
+    const productCategories = [];
+    for (const productCategoryProto of response.productCategories) {
+        if (isDeletedItem(productCategoryProto.item))
+            continue;
+        const productCategory = productCategoryFromProto(productCategoryProto);
+        UpdatableEntity.setParent(productCategory, business);
+        productCategories.push(productCategory);
+    }
+    // The one list a storefront sells from is MeraBills Online, named rather than taken to be
+    // whichever list arrived first: the same sync can carry others, and the catalog has to answer
+    // with the list the prices above came from or a cart would name one they did not.
+    let priceList = null;
+    for (const priceListProto of response.priceLists) {
+        if (isDeletedItem(priceListProto.item))
+            continue;
+        if (getItemId(priceListProto.item) !== MERABILLS_ONLINE_PRICE_LIST_ID)
+            continue;
+        priceList = priceListFromProto(priceListProto);
+        UpdatableEntity.setParent(priceList, business);
+        break;
+    }
+    updatableBusiness.catalog = new Catalog(productCategories, products, priceList);
+    // The orders of this customer, and their cart. A message of any other payload type is dropped.
+    const orders = [];
+    let cart = null;
+    let cartUpdateNumber = 0n;
+    for (const message of response.messages) {
+        if (isDeletedEntity(getEntity(message.entity)))
+            continue;
+        switch (message.payload.oneofKind) {
+            case "salesOrder": {
+                orders.push(orderFromProto(message, message.payload.salesOrder));
+                break;
+            }
+            case "partyPreferences": {
+                // One customer has one cart, so two means two callers' messages are in one container - see
+                // cartMessageFromBlobs, which breaks the tie the same way
+                const updateNumber = getEntity(message.entity).updateNumber;
+                if (cart !== null && updateNumber <= cartUpdateNumber)
+                    break;
+                // An emptied cart is a message whose payload carries no shopping list, which is what
+                // placing an order leaves behind - so it answers null and not an empty list, the same as
+                // never having had a cart at all
+                cart = cartShoppingListFromProto(message.payload.partyPreferences);
+                cartUpdateNumber = updateNumber;
+                break;
+            }
+            // No default: MONEY_TRANSFER has no payload in this protocol, and OTHER is not ours
+        }
+    }
+    for (const order of orders)
+        UpdatableEntity.setParent(order, business);
+    updatableBusiness.orders = Object.freeze(orders);
+    updatableBusiness.cart = cart;
+    return business;
+}
+// One profile as an object graph: the caller, their links, and the businesses those links name.
+// Returns null when the response carries none of the three.
+export function buildProfile(profileId, response) {
+    let user = null;
+    const businessLinks = [];
+    const businesses = [];
+    const userProto = response.user;
+    if (userProto !== undefined && !isDeletedEntity(getEntity(userProto.entity)))
+        user = userProfileFromProto(userProto);
+    for (const businessLink of response.businessLinks) {
+        if (isDeletedEntity(getEntity(businessLink.entity)))
+            continue;
+        businessLinks.push(businessLinkFromProto(businessLink));
+    }
+    for (const business of response.businesses) {
+        if (isDeletedEntity(getEntity(business.entity)))
+            continue;
+        businesses.push(businessProfileFromProto(business));
+    }
+    if (user === null && businessLinks.length === 0 && businesses.length === 0)
+        return null;
+    return new Profile(profileId, user, businessLinks, businesses);
+}
+// One order on its own, for a caller holding a message rather than a whole response
+export function buildOrder(message) {
+    if (message.payload.oneofKind !== "salesOrder")
+        return null;
+    return orderFromProto(message, message.payload.salesOrder);
+}
+// The cart one message holds, for a caller holding a message rather than a whole response. Null for
+// a message that is not a cart, and null for a cart that has been emptied - see the party
+// preferences case of buildBusiness.
+export function buildCart(message) {
+    if (message.payload.oneofKind !== "partyPreferences")
+        return null;
+    return cartShoppingListFromProto(message.payload.partyPreferences);
+}
+// #endregion
+// #region What a customer pushes
+//
+// The only direction of this file that encodes rather than decodes, and the only entity type a
+// storefront may write: a Message, carrying either the cart or an order placed from it. Two rules
+// hold for both, and they are what make a pushed message storable here as well as on the server.
+// The first is that the id is the client's: a sync in answers with an update number and no id, so a
+// message the server named could never be found here again. The second is that updatedAt is the
+// client's too and the server keeps it unchanged - so the copy stored here carries the same eTag as
+// the copy a later read would bring back, and neither can look stale to the other.
+// The cart of this customer as a message to push. An existing message is amended rather than
+// rebuilt, because its payload carries fields this protocol does not expose - the fulfillment mode
+// the merchant app keeps there among them - and losing them would be a storefront overwriting
+// merchant data it cannot even read.
+// Its id is used in preference to the derived one for the same reason: that is where the server
+// already holds this cart, and it is only worth deriving an id when there is no cart to amend.
+// A list holding nothing is pushed as no list at all, the way Java serializeShoppingList answers
+// null below one item - so emptying a cart and never having had one are one state on the wire, and
+// placing an order is what puts a cart into it.
+export function buildCartMessage(cartMessageId, existing, senderId, shoppingList, now) {
+    const existingEntity = existing === null ? null : getEntity(existing.entity);
+    const preferences = existing !== null && existing.payload.oneofKind === "partyPreferences"
+        ? existing.payload.partyPreferences
+        : proto_PartyPreferencesPayload.create();
+    // Later than the copy it replaces, whatever this client's clock reads. A store keeps a blob only
+    // where its eTag is the greater, and that eTag is this field - so a client whose clock sits behind
+    // the time on the cart it is amending, which Constants.MAX_CLOCK_SKEW says is a thing that
+    // happens, would push a change the server accepted and then have its own store refuse it, leaving
+    // the two disagreeing about the cart the customer is looking at. One millisecond past the copy
+    // being replaced is enough, and the server keeps whatever is sent, so both sides still agree.
+    const updatedAt = existingEntity === null || existingEntity.updatedAt < now ? now : existingEntity.updatedAt + 1n;
+    return proto_Message.create({
+        entity: pushedEntity(existingEntity?.id ?? cartMessageId, existingEntity?.createdAt ?? updatedAt, updatedAt),
+        senderId: senderId,
+        messageType: proto_MessageType.PARTY_PREFERENCES,
+        status: proto_TaskStatus.NOT_YET_PROCESSED,
+        payload: {
+            oneofKind: "partyPreferences",
+            partyPreferences: proto_PartyPreferencesPayload.create({
+                ...preferences,
+                shoppingList: pushedShoppingList(shoppingList, false),
+            }),
+        },
+    });
+}
+// One order as a message to push. Its shopping list goes out final whatever was passed in, which is
+// what Java SalesOrderViewModel.saveChanges does before creating one: an order is what a customer
+// has finished choosing, and only a final list tracks a later change as a change rather than
+// silently altering what was ordered.
+// The two totals are filled in here from the list, and are what a fulfilled order is left with once
+// the business has cleared the list itself - so they are written off the items actually being sent
+// rather than off the counts the list carries, which a caller could have set to anything.
+export function buildOrderMessage(orderId, senderId, shoppingList, fulfillmentMode, deliveryAddressId, deliveryAddress, note, creationDate) {
+    return proto_Message.create({
+        entity: pushedEntity(orderId, creationDate, creationDate),
+        senderId: senderId,
+        messageType: proto_MessageType.SALES_ORDER,
+        status: proto_TaskStatus.NOT_YET_PROCESSED,
+        payload: {
+            oneofKind: "salesOrder",
+            salesOrder: proto_SalesOrderPayload.create({
+                status: proto_OrderStatus.NOT_STARTED,
+                fulfillmentMode: fulfillmentMode,
+                shoppingList: pushedShoppingList(shoppingList, true),
+                shoppingListTotal: amountToScaledValue(shoppingList.totalAmount),
+                shoppingListCount: shoppingList.existingItems.length,
+                deliveryAddressId: deliveryAddressId,
+                deliveryAddress: deliveryAddress === null ? undefined : addressToProto(deliveryAddress),
+                creationDate: creationDate,
+                note: stringToProto(note),
+            }),
+        },
+    });
+}
+// A sync in response's messages as the cache write they make, tombstones included - the same as any
+// other entity array this library reads off the wire. This is how a push's own messages end up
+// stored under the update numbers the server just assigned them, with no separate stamping step:
+// the response already carries them as full entities, not as a bare number to reapply by hand.
+export function messagesToCacheWrite(messages) {
+    return toCacheWrite(messages.map((message) => toWireEntity(message.entity, proto_Message.toBinary(message))));
+}
+// The highest update number among this customer's messages already cached, cart and orders alike -
+// what a push sends as its cursor. Computed fresh off the store each time rather than kept anywhere:
+// no cursor is persisted in this library, and this is no exception - see THE SYNC STATES in
+// ../Prompt.txt. Zero when none are cached, which is how a first push asks for everything back.
+export function highestCachedMessageUpdateNumber(blobs) {
+    let highest = 0n;
+    for (const message of messagesFromBlobs(blobs)) {
+        const updateNumber = getEntity(message.entity).updateNumber;
+        if (updateNumber > highest)
+            highest = updateNumber;
+    }
+    return highest;
+}
+// The Entity of something this client is pushing. The update number goes out as zero: the protocol
+// replaces a caller's own with the server's and answers what it assigned, so there is nothing to
+// send and nothing to guess. updateInfo goes out as zero too, which is not the same kind of zero -
+// it should be the id of this store, and this store has no id yet, so a read of this business will
+// send these messages back rather than recognising them as its own. That costs bandwidth and
+// nothing else, since the eTag of the copy stored here is the one the server kept.
+function pushedEntity(id, createdAt, updatedAt) {
+    return proto_Entity.create({ id: id, createdAt: createdAt, updatedAt: updatedAt });
+}
+// Whether a cart is worth the request, answered off what the store already holds - so a caller may
+// call updateCart as often as it likes and only a cart the server has not got costs anything.
+// Two ways it is worth sending. The list differs from the stored one, which is the ordinary case.
+// Or the stored copy has never been accepted: a pushed entity goes out with updateNumber zero and
+// comes back carrying the server's, so zero here means this cart was written by
+// Model.updateCartLocalOnly and has not been sent since.
+// The lists are compared rather than the messages, because a message always differs - updatedAt is
+// the clock's reading, and buildCartMessage moves it on every call. Comparing them is sound only
+// because the server keeps a pushed list exactly as it arrived, so what comes back is what went
+// out; a server that normalised the list would make every call differ and push every time, which
+// is what this library did before and so is no worse.
+export function isCartWorthPushing(stored, cartMessage) {
+    // Nothing stored and nothing to send: an emptied cart and one never created are one state
+    if (stored === null)
+        return getCartShoppingList(cartMessage) !== undefined;
+    if (getEntity(stored.entity).updateNumber === 0n)
+        return true;
+    return !proto_ShoppingList.equals(getCartShoppingList(stored), getCartShoppingList(cartMessage));
+}
+// The list inside a cart message, or absent for one carrying no list - which is an emptied cart
+function getCartShoppingList(message) {
+    return message.payload.oneofKind === "partyPreferences"
+        ? message.payload.partyPreferences.shoppingList
+        : undefined;
+}
+// A shopping list on its way out, or absent when it holds nothing - see buildCartMessage. Emptiness
+// is judged by the items being sent and not by the counts the list carries, for the reason the
+// counts below are.
+function pushedShoppingList(shoppingList, isFinal) {
+    if (shoppingList === null)
+        return undefined;
+    if (shoppingList.existingItems.length === 0 && shoppingList.deletedItems.length === 0)
+        return undefined;
+    return shoppingListToProto(shoppingList, isFinal);
+}
+// The counts are written off the arrays rather than copied from the list. A read takes them from the
+// wire because the protocol sends a count even where it does not send the items, but a push always
+// sends the items - so the arrays are what is true here, and taking the counts from them is what
+// makes it impossible to push a list whose count disagrees with its contents.
+function shoppingListToProto(shoppingList, isFinal) {
+    return proto_ShoppingList.create({
+        isFinal: isFinal,
+        autoAddDeliveryCharge: shoppingList.autoAddDeliveryCharge,
+        autoAddServiceCharge: shoppingList.autoAddServiceCharge,
+        inventoryLocationId: shoppingList.inventoryLocationId,
+        priceListId: shoppingList.priceListId,
+        totalAmountBeforeDiscount: amountToScaledValue(shoppingList.totalAmountBeforeDiscount),
+        discount: amountToScaledValue(shoppingList.discount),
+        existingItemCount: shoppingList.existingItems.length,
+        deletedItemCount: shoppingList.deletedItems.length,
+        existingItems: shoppingList.existingItems.map(shoppingListItemToProto),
+        deletedItems: shoppingList.deletedItems.map(shoppingListItemToProto),
+    });
+}
+// The mirror of shoppingListItemFromProto: everything the model holds unscaled goes back scaled, and
+// nothing derived is sent - amount, totalTax and finalPrice are computed from these fields, here and
+// by the server both.
+function shoppingListItemToProto(item) {
+    return proto_ShoppingListItem.create({
+        packageId: item.packageId,
+        quantity: quantityToScaledValue(item.quantity),
+        unitPrice: amountToScaledValue(item.unitPrice),
+        shoppingListOrder: item.shoppingListOrder,
+        isOriginal: item.isOriginal,
+        isModified: item.isModified,
+        isStockKeepingRequired: item.isStockKeepingRequired,
+        priceDiscount: amountToScaledValue(item.priceDiscount),
+        discount: amountToScaledValue(item.discount),
+        taxes: item.taxes.map(taxToProto),
+        expiry: item.expiryMinutes,
+        description: stringToProto(item.description),
+    });
+}
+function taxToProto(tax) {
+    return proto_Tax.create({ type: tax.type, rate: taxRateToScaledValue(tax.rate) });
+}
+// #endregion
+// #region Entity and item bookkeeping
+// One pass over the entities of a response, splitting them into what is stored and what is removed:
+// a live entity becomes a blob, and a tombstone becomes an id to delete. The blob id is the entity
+// id, which is what makes one read of a container enough to sort it by entity type, and the eTag is
+// Entity.updatedAt.
+// Mutable arrays, so that businessResponseToCacheWrite can add the attachment base url to the blobs.
+function toCacheWrite(entities) {
+    const blobs = [];
+    const deletedIds = [];
+    for (const entity of entities) {
+        if (entity.isDeleted)
+            deletedIds.push(entity.id);
+        else
+            blobs.push({ id: entity.id, eTag: entity.updatedAt, bytes: entity.bytes });
+    }
+    return { blobs: blobs, deletedIds: deletedIds };
+}
+function messageToBlob(message) {
+    const entity = getEntity(message.entity);
+    return {
+        id: entity.id,
+        eTag: entity.updatedAt,
+        bytes: proto_Message.toBinary(message),
+    };
+}
+function messagesFromBlobs(blobs) {
+    const result = [];
+    for (const blob of blobs) {
+        if (blob.id < 0n)
+            continue; // A fixed blob, not an entity
+        if (Ids.getEntityTypeId(blob.id) !== proto_Constants.MESSAGE_ENTITY_TYPE_ID)
+            continue;
+        result.push(proto_Message.fromBinary(blob.bytes));
+    }
+    return result;
+}
+function toWireEntity(entity, bytes) {
+    if (entity === undefined)
+        throw new InvalidArgumentException("An entity of the response carries no Entity");
+    const isDeleted = isDeletedEntity(entity);
+    return {
+        id: entity.id,
+        entityTypeId: Ids.getEntityTypeId(entity.id),
+        updateNumber: entity.updateNumber,
+        updatedAt: entity.updatedAt,
+        isDeleted: isDeleted,
+        bytes: isDeleted ? EMPTY_BYTES : bytes,
+    };
+}
+// A tombstone: the update type is held in the last two bits of the update number
+function isDeletedEntity(entity) {
+    return ((entity.updateNumber & BigInt(proto_Constants.UPDATE_TYPE_MASK)) ===
+        BigInt(proto_Constants.UPDATE_TYPE_DELETED));
+}
+function isDeletedItem(item) {
+    return isDeletedEntity(getEntity(getItem(item).entity));
+}
+function toItemWireEntity(item, bytes) {
+    if (item === undefined)
+        throw new InvalidArgumentException("An item of the response carries no Item");
+    return toWireEntity(item.entity, bytes);
+}
+// The five fields every entity of the protocol carries, as one value - see EntityHeader
+function toEntityHeader(entity) {
+    return new EntityHeader(entity.id, entity.createdAt, entity.updatedAt, entity.updateNumber, entity.updateInfo);
+}
+function getEntity(entity) {
+    if (entity === undefined)
+        throw new InvalidArgumentException("A stored entity carries no Entity");
+    return entity;
+}
+function getItem(item) {
+    if (item === undefined)
+        throw new InvalidArgumentException("A stored item carries no Item");
+    return item;
+}
+function getItemId(item) {
+    return getEntity(getItem(item).entity).id;
+}
+// #endregion
+// #region Values
+// An absent optional string is null and not empty, because Java tells the two apart
+function stringFromProto(value) {
+    return value === undefined ? null : value;
+}
+// The way back. An empty string goes out absent as well: the two mean the same thing to a caller
+// that had nothing to say, and sending one of them would have the field come back as the other.
+function stringToProto(value) {
+    return value === null || value.length === 0 ? undefined : value;
+}
+// An absent optional bool is null - for Product.isManufacturedByBusiness that means "not said either way"
+function booleanFromProto(value) {
+    return value === undefined ? null : value;
+}
+function attachmentBaseUrlFromProto(urlAndToken) {
+    return new AttachmentBaseUrl(urlAndToken.resourceUrl, urlAndToken.sasToken, urlAndToken.expiry);
+}
+function addressFromProto(address) {
+    return new Address(address.id, address.addressType, stringFromProto(address.unitNumber), stringFromProto(address.community), stringFromProto(address.line2), stringFromProto(address.city), stringFromProto(address.state), stringFromProto(address.pinCode), address.countryCode);
+}
+// The way back, for a delivery address a customer sends out directly rather than by id - see
+// buildOrderMessage. id is sent as whatever Address carries, though it means nothing outside the
+// list it was read from and this address belongs to none.
+function addressToProto(address) {
+    return proto_Address.create({
+        id: address.id,
+        addressType: address.addressType,
+        unitNumber: stringToProto(address.unitNumber),
+        community: stringToProto(address.community),
+        line2: stringToProto(address.line2),
+        city: stringToProto(address.city),
+        state: stringToProto(address.state),
+        pinCode: stringToProto(address.pinCode),
+        countryCode: address.countryCode,
+    });
+}
+// The way back, for the addresses of a user being sent to the server rather than read from it.
+function addressListToProto(addressList) {
+    return proto_AddressList.create({
+        defaultAddressId: addressList.defaultAddressId,
+        addresses: addressList.addresses.map(addressToProto),
+    });
+}
+function addressListFromProto(addressList) {
+    if (addressList === undefined)
+        return AddressList.EMPTY;
+    return new AddressList(addressList.defaultAddressId, Object.freeze(addressList.addresses.map(addressFromProto)));
+}
+function taxFromProto(tax) {
+    return Tax.fromScaledValues(tax.type, tax.rate);
+}
+function latLongFromProto(latLong) {
+    if (latLong === undefined)
+        return null;
+    return new LatLong(latLong.latitude, latLong.longitude);
+}
+function dimensionsFromProto(dimensions) {
+    if (dimensions === undefined)
+        return null;
+    return new Dimensions(dimensions.unit, dimensions.length, dimensions.width, dimensions.height);
+}
+function weightFromProto(weight) {
+    if (weight === undefined)
+        return null;
+    return new Weight(weight.unit, weight.value);
+}
+function packageIdentifierFromProto(identifier) {
+    return new PackageIdentifier(identifier.type, identifier.value);
+}
+function businessIdentifierFromProto(identifier) {
+    return new BusinessIdentifier(identifier.type, identifier.value);
+}
+function paymentMethodDetailFromProto(detail) {
+    return new PaymentMethodDetail(detail.method, stringFromProto(detail.data));
+}
+function workingHoursRangeFromProto(range) {
+    return new WorkingHoursRange(range.openMinute, range.closeMinute);
+}
+function workingHoursFromProto(workingHours) {
+    return new WorkingHours(Object.freeze(workingHours.ranges.map(workingHoursRangeFromProto)));
+}
+// An absent WorkingDays means the business works every day, all day - the Java default, not "no day at all"
+function workingDaysFromProto(workingDays) {
+    if (workingDays === undefined)
+        return WorkingDays.ALL_DAYS;
+    return new WorkingDays(Object.freeze([...workingDays.days]), Object.freeze(workingDays.workingHours.map(workingHoursFromProto)));
+}
+function shoppingListItemFromProto(item) {
+    return ShoppingListItem.fromScaledValues(item.packageId, item.quantity, item.unitPrice, item.shoppingListOrder, item.isOriginal, item.isModified, item.isStockKeepingRequired, item.priceDiscount, item.discount, Object.freeze(item.taxes.map(taxFromProto)), item.expiry, stringFromProto(item.description));
+}
+function shoppingListFromProto(shoppingList) {
+    if (shoppingList === undefined)
+        return ShoppingList.EMPTY;
+    return ShoppingList.fromScaledValues(shoppingList.isFinal, shoppingList.autoAddDeliveryCharge, shoppingList.autoAddServiceCharge, shoppingList.inventoryLocationId, shoppingList.priceListId, shoppingList.totalAmountBeforeDiscount, shoppingList.discount, shoppingList.existingItemCount, shoppingList.deletedItemCount, Object.freeze(shoppingList.existingItems.map(shoppingListItemFromProto)), Object.freeze(shoppingList.deletedItems.map(shoppingListItemFromProto)));
+}
+function generalSettingsFromProto(settings) {
+    return GeneralSettings.fromScaledValues(Object.freeze(settings.paymentMethodDetails.map(paymentMethodDetailFromProto)), stringFromProto(settings.customerServicePhone), settings.isWhatsAppSupported, settings.isSmsSupported, addressListFromProto(settings.businessAddresses), Object.freeze(settings.businessIdentifiers.map(businessIdentifierFromProto)), Object.freeze([...settings.fulfillmentModes]), settings.deliveryCharge, Object.freeze(settings.deliveryChargeTaxes.map(taxFromProto)), settings.freeDeliveryTotal, settings.deliveryRadiusKms, stringFromProto(settings.storeTagline), workingDaysFromProto(settings.workingDays), latLongFromProto(settings.primaryStoreLocation), stringFromProto(settings.googleBusinessCategoryId), stringFromProto(settings.googleBusinessCategoryName), stringFromProto(settings.onlineStoreThemeId));
+}
+// #endregion
+// #region Entities
+function businessFromProto(businessProto) {
+    const entity = getEntity(businessProto.entity);
+    return new Business(toEntityHeader(entity), businessProto.businessId, businessProto.displayName, businessProto.countryCode);
+}
+function userProfileFromProto(userProto) {
+    const entity = getEntity(userProto.entity);
+    return new UserProfile(toEntityHeader(entity), userProto.firstName, stringFromProto(userProto.lastName), userProto.mobilePhoneNumber, addressListFromProto(userProto.addresses), stringFromProto(userProto.preferredLanguageCode));
+}
+// The profile database copy of a business - see BusinessProfile for why this is not a Business
+function businessProfileFromProto(businessProto) {
+    const entity = getEntity(businessProto.entity);
+    return new BusinessProfile(toEntityHeader(entity), businessProto.businessId, businessProto.displayName, businessProto.countryCode);
+}
+function businessLinkFromProto(businessLinkProto) {
+    const entity = getEntity(businessLinkProto.entity);
+    return new BusinessLink(toEntityHeader(entity), businessLinkProto.linkedEntityId, businessLinkProto.businessId, businessLinkProto.role, businessLinkProto.partyId, stringFromProto(businessLinkProto.linkToken), businessLinkProto.expiry);
+}
+function attachmentFromProto(attachmentProto) {
+    const entity = getEntity(attachmentProto.entity);
+    return new Attachment(toEntityHeader(entity), attachmentProto.attachmentType, attachmentProto.owningEntityId, attachmentProto.fileHash ?? null, stringFromProto(attachmentProto.fileExtension), stringFromProto(attachmentProto.fileName));
+}
+function productCategoryFromProto(productCategoryProto) {
+    const item = getItem(productCategoryProto.item);
+    const entity = getEntity(item.entity);
+    return new ProductCategory(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled);
+}
+function priceListFromProto(priceListProto) {
+    const item = getItem(priceListProto.item);
+    const entity = getEntity(item.entity);
+    return new PriceList(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled);
+}
+function priceFromProto(priceProto) {
+    const item = getItem(priceProto.item);
+    const entity = getEntity(item.entity);
+    return Price.fromScaledValues(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, priceProto.packageId, priceProto.regularPrice, priceProto.offerPrice);
+}
+function packageFromProto(packageProto, photos, price) {
+    const item = getItem(packageProto.item);
+    const entity = getEntity(item.entity);
+    return new Package(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, packageProto.isSoldLoose, packageProto.itemCode, Object.freeze(packageProto.identifiers.map(packageIdentifierFromProto)), dimensionsFromProto(packageProto.dimensions), weightFromProto(packageProto.weight), photos, price);
+}
+function productFromProto(productProto, photos, packages) {
+    const item = getItem(productProto.item);
+    const entity = getEntity(item.entity);
+    return new Product(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, productProto.productType, stringFromProto(productProto.brand), booleanFromProto(productProto.isManufacturedByBusiness), stringFromProto(productProto.manufacturer), productProto.manufacturerAddress === undefined
+        ? null
+        : addressFromProto(productProto.manufacturerAddress), Object.freeze(productProto.taxes.map(taxFromProto)), Object.freeze([...productProto.features]), photos, packages);
+}
+function orderFromProto(message, salesOrder) {
+    const entity = getEntity(message.entity);
+    return Order.fromScaledValues(toEntityHeader(entity), message.senderId, message.status, stringFromProto(message.senderName), stringFromProto(message.senderPhone), salesOrder.status, salesOrder.fulfillmentMode, shoppingListFromProto(salesOrder.shoppingList), salesOrder.shoppingListTotal, salesOrder.shoppingListCount, salesOrder.deliveryAddressId, salesOrder.deliveryAddress === undefined ? null : addressFromProto(salesOrder.deliveryAddress), salesOrder.creationDate, stringFromProto(salesOrder.note), salesOrder.paymentReceived);
+}
+// The one part of a cart message a customer is shown. Absent rather than empty when the cart holds
+// nothing, so that "emptied by placing an order" and "never had one" are the same answer - which is
+// also what makes createOrder's emptied cart indistinguishable from a cart that was never created.
+// Everything else the message carries is the server's: who sent it, how far the business has got
+// with reading it, and the fulfillment mode Java keeps there, which belongs to an order here.
+function cartShoppingListFromProto(partyPreferences) {
+    const shoppingList = partyPreferences.shoppingList;
+    return shoppingList === undefined ? null : shoppingListFromProto(shoppingList);
+}
+// #endregion
+// #region Photos
+// The photos of one entity, in no particular order - a UI orders these for display. Each is built
+// with the base url resolved for this response, since a Photo takes it at construction rather than
+// looking it up later.
+function takePhotos(attachmentsByOwner, owningEntityId, attachmentBaseUrl) {
+    const attachments = attachmentsByOwner.get(owningEntityId);
+    if (attachments === undefined)
+        return NO_PHOTOS;
+    return Object.freeze(attachments.map((attachment) => new Photo(attachment, attachmentBaseUrl)));
+}
+// #endregion
+const EMPTY_BYTES = new Uint8Array(0);
+const NO_PHOTOS = Object.freeze([]);