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

package/dist/SyncCache.js

@@ -1,38 +1,64 @@
+import { Constants as proto_Constants } from "./generated/Constants";
 import Ids from "./Ids";
 import * as ProtoMap from "./ProtoMap";
+import * as SyncKeys from "./SyncKeys";
 // What the server has already said, so that the next call need only ask for what has changed since. A read cache and nothing else: everything in it came out of a response, so giving a container up costs one refetch.
-// Not write through, not an identity (it stamps nothing) and not a sync - a caller calls the Service and hands the response in, which is why the cursors are the caller's. It holds the wire and only the wire, and ProtoMap reads every field. See SYNC LAYER in ../Prompt.txt.
-// One response is one write: the entities it brought are stored and the entities its tombstones
-// named are deleted, in a single batch. There is nothing to work out beyond that, because the
-// server sends a tombstone for every entity it deleted, children included - so this cache never
-// infers a deletion from another one, and a write costs one transaction whether or not the page
-// happened to carry a tombstone.
+// Not write through, not an identity (it stamps nothing) and not a sync - a caller calls the Service and hands the response in, which is why the paging, and which writes are reads, are the caller's. It holds the wire and only the wire, and ProtoMap reads every field. See SYNC LAYER in ../Prompt.txt.
+// One response is one write: every entity it brought, and every tombstone, is stored in a single
+// batch. A tombstone is kept, as a blob that nothing older replaces, and there is nothing to work out
+// beyond that, because the server sends a tombstone for every entity it deleted, children included - so
+// this cache never infers a deletion from another one.
+// How far a container has been read is kept too, as a blob of its own for each entity type and not
+// worked out from the entities: a read that came back with tombstones, or changes made by this
+// client, would otherwise move it. It moves only with a page of a read, in the batch of the page that
+// moved it, and only upwards: each blob is versioned by its cursor, so the store keeps the greater.
 export default class SyncCache {
     constructor(_database) {
         this._database = _database;
         this._containers = new Map();
     }
     // Everything cached for one business, as the response that carried it, or null before anything has been written for it.
+    // Tombstones are among it, as the entities they are of, and whatever builds on this has to leave them out.
     async readBusiness(containerName) {
         return ProtoMap.businessResponseFromBlobs(await this.readAll(containerName));
     }
-    // Takes in what one business sync out returned, one blob per entity versioned by Entity.updatedAt, so the later of two copies wins and a page that arrives twice changes nothing the second time.
-    // What its tombstones named goes in the same batch, deleted rather than stored: a page brings what
-    // has changed and says what has gone, and applying half of that would leave the cache holding an
-    // entity the server has already reported dead.
-    // Answers how much of the page it kept - blobs stored plus ids deleted, which is what the container
-    // now differs by. That is how a caller tells a response that changed something from one that
-    // changed nothing, and what it publishes on: the store keeps a blob only when its eTag is later, so
-    // a response can be rejected in full, and one that was cannot change what a later read of this
-    // container answers - see MODEL.
+    // The cursors the next read of this business sends, which is how far the reads of it have got: the
+    // highest update number of every entity type that a page of one brought, tombstones included, and zero for a
+    // type that none has. Nothing else moves them, so, what this client pushes is read back by the next read.
+    async readBusinessCursors(containerName) {
+        return this.readCursors(containerName, SyncKeys.BUSINESS_SYNC_IN);
+    }
+    // Takes in one page of a business read, one blob per entity versioned by ProtoMap.entityETag, so the later of two copies wins and a page that arrives twice changes nothing the second time.
+    // A tombstone is stored the same way, and wins over the copies of what it is of, a delete being a later write than any of them. The cursors are raised
+    // by the page, tombstones included, in the same batch: they cannot get ahead of the entities they
+    // describe, and an interrupted read repeats itself from where its last page got to.
+    // Answers how much of the page it kept - the blobs stored, which is what the container now differs
+    // by. That is how a caller tells a response that changed something from one that changed nothing,
+    // and what it publishes on: the store keeps a blob only when its eTag is later, so a response can be
+    // rejected in full, and one that was cannot change what a later read of this container answers - see MODEL.
     async writeBusiness(containerName, response) {
+        return this.writeRead(containerName, ProtoMap.businessResponseToCacheWrite(response), SyncKeys.BUSINESS_SYNC_IN, (cursors) => ProtoMap.raiseBusinessCursors(cursors, response));
+    }
+    // Takes in what a business response brought that was not read, which moves no cursor: it is how
+    // far the container has been read that this does not change, and what is merged in here is not
+    // something this container was read for. Otherwise the same as writeBusiness.
+    async storeBusiness(containerName, response) {
         return this.write(containerName, ProtoMap.businessResponseToCacheWrite(response));
     }
     // The same for one profile: the customer, the businesses they may reach, and the link to each.
     async readProfile(containerName) {
         return ProtoMap.profileResponseFromBlobs(await this.readAll(containerName));
     }
+    async readProfileCursors(containerName) {
+        return this.readCursors(containerName, SyncKeys.PROFILE_SYNC_IN);
+    }
+    // One page of a profile read - see writeBusiness
     async writeProfile(containerName, response) {
+        return this.writeRead(containerName, ProtoMap.profileResponseToCacheWrite(response), SyncKeys.PROFILE_SYNC_IN, (cursors) => ProtoMap.raiseProfileCursors(cursors, response));
+    }
+    // What a call that is not a read answered with - a sign up, an update - which is a change this client
+    // made, and so, moves no cursor: the next read brings it back. Otherwise the same as writeProfile.
+    async storeProfile(containerName, response) {
         return this.write(containerName, ProtoMap.profileResponseToCacheWrite(response));
     }
     // The credentials that sign calls about this container - the user token in a profile container, the link token in a business one - and null before the server has issued either.
@@ -52,15 +78,15 @@ export default class SyncCache {
     async readOrders(containerName) {
         return ProtoMap.orderMessagesFromBlobs(await this.readAll(containerName));
     }
-    // The cursor a push sends: the highest update number among this customer's messages already
-    // cached here, party preferences and orders alike. Not persisted, like every cursor in this
-    // library - read off the store fresh each time rather than kept anywhere.
+    // The cursor a push sends: how far the reads of this container have got with this customer's
+    // messages, party preferences and orders alike - the cursor the next read sends for them. What a push
+    // stores here does not move it, so that a change made while it was being made is not skipped.
     async readMessageUpdateNumber(containerName) {
-        return ProtoMap.highestCachedMessageUpdateNumber(await this.readAll(containerName));
+        return (await this.readBusinessCursors(containerName)).getUpdateNumber(proto_Constants.MESSAGE_ENTITY_TYPE_ID);
     }
     // Refuses a message that is not an order, since only the payload says which it is: one stored as the other would never be read back.
     async writeOrder(containerName, order) {
-        return this.writeBlobs(containerName, [ProtoMap.orderToBlob(order)]);
+        return this.writeOwnMessage(containerName, order, ProtoMap.orderToBlob);
     }
     // The party preferences message in this container, or null when there is none. Two mean two
     // callers, which is the same open question as the orders above.
@@ -68,7 +94,18 @@ export default class SyncCache {
         return ProtoMap.partyPreferencesMessageFromBlobs(await this.readAll(containerName));
     }
     async writePartyPreferences(containerName, partyPreferences) {
-        return this.writeBlobs(containerName, [ProtoMap.partyPreferencesToBlob(partyPreferences)]);
+        return this.writeOwnMessage(containerName, partyPreferences, ProtoMap.partyPreferencesToBlob);
+    }
+    // Gives up everything cached for a business: the entities, the cursors that say how far they were read, and the tokens
+    // that were filed with them. For when what a container holds turns out to be of another business than the one it is
+    // named for - which a businessId, being only how a business is found, can come to be. It cannot be told apart from the
+    // business that the same name now finds by anything but the id of its Business, and a cursor of the one is no cursor
+    // of the other: this cache keeps a blob only when its eTag is the greater, so, the cursors of the old would never be
+    // lowered to the numbers of the new, and what the new has below them would never be asked for.
+    // The container is let go of here as well as in the store, as this cache holds each one it has fetched against its name.
+    async deleteBusiness(containerName) {
+        this._containers.delete(containerName);
+        await this._database.deleteContainer(containerName);
     }
     // Drops the party preferences message this container holds, and answers zero when it holds none.
     // The one delete here that no tombstone asked for, and the only reason it exists: one written
@@ -82,35 +119,41 @@ export default class SyncCache {
             return 0;
         return this.write(containerName, {
             blobs: NO_BLOBS,
-            deletedIds: [ProtoMap.partyPreferencesToBlob(partyPreferences).id],
+            deletedIds: [ProtoMap.getMessageId(partyPreferences)],
         });
     }
     // The messages a sync in response carried, in a single batch - a pushed order and the party
     // preferences message it emptied belong in one write, so that this cache cannot come to hold the
     // order without the emptying. Tombstones included, the same as any other entity array read off
     // the wire: this is what a push's own messages are stored as once the server has echoed them back
-    // with real update numbers, and it is also how anything else of this customer's that the response
-    // carried lands here. Neither is checked against a payload type, unlike the two writers above -
+    // with real update numbers. Neither is checked against a payload type, unlike the two writers above -
     // those are for a caller handing in a message it was given, where storing an order as party
     // preferences would be a mistake worth catching, and this is for messages the response itself is
-    // the authority on.
+    // the authority on. It moves no cursor, as it is a change that this client made: the next read
+    // brings the messages back, and what is stored here is the same, so, that changes nothing.
     async writeMessages(containerName, messages) {
         return this.write(containerName, ProtoMap.messagesToCacheWrite(messages));
     }
     async readAll(containerName) {
         return (await this.getContainer(containerName)).readAll();
     }
+    // A message the caller holds rather than one a response carried, versioned from what this container
+    // holds of it: one this client amended has no update number of its own, and is stored at the update
+    // number of the copy it amends - see ProtoMap.messageToBlob
+    async writeOwnMessage(containerName, message, toBlob) {
+        const held = await (await this.getContainer(containerName)).read(ProtoMap.getMessageId(message));
+        return this.writeBlobs(containerName, [toBlob(message, held?.eTag ?? null)]);
+    }
     // For the writers that store one thing and delete nothing - a credential or a single message,
     // none of which a tombstone ever arrives for on its own
     async writeBlobs(containerName, blobs) {
         return this.write(containerName, { blobs: blobs, deletedIds: NO_DELETES });
     }
     // One transaction per call, which is what makes an interrupted write repeat itself rather than leave the cache part written.
-    // The count the store answers with covers only what it stored: a delete is unconditional, so
-    // there is nothing for it to compare and nothing for it to report. Counting the ids instead can
-    // therefore call a page that deleted nothing a page that changed something, when a tombstone
-    // names an entity this container never held - which is the harmless direction, since a caller
-    // republishes once for nothing rather than going on showing an entity the server has said is gone.
+    // The count the store answers with covers only what it stored: a blob it already holds a copy of that
+    // is as new, a tombstone it already holds included, is not stored, and is not counted. A delete is
+    // unconditional, so there is nothing for it to compare, and the ids are counted instead: the only
+    // delete there is is a caller's own - see deletePartyPreferences.
     async write(containerName, cacheWrite) {
         const blobs = cacheWrite.blobs;
         const deletedIds = cacheWrite.deletedIds;
@@ -119,6 +162,26 @@ export default class SyncCache {
         const storedCount = await (await this.getContainer(containerName)).write(blobs, deletedIds);
         return storedCount + deletedIds.length;
     }
+    // A page of a read: what it brought, and the cursors it moved, in one batch. The cursors are not what the
+    // page brought, so they are not counted: the count is what the entities of it changed. The store
+    // keeps a cursor only where it is the greater, which it is of the one that was read, so what it
+    // stored of them is the cursors that moved - or fewer, where another writer moved one first, which
+    // is why the count cannot go below zero.
+    async writeRead(containerName, cacheWrite, cursorKeys, raiseCursors) {
+        const cursors = await this.readCursors(containerName, cursorKeys);
+        const movedKeys = raiseCursors(cursors);
+        const blobs = [...cacheWrite.blobs, ...ProtoMap.cursorsToBlobs(cursors, movedKeys)];
+        const deletedIds = cacheWrite.deletedIds;
+        if (blobs.length === 0 && deletedIds.length === 0)
+            return 0;
+        const storedCount = await (await this.getContainer(containerName)).write(blobs, deletedIds);
+        return Math.max(0, storedCount - movedKeys.size) + deletedIds.length;
+    }
+    async readCursors(containerName, keys) {
+        const container = await this.getContainer(containerName);
+        const blobs = await Promise.all(keys.map((key) => container.read(Ids.getSyncCursorBlobId(key))));
+        return ProtoMap.cursorsFromBlobs(keys, blobs);
+    }
     // Held against their names, so each container is fetched once however often it is used. The promise is held rather than the container, so two calls arriving together share one fetch.
     // A caller that deletes a container from the store gives up this cache with it: nothing here can tell that what it holds is no longer what the store would hand out.
     getContainer(containerName) {

package/dist/SyncState.js

@@ -1,7 +1,7 @@
 import { InvalidArgumentException } from "./Exceptions";
 import * as SyncKeys from "./SyncKeys";
 // How far one read has got, as an update number per entity type computed from what arrives and sent back on the next call, which is what makes a read incremental. One class for both directions - only the keys differ.
-// Held in memory by whoever is reading and stored nowhere, so a new session asks from zero and is sent what it already holds: that costs bandwidth alone, since the store keeps a blob only when its eTag is the greater. "In" and "out" name the direction relative to this store, the opposite way round to the calls of the wire.
+// A value held in memory: SyncCache keeps it between sessions, one blob per entity type, so that a new session asks only for what changed. A container that holds none asks from zero and is sent what it already holds, which costs bandwidth alone, since the store keeps a blob only when its eTag is the greater. "In" and "out" name the direction relative to this store, the opposite way round to the calls of the wire.
 export default class SyncState {
     // The keys this state accepts, which is the whole difference between a business state and a profile one. Anything else is refused, because a Business arrives from both calls with an unrelated update number in each.
     constructor(_keys) {

package/dist/Tax.d.ts

@@ -1,10 +1,18 @@
-import { TaxType as proto_TaxType } from "./generated/TaxType";
+import { TaxType } from "./TaxType";
 export default class Tax {
     private readonly _type;
     private readonly _rate;
-    static fromScaledValues(type: proto_TaxType, scaledRate: number): Tax;
-    constructor(_type: proto_TaxType, _rate: number);
-    get type(): proto_TaxType;
+    static fromScaledValues(countryCode: number, taxCode: number, scaledRate: number): Tax;
+    constructor(_type: TaxType, _rate: number);
+    get type(): TaxType;
     get countryCode(): number;
+    get taxCode(): number;
     get rate(): number;
 }
+export declare class TaxAmount {
+    private readonly _type;
+    private readonly _amount;
+    constructor(_type: TaxType, _amount: number);
+    get type(): TaxType;
+    get amount(): number;
+}

package/dist/Tax.js

@@ -1,13 +1,22 @@
+import { countryCodeOf, createTaxType, taxCodeOf } from "./TaxType";
 import { taxRateFromScaledValue } from "./Constants";
 // A tax and its rate, applying to a product or a shopping-list line. Rate is exposed as a
 // percentage (18 for 18%), though the wire carries it scaled by Constants.TAX_RATE_FACTOR.
+//
+// The taxes of a product are INCLUDED in the prices of its packages, and the taxes of the delivery
+// charge in the charge: nothing is added to a price a customer is shown. A shopping list item is
+// the other way round - it stores its price WITHOUT taxes and works its taxes out on top - which is
+// why a price has its taxes taken out on the way into an item (see CartEditor) and put back for
+// display (see ShoppingListItem.unitPriceWithTaxes).
 // Deliberately doesn't compute tax on an amount - only a line item knows the amount, and does
 // that itself.
 export default class Tax {
     // Only ProtoMap calls this: it is the one place that sees a rate still multiplied by
-    // Constants.TAX_RATE_FACTOR.
-    static fromScaledValues(type, scaledRate) {
-        return new Tax(type, taxRateFromScaledValue(scaledRate));
+    // Constants.TAX_RATE_FACTOR. The wire carries a tax as its raw code, which means something only
+    // within a country - that of the business the tax is on - so the type is made here from the two,
+    // the same way Java TaxType.createId does.
+    static fromScaledValues(countryCode, taxCode, scaledRate) {
+        return new Tax(createTaxType(countryCode, taxCode), taxRateFromScaledValue(scaledRate));
     }
     constructor(_type, _rate) {
         this._type = _type;
@@ -21,10 +30,30 @@ export default class Tax {
     // country comes back out of the value itself rather than having to be carried alongside it.
     // Zero for TaxType.UNSPECIFIED_TAX_TYPE, no country's code being zero.
     get countryCode() {
-        return this._type >> 8;
+        return countryCodeOf(this._type);
+    }
+    // The raw tax code, which is all the wire carries of a tax: the low eight bits of the type
+    get taxCode() {
+        return taxCodeOf(this._type);
     }
     // A percentage: 18 means 18%
     get rate() {
         return this._rate;
     }
 }
+// How much one TYPE of tax comes to across a shopping list - the line a bill shows for it, "GST
+// 5.25". Several taxes of one type, on one item or on many, are added into one. Always a tax that
+// is included in the total the list comes to, never an extra on top of it.
+export class TaxAmount {
+    constructor(_type, _amount) {
+        this._type = _type;
+        this._amount = _amount;
+    }
+    get type() {
+        return this._type;
+    }
+    // Zero is possible - a list of free items has taxes and owes none - and a bill shows no line for it
+    get amount() {
+        return this._amount;
+    }
+}

package/dist/TaxHelper.d.ts

@@ -0,0 +1,12 @@
+import Tax from "./Tax";
+export default class TaxHelper {
+    static scaledRatesOf(taxes: ReadonlyArray<Tax>): ReadonlyArray<number>;
+    static calculateTaxAmount(taxBase: bigint, taxRate: number): bigint;
+    static calculateTaxes(taxBase: bigint, taxRates: ReadonlyArray<number>): Array<bigint>;
+    static calculateTotalTaxRate(taxRates: ReadonlyArray<number>): number;
+    static addTaxes(taxBase: bigint, taxRates: ReadonlyArray<number>): bigint;
+    static removeTaxes(amountWithTaxes: bigint, taxRates: ReadonlyArray<number>): bigint;
+    private static divideAndRound;
+    private static abs;
+    private static readonly TAX_RATE_FACTOR;
+}

package/dist/TaxHelper.js

@@ -0,0 +1,93 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+import { taxRateToScaledValue } from "./Constants";
+// The arithmetic of taxes, which is Java com.merabills.repository.entities.helpers.TaxHelper and
+// is meant to give the same answer to the unit. It is the only place in this library where a tax is
+// worked out, added to an amount or taken out of one.
+//
+// It works on SCALED values, not the unscaled numbers the rest of this library speaks: an amount is
+// a bigint multiplied by Constants.AMOUNT_FACTOR, and a rate is a number multiplied by
+// Constants.TAX_RATE_FACTOR, so 5% is 500. Java does the same in longs and ints, and rounding a
+// tax in floating point instead would round some of them the other way, which is the difference
+// between a bill that agrees with the merchant's and one that is a paisa out. A bigint rather than
+// a number because an amount can be as large as 2^44 and a product with a rate overflows 2^53.
+//
+// Only integer arithmetic is used: a tax is the tax base multiplied by the rate, and the division
+// by TAX_RATE_FACTOR and the rounding (half up, as Math.round) are the last steps. Each tax is
+// rounded on its own, as each is shown (and paid) on its own.
+//
+// Not on the public surface (see index.ts): a UI reads a tax off a ShoppingListItem, a ShoppingList
+// or a CartLine, which have done this arithmetic already, in unscaled numbers.
+class TaxHelper {
+    // The rates of these taxes the way the arithmetic below takes them: scaled, and in the same
+    // order. A rate that is not greater than zero is no tax at all - Java refuses one (validateTaxes)
+    // and drops one that arrives (getTaxCodesAndRates) - so it is a zero here, adding and removing
+    // nothing, and the taxes stay in step with the amounts worked out for them.
+    static scaledRatesOf(taxes) {
+        return taxes.map((tax) => Number.isFinite(tax.rate) && tax.rate > 0 ? taxRateToScaledValue(tax.rate) : 0);
+    }
+    // One tax on a tax base (the amount before taxes)
+    static calculateTaxAmount(taxBase, taxRate) {
+        return TaxHelper.divideAndRound(taxBase * BigInt(taxRate), TaxHelper.TAX_RATE_FACTOR);
+    }
+    // Each of the taxes with these rates on a tax base, in the order of the rates
+    static calculateTaxes(taxBase, taxRates) {
+        return taxRates.map((taxRate) => TaxHelper.calculateTaxAmount(taxBase, taxRate));
+    }
+    // The sum of these rates (zero when there are none), scaled
+    static calculateTotalTaxRate(taxRates) {
+        let result = 0;
+        for (const taxRate of taxRates)
+            result += taxRate;
+        return result;
+    }
+    // The tax base plus the taxes with these rates on it. Taxes only apply to a tax base greater
+    // than zero.
+    static addTaxes(taxBase, taxRates) {
+        if (taxBase <= 0n)
+            return taxBase;
+        let result = taxBase;
+        for (const taxRate of taxRates)
+            result += TaxHelper.calculateTaxAmount(taxBase, taxRate);
+        return result;
+    }
+    // The inverse of addTaxes: the amount the taxes with these rates have to be added to for the
+    // result to be this amount with taxes. Each tax is rounded on its own, so some amounts with taxes
+    // cannot be reached; this then answers the amount for which addTaxes comes closest (the lower
+    // one, when two are equally close). So removeTaxes(addTaxes(amount, rates), rates) is always
+    // amount.
+    static removeTaxes(amountWithTaxes, taxRates) {
+        if (amountWithTaxes <= 0n || taxRates.length === 0)
+            return amountWithTaxes;
+        // Ignoring rounding, the amount with taxes is the amount multiplied by (1 + the total rate), so
+        // estimate the amount by dividing by that. Rounding moves each tax by at most half a unit, and
+        // the estimate is itself rounded, so the amount looked for is within the number of taxes of the
+        // estimate (Java looks as far): look at every amount that close.
+        const estimate = TaxHelper.divideAndRound(amountWithTaxes * TaxHelper.TAX_RATE_FACTOR, TaxHelper.TAX_RATE_FACTOR + BigInt(TaxHelper.calculateTotalTaxRate(taxRates)));
+        const reach = BigInt(taxRates.length);
+        const first = estimate > reach ? estimate - reach : 0n;
+        let result = estimate;
+        let smallestDifference = null;
+        for (let candidate = first; candidate <= estimate + reach; ++candidate) {
+            const difference = TaxHelper.abs(TaxHelper.addTaxes(candidate, taxRates) - amountWithTaxes);
+            // Strictly smaller, so of two equally close the lower amount (reached first) is kept
+            if (smallestDifference === null || difference < smallestDifference) {
+                smallestDifference = difference;
+                result = candidate;
+            }
+        }
+        return result;
+    }
+    // Divides by a positive denominator and rounds half up, exactly as Math.round does. A bigint
+    // division truncates towards zero, so the floor is taken by hand.
+    static divideAndRound(numerator, denominator) {
+        const doubled = numerator * 2n + denominator;
+        const divisor = denominator * 2n;
+        const quotient = doubled / divisor;
+        return doubled % divisor !== 0n && doubled < 0n ? quotient - 1n : quotient;
+    }
+    static abs(value) {
+        return value < 0n ? -value : value;
+    }
+}
+TaxHelper.TAX_RATE_FACTOR = BigInt(proto_Constants.TAX_RATE_FACTOR);
+export default TaxHelper;

package/dist/TaxType.d.ts

@@ -0,0 +1,7 @@
+export declare enum TaxType {
+    UNSPECIFIED_TAX_TYPE = 0,
+    GST = 91136
+}
+export declare function createTaxType(countryCode: number, taxCode: number): TaxType;
+export declare function countryCodeOf(type: TaxType): number;
+export declare function taxCodeOf(type: TaxType): number;

package/dist/TaxType.js

@@ -0,0 +1,32 @@
+// The name of a tax, for a UI to show. Not part of the wire protocol: a Tax is sent as its raw tax
+// code, which is unique only within a country, and ProtoMap combines it with the country of the
+// business the tax is on. The values are Java TaxType.createId(country, taxCode) =
+// (country.getNumeric() << 8) | taxCode, so each is globally unique; the country is recovered with
+// countryCodeOf and the raw tax code with taxCodeOf. They are copied from Java's TaxType by hand, and
+// pinned there by TaxTypeIdsTest (repository/test/com/merabills/repository/entities/helpers), which
+// fails when GST or the shift of the country changes, or a type is added, until this file has
+// followed - so a tax added there must be added here with the same value. The tests of this
+// library pin the same values (Values.test.ts).
+export var TaxType;
+(function (TaxType) {
+    // No country's numeric code is ever 0, so this can never collide with a real type
+    TaxType[TaxType["UNSPECIFIED_TAX_TYPE"] = 0] = "UNSPECIFIED_TAX_TYPE";
+    // India (country code 356): Goods and Services Tax (tax code 0)
+    TaxType[TaxType["GST"] = 91136] = "GST";
+})(TaxType || (TaxType = {}));
+// Bits of a TaxType value the raw tax code takes, below the country - Java TaxType.COUNTRY_CODE_SHIFT
+const TAX_CODE_BITS = 8;
+const TAX_CODE_MASK = (1 << TAX_CODE_BITS) - 1;
+// Java TaxType.createId: the country in the high bits, the raw tax code in the low eight. Not
+// restricted to the TaxType members, since a country's tax this library has no name for is still a tax.
+export function createTaxType(countryCode, taxCode) {
+    return ((countryCode << TAX_CODE_BITS) | taxCode);
+}
+// The country a type belongs to, ISO 3166-1 numeric; zero for UNSPECIFIED_TAX_TYPE
+export function countryCodeOf(type) {
+    return type >> TAX_CODE_BITS;
+}
+// The raw tax code of a type: the low eight bits
+export function taxCodeOf(type) {
+    return type & TAX_CODE_MASK;
+}

package/dist/generated/AttachmentType.d.ts

@@ -154,5 +154,23 @@ export declare enum AttachmentType {
     /**
      * @generated from protobuf enum value: TRANSACTION_3 = 83;
      */
-    TRANSACTION_3 = 83
+    TRANSACTION_3 = 83,
+    /**
+     * Other kinds of image that an attachment can be
+     *
+     * @generated from protobuf enum value: AI_GENERATED_PHOTO = 90;
+     */
+    AI_GENERATED_PHOTO = 90,
+    /**
+     * @generated from protobuf enum value: CAMERA_CAPTURE_PHOTO = 91;
+     */
+    CAMERA_CAPTURE_PHOTO = 91,
+    /**
+     * @generated from protobuf enum value: BUSINESS_CARD_IMAGE = 92;
+     */
+    BUSINESS_CARD_IMAGE = 92,
+    /**
+     * @generated from protobuf enum value: GREETING_IMAGE = 93;
+     */
+    GREETING_IMAGE = 93
 }

package/dist/generated/AttachmentType.js

@@ -160,4 +160,22 @@ export var AttachmentType;
      * @generated from protobuf enum value: TRANSACTION_3 = 83;
      */
     AttachmentType[AttachmentType["TRANSACTION_3"] = 83] = "TRANSACTION_3";
+    /**
+     * Other kinds of image that an attachment can be
+     *
+     * @generated from protobuf enum value: AI_GENERATED_PHOTO = 90;
+     */
+    AttachmentType[AttachmentType["AI_GENERATED_PHOTO"] = 90] = "AI_GENERATED_PHOTO";
+    /**
+     * @generated from protobuf enum value: CAMERA_CAPTURE_PHOTO = 91;
+     */
+    AttachmentType[AttachmentType["CAMERA_CAPTURE_PHOTO"] = 91] = "CAMERA_CAPTURE_PHOTO";
+    /**
+     * @generated from protobuf enum value: BUSINESS_CARD_IMAGE = 92;
+     */
+    AttachmentType[AttachmentType["BUSINESS_CARD_IMAGE"] = 92] = "BUSINESS_CARD_IMAGE";
+    /**
+     * @generated from protobuf enum value: GREETING_IMAGE = 93;
+     */
+    AttachmentType[AttachmentType["GREETING_IMAGE"] = 93] = "GREETING_IMAGE";
 })(AttachmentType || (AttachmentType = {}));

package/dist/generated/AuthTokens.d.ts

@@ -23,7 +23,9 @@ export interface AuthTokens {
     authenticationMethod: AuthenticationMethod;
     /**
      * The credential from that identity provider - a Firebase id token when the method is FIREBASE.
-     * Always set. Not issued or renewed by this server; refreshed with the identity provider.
+     * Always set in a request. Blank in a response, which carries the tokens that the server renewed:
+     * it never echoes this back, as it belongs to the identity provider, so, a client keeps the one that it
+     * holds. Not issued or renewed by this server; refreshed with the identity provider.
      *
      * @generated from protobuf field: string authenticationToken = 2
      */

package/dist/generated/BusinessLink.d.ts

@@ -43,7 +43,10 @@ export interface BusinessLink {
     role: Role;
     /**
      * Id of the party record of the linked entity within that business, or Constants.ENTITY_ID_NULL
-     * when there is none. Not resolvable by a storefront - Party is not generated by this protocol.
+     * when there is none. A link that has been blocked has the invalid party id that Java names
+     * Party.INVALID_PARTY_ID instead, which is not zero (it is the id of a party whose low part is
+     * zero, 0x0800000000000000), so, a partyId that is not zero is not always a party.
+     * Not resolvable by a storefront - Party is not generated by this protocol.
      *
      * @generated from protobuf field: int64 partyId = 5
      */

package/dist/generated/BusinessSyncInRequest.d.ts

@@ -7,16 +7,24 @@ import { MessageType } from "@protobuf-ts/runtime";
 import { Message } from "./Message";
 /**
  * Pushes the business entities a customer has changed - their shopping cart and the orders placed
- * from it - to one business database, named the same way a BusinessSyncOutRequest names it.
+ * from it - to one business database. The request names no business: the link token in the
+ * AuthTokens of the authorization header does, as a link names exactly one.
+ * Not implemented yet: the route (shopBusinessSyncIn) answers 501, and what is said here and in the
+ * BusinessSyncInResponse is the contract that it is to meet, and not behaviour that the server has.
+ * ProtoMap.fromProto accepts the paymentReceived of an order, and the senderId and status of a message,
+ * as they are sent, so, sync in has to enforce who may set each of them when it is written.
  * An entity being synced in carries the id it already has, or Constants.ENTITY_ID_NULL if the
  * caller is creating it and the server is to assign one; incoming update numbers are the caller's
- * own and are replaced by the server, which returns the new ones in the BusinessSyncInResponse.
+ * own and are replaced by the server, which returns the messages bearing the new ones in the
+ * BusinessSyncInResponse.
  *
  * @generated from protobuf message com.merabills.storefront.BusinessSyncInRequest
  */
 export interface BusinessSyncInRequest {
     /**
-     * Client-side cursor for the customer's orders and shopping cart (Constants.MESSAGE_ENTITY_TYPE_ID).
+     * Client-side cursor for the customer's orders and shopping cart (Constants.MESSAGE_ENTITY_TYPE_ID):
+     * how far the client's sync outs of them have got, which is not moved by a push. The answer to a push
+     * is only the messages that were pushed, so, it does not depend on this.
      *
      * @generated from protobuf field: int64 messageUpdateNumber = 1
      */

package/dist/generated/BusinessSyncInResponse.d.ts

@@ -7,10 +7,11 @@ import { MessageType } from "@protobuf-ts/runtime";
 import { Message } from "./Message";
 import { AuthTokens } from "./AuthTokens";
 /**
- * The answer to a BusinessSyncInRequest: the update number the server assigned to the pushed
- * entities, one per entity type. Raise the matching cursor to this value so the next sync out does
- * not fetch back what was just sent; 0 means nothing of that type was accepted. Carries no entities
- * - sync out again to see the server's view of what was pushed.
+ * Not implemented yet (the route answers 501): this is the contract that it is to meet.
+ * The answer to a BusinessSyncInRequest: the messages the server now holds for what was pushed,
+ * which bear the update numbers it assigned, and any tokens it renewed. A push is not a read, so, do
+ * not move the message cursor with these update numbers: a change somebody else made, with an update
+ * number below them, would then never be sent. The next sync out returns what was pushed as well.
  *
  * @generated from protobuf message com.merabills.storefront.BusinessSyncInResponse
  */