@peabody-soft/mbs-protos 1.0.0

package/Address.proto

@@ -0,0 +1,36 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "AddressType.proto";
+
+// A postal address - a delivery address of a customer, or an address of a business
+message Address {
+
+  // Unique id of this address within the list that holds it
+  int64 id = 1;
+
+  AddressType addressType = 2;
+
+  // Flat / house / building number (at most Constants.ADDRESS_UNIT_NUMBER_MAX_LENGTH)
+  optional string unitNumber = 3;
+
+  // Street, locality or neighbourhood (at most Constants.ADDRESS_COMMUNITY_MAX_LENGTH)
+  optional string community = 4;
+
+  // At most Constants.ADDRESS_LINE2_MAX_LENGTH
+  optional string line2 = 5;
+
+  // At most Constants.ADDRESS_CITY_MAX_LENGTH
+  optional string city = 6;
+
+  // At most Constants.ADDRESS_STATE_MAX_LENGTH
+  optional string state = 7;
+
+  // Postal code / PIN code (at most Constants.ADDRESS_PIN_CODE_MAX_LENGTH)
+  optional string pinCode = 8;
+
+  // ISO 3166-1 numeric country code
+  int32 countryCode = 9;
+}

package/AddressList.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "Address.proto";
+
+// A list of addresses, one of which is the default.
+// Not included because it is derived: size, and the default Address itself (look up
+// defaultAddressId in addresses; when it is not found, the first address is the default).
+message AddressList {
+
+  // Id of the default address in the list below
+  int64 defaultAddressId = 1;
+
+  // At most Constants.MAX_ADDRESSES addresses
+  repeated Address addresses = 2;
+}

package/AddressType.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// Type of an address. Values match the ADDRESS_TYPE_* constants of Address.
+enum AddressType {
+
+  HOME = 0;
+  BUSINESS = 1;
+}

package/Attachment.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "AttachmentType.proto";
+import "Entity.proto";
+
+// A file (a photo of a business, product or package, for example) attached to an entity.
+// Excluded: isPublic, isReadyForSync and isProcessingComplete.
+// Not included because it is derived: storageFileName, the name the file is stored under. A client
+// needs it to fetch the file, so here is exactly how Attachment.getStorageFileName builds it, from
+// the createdAt of this entity, its id, its fileHash and its fileExtension:
+//
+//   "%04d-%02d-%02d-%016X-%s.%s"  (Java Attachment.ATTACHMENT_FILE_NAME_FORMAT)
+//
+//   year, month and day  the createdAt of this entity, read in UTC. The month is the one
+//                        java.util.Calendar gives and is therefore zero based: January is 00 and
+//                        December is 11, so a file created in September 2026 is stored under
+//                        "2026-08-...". Both ends of the protocol do this, so a client must too.
+//   id                   Entity.id, 16 upper case hex digits, zero padded, with no 0x prefix
+//   fileHash             the 16 bytes of fileHash as 32 upper case hex digits
+//   fileExtension        appended after a dot, as it is
+//
+// The case matters: a blob name is case sensitive. The whole name is one flat name, not a path -
+// see UrlAndToken for how a url is built from it.
+message Attachment {
+
+  Entity entity = 1;
+
+  // Exposed instead of the raw type id held in the category of this attachment
+  AttachmentType attachmentType = 2;
+
+  // Id of the entity this file is attached to - a business, a product or a package in this
+  // protocol. Nothing nests here, so this is how a client finds the photos of an entity. The
+  // entity type of the owner is the most significant byte of this id (see Constants).
+  int64 owningEntityId = 3;
+
+  // MD5 hash of the attached file, exactly Constants.ATTACHMENT_FILE_HASH_SIZE_BYTES bytes long.
+  // Null / empty when the attachment is deleted.
+  optional bytes fileHash = 4;
+
+  // File name extension, without the dot (at most Constants.ATTACHMENT_FILE_EXTENSION_MAX_LENGTH)
+  optional string fileExtension = 5;
+
+  // File name, without the extension (at most Constants.ATTACHMENT_FILE_NAME_MAX_LENGTH)
+  optional string fileName = 6;
+}

package/AttachmentType.proto

@@ -0,0 +1,56 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// The type of an attachment, and - for catalog and store images - the slot the image occupies.
+// Values match the ids of the corresponding Java enum entries and must never be changed.
+enum AttachmentType {
+
+  // General purpose attachments of any entity
+  GENERAL_0 = 0;
+  GENERAL_1 = 1;
+  GENERAL_2 = 2;
+  GENERAL_3 = 3;
+
+  // The main catalog image of a product or a package
+  CATALOG_MAIN_0 = 8;
+
+  // Catalog images showing the product in use
+  CATALOG_LIFESTYLE_0 = 16;
+  CATALOG_LIFESTYLE_1 = 17;
+  CATALOG_LIFESTYLE_2 = 18;
+  CATALOG_LIFESTYLE_3 = 19;
+  CATALOG_LIFESTYLE_4 = 20;
+  CATALOG_LIFESTYLE_5 = 21;
+  CATALOG_LIFESTYLE_6 = 22;
+  CATALOG_LIFESTYLE_7 = 23;
+
+  // Catalog images of the product from different angles
+  CATALOG_ANGLE_0 = 40;
+  CATALOG_ANGLE_1 = 41;
+  CATALOG_ANGLE_2 = 42;
+  CATALOG_ANGLE_3 = 43;
+  CATALOG_ANGLE_4 = 44;
+  CATALOG_ANGLE_5 = 45;
+  CATALOG_ANGLE_6 = 46;
+  CATALOG_ANGLE_7 = 47;
+
+  // Other catalog images
+  CATALOG_OTHER_0 = 56;
+  CATALOG_OTHER_1 = 57;
+  CATALOG_OTHER_2 = 58;
+  CATALOG_OTHER_3 = 59;
+
+  // Photos of the store / business
+  STORE_0 = 64;
+  STORE_1 = 65;
+  STORE_2 = 66;
+  STORE_3 = 67;
+
+  // Attachments of a transaction
+  TRANSACTION_0 = 80;
+  TRANSACTION_1 = 81;
+  TRANSACTION_2 = 82;
+  TRANSACTION_3 = 83;
+}

package/AuthTokens.proto

@@ -0,0 +1,51 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "AuthenticationMethod.proto";
+
+// The tokens that prove who is making a request. This is serialized into the authorization header
+// of every request, the way ServiceProxy.setAuthorizationHeader serializes the Java AuthTokens, so
+// it is a credential envelope rather than part of the entity model and never appears in a body.
+//
+// The three tokens answer different questions: authenticationToken says which person is calling,
+// userToken says which MeraBills user that person is, and linkToken says which business they may
+// act against. They are parsed in that order and the first is a prerequisite for the second, so a
+// userToken is never trusted on its own (Authority.parseUserToken parses the authentication token
+// first). A storefront acquires them in that order too - it signs in with an identity provider,
+// exchanges that for a user token by calling the profile sync out, and gets a link token per
+// business from the BusinessLinks that call returns.
+//
+// Not included because the server derives it: the subject id, and the phone number, which
+// Authority.parseAuthenticationToken reads out of authenticationToken rather than trusting a field.
+// A client that knows its own subject id has no reason to send it, and no way to be believed if it
+// did.
+//
+// Every value here is a bearer credential: never log one, never put one in a url, and hold them
+// only for as long as the session lasts.
+message AuthTokens {
+
+  // Which identity provider issued authenticationToken, and so how the server parses it. Always
+  // set - it selects the parser, and a request whose method has none is refused. There is no
+  // unspecified value, because zero is FIREBASE.
+  AuthenticationMethod authenticationMethod = 1;
+
+  // The credential from that identity provider - a Firebase id token when the method is FIREBASE.
+  // Always set: every request is parsed for a subject, so there is no anonymous form of this
+  // message. This is not issued by this server, and this server does not renew it; a client
+  // refreshes it with its identity provider.
+  string authenticationToken = 2;
+
+  // Token proving which MeraBills user the subject is, issued and signed by this server, carrying
+  // the user id and the rights of the caller. Absent until a client has called the profile sync out
+  // once, and again once it expires, at which point a client calls that again to be given another
+  // rather than deriving one.
+  optional string userToken = 3;
+
+  // Token authorizing the caller to act against one business - the BusinessLink.linkToken of that
+  // business, which a ProfileSyncOutResponse carries. Absent for a request that names no business,
+  // required for one that does. It is per business, so a client that shows two businesses holds one
+  // of these for each and sends the one that matches the request.
+  optional string linkToken = 4;
+}

package/AuthenticationMethod.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// Which identity provider issued the AuthTokens.authenticationToken of a request, and so how the
+// server parses it.
+// Values match the ids of the corresponding Java enum entries and must never be changed.
+// Note that there is no unspecified value: zero is FIREBASE. AuthTokens.authenticationMethod is
+// always set, so a client never needs one.
+enum AuthenticationMethod {
+
+  // The authentication token is a Firebase id token, and the subject id the server reads out of it
+  // is a Firebase uid, which is not the same thing as the MeraBills User.entity.id. The userToken
+  // of an AuthTokens is not a Firebase token - it is issued by this server, whatever method
+  // authenticated the subject.
+  FIREBASE = 0;
+
+  // Reserved for internal administrative callers. A storefront never uses this method.
+  ADMIN = 127;
+}

package/Business.proto

@@ -0,0 +1,32 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "Entity.proto";
+
+// A business that a customer can buy from.
+// A business contains no other entity: its settings arrive as a Configuration, its photos as
+// Attachments whose owningEntityId is this business, and its catalog as the item entities of a
+// BusinessSyncOutResponse.
+// This is a profile database entity, so it is carried by a ProfileSyncOutResponse - one per business
+// the caller is linked to. A BusinessSyncOutResponse carries it as well, for the one business it is
+// about, because a client that has not signed in has no profile sync out to read it from.
+// Excluded: category (and the BusinessType derived from it), displayNameOld,
+// allowJoinWithoutInvitation, forTraining and all Translations fields.
+message Business {
+
+  Entity entity = 1;
+
+  // Unique, lower case, url friendly id of this business
+  // (Constants.BUSINESS_ID_MIN_LENGTH to Constants.BUSINESS_ID_MAX_LENGTH)
+  string businessId = 2;
+
+  // Name of this business, as displayed to customers ("Warm Loaf")
+  // (Constants.BUSINESS_DISPLAY_NAME_MIN_LENGTH to Constants.BUSINESS_DISPLAY_NAME_MAX_LENGTH)
+  string displayName = 3;
+
+  // ISO 3166-1 numeric country code. Every amount in this protocol is in the currency of this
+  // country - no amount carries a currency of its own.
+  int32 countryCode = 4;
+}

package/BusinessIdentifier.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "BusinessIdentifierType.proto";
+
+// An identifier of a business, and the kind of identifier it is. A protobuf map cannot be keyed by
+// an enum, so the identifiers of a business are a repeated pair rather than a map.
+message BusinessIdentifier {
+
+  BusinessIdentifierType type = 1;
+
+  // The identifier itself (at most Constants.IDENTIFIER_MAX_LENGTH)
+  string value = 2;
+}

package/BusinessIdentifierType.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// A kind of identifier that a business can carry. Every value below is restricted to India.
+// The Java enum identifies these by string id rather than by number, so the values below are
+// numbered here: map each one to the Java id given in its comment.
+enum BusinessIdentifierType {
+
+  UNSPECIFIED_BUSINESS_IDENTIFIER_TYPE = 0;
+
+  // "cin" - Corporate Identity Number
+  CIN = 1;
+
+  // "fssai" - Food Safety and Standards Authority of India licence number
+  FSSAI = 2;
+
+  // "gstin" - Goods and Services Tax Identification Number
+  GSTIN = 3;
+
+  // "pan" - Permanent Account Number
+  PAN = 4;
+
+  // "tan" - Tax Deduction and Collection Account Number
+  TAN = 5;
+
+  // "udyam" - Udyam registration number
+  UDYAM = 6;
+}

package/BusinessLink.proto

@@ -0,0 +1,59 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "Entity.proto";
+import "Role.proto";
+
+// Associates an entity - a user or a business - with a business, in a particular role. This is what
+// tells a signed in customer which businesses they are a customer of, and it carries the token that
+// lets them act against each one.
+//
+// A business link lives in a profile database, alongside the User and the Business entities it names,
+// so it is carried by a ProfileSyncOutResponse and never by a BusinessSyncOutResponse.
+//
+// Excluded: invitationDetails - the name of the inviter, the note they wrote and the rest of it are
+// about accepting an invitation, which is not part of a storefront.
+// Not included because they are derived from expiry: isExpirySet and hasExpired.
+message BusinessLink {
+
+  Entity entity = 1;
+
+  // Id of the entity this link is for: a user or a business, and nothing else. The entity type is
+  // the most significant byte of this id (Constants.USER_ENTITY_TYPE_ID or
+  // Constants.BUSINESS_ENTITY_TYPE_ID), which is how a client tells the two apart. For a storefront
+  // this is the User of the caller.
+  int64 linkedEntityId = 2;
+
+  // Id of the business this link is to.
+  //
+  // This is an entity id, so it matches Business.entity.id - not Business.businessId, which is the
+  // lower case url friendly string a storefront is reached by. The Java accessors are both called
+  // getBusinessId and return different things (a long here, a String on Business), so this is easy to
+  // get wrong.
+  int64 businessId = 3;
+
+  // What the linked entity may do with the business. A storefront customer is normally
+  // Role.CUSTOMER.
+  Role role = 4;
+
+  // Id of the party record of the linked entity within that business, or Constants.ENTITY_ID_NULL
+  // when there is none. A Party is not generated by this protocol, so this id cannot be resolved by
+  // a storefront; it is here because it is a field of the Java class and because the server needs it.
+  // Every role outside the partner group has one.
+  int64 partyId = 5;
+
+  // Token proving that the linked entity may act against this business. This is what goes into
+  // AuthTokens.linkToken of every later request that names the business.
+  //
+  // It is a bearer credential: never log it, never put it in a URL, and never show it to anyone but
+  // the entity it was issued to. It is not one of the stored attributes of the entity - the server
+  // issues it - so a link that arrives without one cannot be used to reach the business.
+  optional string linkToken = 6;
+
+  // Time after which this link is no longer valid, in milliseconds since Jan 1, 1970 00:00:00 UTC.
+  // BusinessLink.NO_EXPIRY (0) means it does not expire. A client must compare this against its own
+  // clock, so allow for Constants.MAX_CLOCK_SKEW before deciding a link has expired.
+  int64 expiry = 7;
+}

package/BusinessSyncInRequest.proto

@@ -0,0 +1,42 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+import "Message.proto";
+
+// A request to sync in the entities a customer has changed: their shopping cart, and the orders
+// they place from it. This is the counterpart of BusinessSyncOutRequest and mirrors the Java sync in
+// (Service.businessSyncIn, which takes the Entity[][] that BusinessDb.syncInToMaster authorizes a
+// table at a time): entities travel flat, one array per entity type, and nothing is nested.
+//
+// This writes one business database, which is what it is named after. A message is a business entity
+// even though the customer sent it, so the cart and the orders belong here; the profile of the
+// customer does not, and is written by a sync in of its own.
+//
+// Who is asking is not part of this message: it is in the AuthTokens of the authorization header. The
+// server authorizes each array against the rights of that caller - messages against
+// Right.MESSAGES_MODIFY - so a client cannot push an entity type it has no right to, and a
+// storefront customer may push only their own messages.
+//
+// An entity being synced in carries the id it already has, or Constants.ENTITY_ID_NULL when the
+// client is creating it and the server is to assign one. The update numbers of the incoming
+// entities are the client's own and are not comparable with the server's: the server assigns new
+// ones and returns them in the BusinessSyncInResponse.
+message BusinessSyncInRequest {
+
+  // The business these entities belong to, named by its unique, lower case, url friendly id - the
+  // same Business.businessId that BusinessSyncOutRequest names
+  // (Constants.BUSINESS_ID_MIN_LENGTH to Constants.BUSINESS_ID_MAX_LENGTH)
+  string businessId = 1;
+
+  // The shopping cart of the customer (a message whose payload is a PartyPreferencesPayload) and
+  // the orders they place (a payload of SalesOrderPayload) - entity type
+  // Constants.MESSAGE_ENTITY_TYPE_ID.
+  //
+  // This is the only entity type a storefront may push. A customer does not edit the business, its
+  // settings, its catalog or its photos, and their own User lives in a profile database that this
+  // call does not touch - so there is deliberately no field for any of those types here, rather
+  // than a field the server would reject.
+  repeated Message messages = 2;
+}

package/BusinessSyncInResponse.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// The answer to a BusinessSyncInRequest: the update number the server assigned to the entities that
+// were pushed, one per entity type, the way Java sync in returns the long[] of max incoming update
+// numbers that BusinessDb.syncIn produces, indexed by table entity type id.
+//
+// A client raises its cursor for that entity type to the number below, so that the next
+// BusinessSyncOutRequest does not fetch back what it has just sent. Zero means nothing of that type
+// was accepted, which is what a request that carried none of them gets back.
+//
+// This response carries no entities. A client that needs the server's view of what it pushed - the
+// id assigned to an entity the server created, or the authoritative totals of a shopping list,
+// which are computed with the rounding rules of PriceCalculation - syncs out again afterwards.
+message BusinessSyncInResponse {
+
+  // The highest update number the server assigned to the messages of the request - entity type
+  // Constants.MESSAGE_ENTITY_TYPE_ID. There is one field per entity type that
+  // BusinessSyncInRequest can carry, and messages are the only one.
+  int64 messageUpdateNumber = 1;
+}

package/BusinessSyncOutRequest.proto

@@ -0,0 +1,100 @@
+syntax = "proto3";
+package com.merabills.storefront;
+option java_multiple_files = true;
+option java_package = "com.merabills.server.core.generated";
+
+// A request to sync out everything a storefront needs of one business: the Business, its settings, its
+// catalog and the messages of the customer. This is an incremental sync, so the request carries a
+// cursor per entity type and the BusinessSyncOutResponse carries only what has changed since, flat,
+// for the client to reassemble.
+//
+// This reads one business database, which is why there is no cursor for the User of the caller and no
+// User in the response: a user lives in a profile database and is read by a ProfileSyncOutRequest, the
+// way Java splits Service.businessSyncOut from Service.profileSyncOut.
+//
+// A Business is a profile database entity too, but it is carried here as well, because a client that
+// has not signed in has no profile sync out to read it from and would otherwise not know the name or
+// the country of the business it is showing. So businessUpdateNumber below and
+// ProfileSyncOutRequest.businessUpdateNumber are cursors over the same entity type kept by two
+// different calls: a client keeps one per call and must not carry a number from one over to the other.
+//
+// Who is asking is not part of this message: it is in the AuthTokens of the authorization header,
+// whose linkToken is the BusinessLink.linkToken of the business named below.
+//
+// The store it is asking on behalf of is, in clientDatabaseId below. A storefront keeps a
+// persistent store, so it is a database in the sync topology and has an id of its own, and the
+// server needs that id to know which changes not to send back. This is the requestingDbId argument
+// of Service.businessSyncOut, which the Java clients pass as the db-id query parameter
+// (HttpQueryParameters.DATABASE_ID) rather than in the body; a storefront carries it here instead,
+// so that one protobuf message says everything a sync out needs.
+//
+// Each cursor below is the highest Entity.updateNumber of that entity type that this client has
+// already synced out. The server sends back the entities of that type whose updateNumber is
+// greater, so a client stores the highest updateNumber it receives per type and sends it back on
+// the next call. Zero, the default, means this client has nothing yet and asks for everything -
+// a first sync therefore leaves every cursor unset.
+//
+// One field below is not a cursor: attachmentBaseUrlExpiry is a time, and it asks for a value rather
+// than for entities. It is here because the files of the attachments of a business are read from a
+// url that expires, and renewing it in this call costs nothing, where a call of its own would cost a
+// round trip on every sync.
+//
+// Sync out is bounded: one call returns at most Constants.SYNC_OUT_LIMIT entities across all types
+// together. On receiving that many, a client must call again with its updated cursors until it
+// receives fewer.
+//
+// There is one cursor per entity type that has a table of its own, which is how updateNumbers are
+// kept, and not one per class: the product categories, products, packages, price lists and prices
+// of a catalog are all item entities and all share itemUpdateNumber. Update numbers are only
+// comparable within one entity type, and only against the same server.
+message BusinessSyncOutRequest {
+
+  // The business to sync out, named by its unique, lower case, url friendly id - the same
+  // Business.businessId that the storefront was reached by
+  // (Constants.BUSINESS_ID_MIN_LENGTH to Constants.BUSINESS_ID_MAX_LENGTH)
+  string businessId = 1;
+
+  // Id of the store this client keeps, which is what makes an incremental sync out incremental in
+  // both directions: the server compares it against the Entity.updateInfo of every candidate
+  // entity and leaves out the ones this client wrote itself, because it already has them.
+  //
+  // A client generates this once and keeps it for the life of its store. It is never
+  // Constants.MASTER_DB_ID, which is the server, and never a reserved id, so a client that sends
+  // zero is claiming to be the server and will be sent its own writes back on every sync.
+  //
+  // The same value goes into the Entity.updateInfo of everything this client pushes in a
+  // BusinessSyncInRequest. There is no such field on that request, because there the id arrives on
+  // each entity instead.
+  int64 clientDatabaseId = 2;
+
+  // The business - entity type Constants.BUSINESS_ENTITY_TYPE_ID
+  int64 businessUpdateNumber = 3;
+
+  // The photos of the business, its products and its packages - entity type
+  // Constants.ATTACHMENT_ENTITY_TYPE_ID
+  int64 attachmentUpdateNumber = 4;
+
+  // The expiry of the attachment base url and token this client is holding - the UrlAndToken.expiry
+  // of the last BusinessSyncOutResponse.attachmentBaseUrl it received, sent back unchanged. Zero,
+  // the default, means this client holds none and is asking for one, which is what a first sync
+  // does.
+  //
+  // The server answers with a new attachmentBaseUrl when this is zero, or within
+  // Constants.ATTACHMENT_BASE_URL_EXPIRY_MARGIN of the time it reads the request, and leaves it
+  // absent otherwise. This is a time and not an update number: it is not comparable with the cursors
+  // around it, it does not rise monotonically, and a client must never derive it from anything but
+  // the UrlAndToken it holds.
+  int64 attachmentBaseUrlExpiry = 5;
+
+  // The settings of the business, which are held in a configuration entity - entity type
+  // Constants.CONFIGURATION_ENTITY_TYPE_ID
+  int64 configurationUpdateNumber = 6;
+
+  // The orders of the customer and their shopping cart - entity type
+  // Constants.MESSAGE_ENTITY_TYPE_ID
+  int64 messageUpdateNumber = 7;
+
+  // The whole catalog: product categories, products, packages, price lists and prices, which are
+  // all item entities and share this one cursor - entity type Constants.ITEM_ENTITY_TYPE_ID
+  int64 itemUpdateNumber = 8;
+}