@peabody-soft/mbs-model-ts 1.0.0

package/dist/SyncCache.js

@@ -0,0 +1,137 @@
+import Ids from "./Ids";
+import * as ProtoMap from "./ProtoMap";
+// 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.
+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.
+    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.
+    async writeBusiness(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 writeProfile(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.
+    async readAuthTokens(containerName) {
+        const blob = await (await this.getContainer(containerName)).read(Ids.AUTH_TOKENS_BLOB_ID);
+        if (blob === null)
+            return null;
+        return ProtoMap.authTokensFromBytes(blob.bytes);
+    }
+    // Unconditional, unlike everything else here: a reissued token is not a later version of an earlier one, so there is nothing to compare and the latest wins.
+    // Keeps only what this server issued - see ProtoMap.authTokensToBlob for why the authentication token is dropped whatever is passed in.
+    async writeAuthTokens(containerName, authTokens) {
+        await this.writeBlobs(containerName, [ProtoMap.authTokensToBlob(authTokens)]);
+    }
+    // The orders of whoever the responses written here answered, since a server sends a caller only their own messages.
+    // Nothing here records which caller that was, or notices when it changes - see THE MESSAGES OF A BUSINESS ARE NOT PUBLIC.
+    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, cart and orders alike. Not persisted, like every cursor in this library - read off
+    // the store fresh each time rather than kept anywhere.
+    async readMessageUpdateNumber(containerName) {
+        return ProtoMap.highestCachedMessageUpdateNumber(await this.readAll(containerName));
+    }
+    // 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)]);
+    }
+    // The cart in this container, or null when there is none. Two carts mean two callers, which is the same open question as the orders above.
+    async readCart(containerName) {
+        return ProtoMap.cartMessageFromBlobs(await this.readAll(containerName));
+    }
+    async writeCart(containerName, cart) {
+        return this.writeBlobs(containerName, [ProtoMap.cartToBlob(cart)]);
+    }
+    // Drops the cart 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: a cart written before anybody
+    // signed in is handed over to the container named for the membership, and the copy left behind
+    // would otherwise be read by the next anonymous visitor and by the next customer to sign in - see
+    // Model.businessSyncIn. Nothing else about a container is a caller's to remove: everything in one
+    // came off the wire, and what the server has not said is gone stays.
+    async deleteCart(containerName) {
+        const cart = await this.readCart(containerName);
+        if (cart === null)
+            return 0;
+        return this.write(containerName, {
+            blobs: NO_BLOBS,
+            deletedIds: [ProtoMap.cartToBlob(cart).id],
+        });
+    }
+    // The messages a sync in response carried, in a single batch - a pushed order and the cart 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 - those are for a
+    // caller handing in a message it was given, where storing an order as a cart would be a mistake
+    // worth catching, and this is for messages the response itself is the authority on.
+    async writeMessages(containerName, messages) {
+        return this.write(containerName, ProtoMap.messagesToCacheWrite(messages));
+    }
+    async readAll(containerName) {
+        return (await this.getContainer(containerName)).readAll();
+    }
+    // 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.
+    async write(containerName, cacheWrite) {
+        const blobs = cacheWrite.blobs;
+        const deletedIds = cacheWrite.deletedIds;
+        if (blobs.length === 0 && deletedIds.length === 0)
+            return 0;
+        const storedCount = await (await this.getContainer(containerName)).write(blobs, deletedIds);
+        return storedCount + deletedIds.length;
+    }
+    // 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) {
+        const held = this._containers.get(containerName);
+        if (held !== undefined)
+            return held;
+        const pending = this._database.getContainer(containerName);
+        this._containers.set(containerName, pending);
+        // A failure is not remembered, or one unlucky read would poison this name for as long as this cache lives
+        void pending.catch(() => {
+            if (this._containers.get(containerName) === pending)
+                this._containers.delete(containerName);
+        });
+        return pending;
+    }
+}
+export const NO_DELETES = Object.freeze([]);
+const NO_BLOBS = Object.freeze([]);

package/dist/SyncKeys.d.ts

@@ -0,0 +1,5 @@
+export declare const BUSINESS_SYNC_IN: ReadonlyArray<number>;
+export declare const PROFILE_SYNC_IN: ReadonlyArray<number>;
+export declare const BUSINESS_SYNC_OUT: ReadonlyArray<number>;
+export declare const ITEM_ENTITY_TYPE_IDS: ReadonlyArray<number>;
+export declare function keyOf(entityTypeId: number): number;

package/dist/SyncKeys.js

@@ -0,0 +1,41 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+// Which update numbers a SyncState keeps, and what entity type counts under which key. Kept here
+// rather than in SyncState since these are facts about the protocol, not about counting.
+// A state refuses keys outside its set on purpose: Business arrives from both sync outs with
+// unrelated update numbers, and these must never mix.
+// The cursors a business sync in sends: the business itself, its attachments, its configurations,
+// its messages and its items. These are the five cursor fields of a BusinessSyncOutRequest.
+export const BUSINESS_SYNC_IN = Object.freeze([
+    proto_Constants.BUSINESS_ENTITY_TYPE_ID,
+    proto_Constants.ATTACHMENT_ENTITY_TYPE_ID,
+    proto_Constants.CONFIGURATION_ENTITY_TYPE_ID,
+    proto_Constants.MESSAGE_ENTITY_TYPE_ID,
+    proto_Constants.ITEM_ENTITY_TYPE_ID,
+]);
+// The cursors a profile sync in sends - the three entity types Java keeps in a profile database.
+// BUSINESS also appears above, with an unrelated number in each; never mix the two.
+export const PROFILE_SYNC_IN = Object.freeze([
+    proto_Constants.USER_ENTITY_TYPE_ID,
+    proto_Constants.BUSINESS_ENTITY_TYPE_ID,
+    proto_Constants.BUSINESS_LINK_ENTITY_TYPE_ID,
+]);
+// Update numbers a business sync out records (as a BusinessSyncInResponse returns them). Message
+// is the only entity type a storefront may push, so this is a set of one.
+export const BUSINESS_SYNC_OUT = Object.freeze([
+    proto_Constants.MESSAGE_ENTITY_TYPE_ID,
+]);
+// The five entity types that share the item table, and therefore share one update number
+export const ITEM_ENTITY_TYPE_IDS = Object.freeze([
+    proto_Constants.PACKAGE_ENTITY_TYPE_ID,
+    proto_Constants.PRODUCT_ENTITY_TYPE_ID,
+    proto_Constants.PRODUCT_CATEGORY_ENTITY_TYPE_ID,
+    proto_Constants.PRICE_ENTITY_TYPE_ID,
+    proto_Constants.PRICE_LIST_ENTITY_TYPE_ID,
+]);
+// The key an entity counts under: one update number per table, not per class - a product's number
+// is the shared item number.
+export function keyOf(entityTypeId) {
+    return ITEM_ENTITY_TYPE_IDS.includes(entityTypeId)
+        ? proto_Constants.ITEM_ENTITY_TYPE_ID
+        : entityTypeId;
+}

package/dist/SyncState.d.ts

@@ -0,0 +1,8 @@
+export default class SyncState {
+    private readonly _keys;
+    constructor(_keys: ReadonlyArray<number>);
+    getUpdateNumber(entityTypeId: number): bigint;
+    raiseUpdateNumber(entityTypeId: number, updateNumber: bigint): boolean;
+    private checkKey;
+    private readonly _updateNumbers;
+}

package/dist/SyncState.js

@@ -0,0 +1,30 @@
+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.
+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) {
+        this._keys = _keys;
+        this._updateNumbers = new Map();
+    }
+    // Zero (an unset key) asks the server for everything of that type - what a first read sends for every key.
+    getUpdateNumber(entityTypeId) {
+        return this._updateNumbers.get(this.checkKey(entityTypeId)) ?? 0n;
+    }
+    // Raises the cursor for this entity type (tombstones included - skipping one would refetch it for ever) and reports whether it moved.
+    // Numbers only ever rise; a lower one is ignored as stale or redelivered.
+    raiseUpdateNumber(entityTypeId, updateNumber) {
+        const key = this.checkKey(entityTypeId);
+        if (updateNumber <= (this._updateNumbers.get(key) ?? 0n))
+            return false;
+        this._updateNumbers.set(key, updateNumber);
+        return true;
+    }
+    checkKey(entityTypeId) {
+        const key = SyncKeys.keyOf(entityTypeId);
+        if (!this._keys.includes(key))
+            throw new InvalidArgumentException(`Entity type ${entityTypeId} has no update number in this sync state`);
+        return key;
+    }
+}

package/dist/Tax.d.ts

@@ -0,0 +1,10 @@
+import { TaxType as proto_TaxType } from "./generated/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;
+    get countryCode(): number;
+    get rate(): number;
+}

package/dist/Tax.js

@@ -0,0 +1,30 @@
+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.
+// 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));
+    }
+    constructor(_type, _rate) {
+        this._type = _type;
+        this._rate = _rate;
+    }
+    get type() {
+        return this._type;
+    }
+    // The country this tax belongs to, ISO 3166-1 numeric. A TaxType value is not a raw Java tax
+    // code - it is Java TaxType.createId(country, taxCode), the country in its high bits - so the
+    // 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;
+    }
+    // A percentage: 18 means 18%
+    get rate() {
+        return this._rate;
+    }
+}

package/dist/UserProfile.d.ts

@@ -0,0 +1,16 @@
+import { AddressList } from "./Address";
+import Entity, { EntityHeader } from "./Entity";
+export default class UserProfile extends Entity {
+    private readonly _firstName;
+    private readonly _lastName;
+    private readonly _mobilePhoneNumber;
+    private readonly _addresses;
+    private readonly _preferredLanguageCode;
+    constructor(header: EntityHeader, _firstName: string, _lastName: string | null, _mobilePhoneNumber: string, _addresses: AddressList, _preferredLanguageCode: string | null);
+    get firstName(): string;
+    get lastName(): string | null;
+    get mobilePhoneNumber(): string;
+    get addresses(): AddressList;
+    get preferredLanguageCode(): string | null;
+    get formattedName(): string;
+}

package/dist/UserProfile.js

@@ -0,0 +1,40 @@
+import Entity from "./Entity";
+// The customer: whose orders and cart the business sees. Named for the database it lives in
+// (profile, not business) - a signed-out storefront has no user but still shows its catalog.
+// Exactly the User message, with no derived state added.
+export default class UserProfile extends Entity {
+    constructor(header, _firstName, _lastName, _mobilePhoneNumber, _addresses, _preferredLanguageCode) {
+        super(header);
+        this._firstName = _firstName;
+        this._lastName = _lastName;
+        this._mobilePhoneNumber = _mobilePhoneNumber;
+        this._addresses = _addresses;
+        this._preferredLanguageCode = _preferredLanguageCode;
+    }
+    get firstName() {
+        return this._firstName;
+    }
+    get lastName() {
+        return this._lastName;
+    }
+    // E.164 formatted
+    get mobilePhoneNumber() {
+        return this._mobilePhoneNumber;
+    }
+    // The delivery addresses of this customer, and which of them is the default. This is also what
+    // resolves Order.deliveryAddressId, which is an id into this list.
+    get addresses() {
+        return this._addresses;
+    }
+    // BCP 47 / ISO 639
+    get preferredLanguageCode() {
+        return this._preferredLanguageCode;
+    }
+    // The two names with a space between them, and just the first name when there is no last name.
+    // Computed here rather than sent.
+    get formattedName() {
+        if (this._lastName === null || this._lastName.length === 0)
+            return this._firstName;
+        return `${this._firstName} ${this._lastName}`;
+    }
+}

package/dist/WorkingDays.d.ts

@@ -0,0 +1,33 @@
+export default class WorkingDays {
+    private readonly _days;
+    private readonly _workingHours;
+    constructor(_days: ReadonlyArray<boolean>, _workingHours: ReadonlyArray<WorkingHours>);
+    get days(): ReadonlyArray<boolean>;
+    get workingHours(): ReadonlyArray<WorkingHours>;
+    get includesAllDaysOfWeek(): boolean;
+    isWorkingDay(dayOfWeek: number): boolean;
+    getWorkingHours(dayOfWeek: number): WorkingHours | null;
+    isOpenAllDay(dayOfWeek: number): boolean;
+    isOpenAt(dayOfWeek: number, minuteOfDay: number): boolean;
+    private static checkDayOfWeek;
+    static readonly ALL_DAYS: WorkingDays;
+}
+export declare class WorkingHours {
+    private readonly _ranges;
+    constructor(_ranges: ReadonlyArray<WorkingHoursRange>);
+    get ranges(): ReadonlyArray<WorkingHoursRange>;
+    get rangeCount(): number;
+    get isAllDay(): boolean;
+    contains(minuteOfDay: number): boolean;
+    static readonly ALL_DAY: WorkingHours;
+}
+export declare class WorkingHoursRange {
+    private readonly _openMinute;
+    private readonly _closeMinute;
+    constructor(_openMinute: number, _closeMinute: number);
+    get openMinute(): number;
+    get closeMinute(): number;
+    get isAllDay(): boolean;
+    contains(minuteOfDay: number): boolean;
+    overlaps(other: WorkingHoursRange): boolean;
+}

package/dist/WorkingDays.js

@@ -0,0 +1,121 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+import { InvalidArgumentException } from "./Exceptions";
+// Days and hours a business works. Absence is the permissive value throughout: no WorkingDays
+// means every day (ALL_DAYS); a day with no hours/ranges means worked all day.
+// No time zone here (the protocol carries none) - only a caller that knows the business's zone
+// can turn a moment into these day/minute values.
+class WorkingDays {
+    constructor(_days, _workingHours) {
+        this._days = _days;
+        this._workingHours = _workingHours;
+    }
+    // Index 0 is Sunday and index 6 is Saturday, the same numbering as Date.getDay. Shorter than
+    // seven entries is normal, and a missing entry is false.
+    get days() {
+        return this._days;
+    }
+    // Indexed exactly as days above. Shorter than days, or empty, is normal: see the comment on
+    // this class for what a missing entry means.
+    get workingHours() {
+        return this._workingHours;
+    }
+    get includesAllDaysOfWeek() {
+        for (let dayOfWeek = 0; dayOfWeek < proto_Constants.DAYS_IN_WEEK; ++dayOfWeek)
+            if (!this.isWorkingDay(dayOfWeek))
+                return false;
+        return true;
+    }
+    isWorkingDay(dayOfWeek) {
+        WorkingDays.checkDayOfWeek(dayOfWeek);
+        return this._days[dayOfWeek] === true;
+    }
+    // The hours of a day that is worked, or null when that day is worked all day long or is not
+    // worked at all. A UI showing opening times treats null as all day, having tested the day first.
+    getWorkingHours(dayOfWeek) {
+        WorkingDays.checkDayOfWeek(dayOfWeek);
+        if (dayOfWeek >= this._workingHours.length)
+            return null;
+        const workingHours = this._workingHours[dayOfWeek];
+        return workingHours.isAllDay ? null : workingHours;
+    }
+    isOpenAllDay(dayOfWeek) {
+        return this.isWorkingDay(dayOfWeek) && this.getWorkingHours(dayOfWeek) === null;
+    }
+    // minuteOfDay is minutes after local midnight, from 0 to Constants.MINUTES_PER_DAY - 1
+    isOpenAt(dayOfWeek, minuteOfDay) {
+        if (!this.isWorkingDay(dayOfWeek))
+            return false;
+        const workingHours = this.getWorkingHours(dayOfWeek);
+        return workingHours === null || workingHours.contains(minuteOfDay);
+    }
+    static checkDayOfWeek(dayOfWeek) {
+        if (!Number.isInteger(dayOfWeek) || dayOfWeek < 0 || dayOfWeek >= proto_Constants.DAYS_IN_WEEK)
+            throw new InvalidArgumentException(`Not a day of the week: ${dayOfWeek}`);
+    }
+}
+// What an absent WorkingDays means: the business works every day, all day long
+WorkingDays.ALL_DAYS = new WorkingDays(Object.freeze([true, true, true, true, true, true, true]), Object.freeze([]));
+export default WorkingDays;
+// The hours of a single day that are worked, as the stretches of it that are.
+export class WorkingHours {
+    constructor(_ranges) {
+        this._ranges = _ranges;
+    }
+    // Ordered by openMinute, never overlapping, and never touching: a range that closes exactly when
+    // the next opens arrives as one unbroken range.
+    get ranges() {
+        return this._ranges;
+    }
+    get rangeCount() {
+        return this._ranges.length;
+    }
+    // No ranges at all means all day long, which is also what one range covering the whole day means
+    get isAllDay() {
+        return (this._ranges.length === 0 || (this._ranges.length === 1 && this._ranges[0].isAllDay));
+    }
+    contains(minuteOfDay) {
+        if (this.isAllDay)
+            return true;
+        for (const range of this._ranges)
+            if (range.contains(minuteOfDay))
+                return true;
+        return false;
+    }
+}
+// What a missing or empty entry of WorkingDays.workingHours means
+WorkingHours.ALL_DAY = new WorkingHours(Object.freeze([]));
+// One stretch of a day that is worked, in minutes after local midnight.
+export class WorkingHoursRange {
+    constructor(_openMinute, _closeMinute) {
+        this._openMinute = _openMinute;
+        this._closeMinute = _closeMinute;
+        // Validated on the way in: a payload that breaks protocol rules fails the sync rather than
+        // producing opening times a customer would trust as fact.
+        if (!Number.isInteger(_openMinute) ||
+            _openMinute < 0 ||
+            _openMinute >= proto_Constants.MINUTES_PER_DAY)
+            throw new InvalidArgumentException(`Not a minute of the day: ${_openMinute}`);
+        if (!Number.isInteger(_closeMinute) ||
+            _closeMinute <= _openMinute ||
+            _closeMinute > proto_Constants.MINUTES_PER_DAY)
+            throw new InvalidArgumentException(`Work cannot stop at minute ${_closeMinute} having started at ${_openMinute}`);
+    }
+    // Worked. From 0 to Constants.MINUTES_PER_DAY - 1.
+    get openMinute() {
+        return this._openMinute;
+    }
+    // Not worked; MINUTES_PER_DAY means work stops at midnight. Always > openMinute - a range never
+    // spans midnight, so overnight work is two ranges on two days.
+    get closeMinute() {
+        return this._closeMinute;
+    }
+    get isAllDay() {
+        return this._openMinute === 0 && this._closeMinute === proto_Constants.MINUTES_PER_DAY;
+    }
+    contains(minuteOfDay) {
+        return minuteOfDay >= this._openMinute && minuteOfDay < this._closeMinute;
+    }
+    overlaps(other) {
+        return this._openMinute < other._closeMinute && other._openMinute < this._closeMinute;
+    }
+}

package/dist/generated/Address.d.ts

@@ -0,0 +1,77 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { AddressType } from "./AddressType";
+/**
+ * A postal address - a delivery address of a customer, or an address of a business
+ *
+ * @generated from protobuf message com.merabills.storefront.Address
+ */
+export interface Address {
+    /**
+     * Unique id of this address within the list that holds it
+     *
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: bigint;
+    /**
+     * @generated from protobuf field: com.merabills.storefront.AddressType addressType = 2
+     */
+    addressType: AddressType;
+    /**
+     * Flat / house / building number (at most Constants.ADDRESS_UNIT_NUMBER_MAX_LENGTH)
+     *
+     * @generated from protobuf field: optional string unitNumber = 3
+     */
+    unitNumber?: string;
+    /**
+     * Street, locality or neighbourhood (at most Constants.ADDRESS_COMMUNITY_MAX_LENGTH)
+     *
+     * @generated from protobuf field: optional string community = 4
+     */
+    community?: string;
+    /**
+     * At most Constants.ADDRESS_LINE2_MAX_LENGTH
+     *
+     * @generated from protobuf field: optional string line2 = 5
+     */
+    line2?: string;
+    /**
+     * At most Constants.ADDRESS_CITY_MAX_LENGTH
+     *
+     * @generated from protobuf field: optional string city = 6
+     */
+    city?: string;
+    /**
+     * At most Constants.ADDRESS_STATE_MAX_LENGTH
+     *
+     * @generated from protobuf field: optional string state = 7
+     */
+    state?: string;
+    /**
+     * Postal code / PIN code (at most Constants.ADDRESS_PIN_CODE_MAX_LENGTH)
+     *
+     * @generated from protobuf field: optional string pinCode = 8
+     */
+    pinCode?: string;
+    /**
+     * ISO 3166-1 numeric country code
+     *
+     * @generated from protobuf field: int32 countryCode = 9
+     */
+    countryCode: number;
+}
+declare class Address$Type extends MessageType<Address> {
+    constructor();
+    create(value?: PartialMessage<Address>): Address;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Address): Address;
+    internalBinaryWrite(message: Address, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.Address
+ */
+export declare const Address: Address$Type;
+export {};