@peabody-soft/mbs-model-ts 1.0.0

package/dist/generated/UrlAndToken.js

@@ -0,0 +1,67 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+// @generated message type with reflection information, may provide speed optimized methods
+class UrlAndToken$Type extends MessageType {
+    constructor() {
+        super("com.merabills.storefront.UrlAndToken", [
+            { no: 1, name: "resourceUrl", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "sasToken", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "expiry", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.resourceUrl = "";
+        message.sasToken = "";
+        message.expiry = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string resourceUrl */ 1:
+                    message.resourceUrl = reader.string();
+                    break;
+                case /* string sasToken */ 2:
+                    message.sasToken = reader.string();
+                    break;
+                case /* int64 expiry */ 3:
+                    message.expiry = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string resourceUrl = 1; */
+        if (message.resourceUrl !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.resourceUrl);
+        /* string sasToken = 2; */
+        if (message.sasToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.sasToken);
+        /* int64 expiry = 3; */
+        if (message.expiry !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.expiry);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.UrlAndToken
+ */
+export const UrlAndToken = new UrlAndToken$Type();

package/dist/generated/User.d.ts

@@ -0,0 +1,63 @@
+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 { AddressList } from "./AddressList";
+import { Entity } from "./Entity";
+/**
+ * A user of MeraBills; a customer of a business is represented by one. Carried by a
+ * ProfileSyncOutResponse, not by a business sync out - a client reads the caller once, at sign in.
+ * Excluded: referralDetails, isCallingUser, all Translations fields.
+ * Not included because it is derived: formattedName (firstName + " " + lastName).
+ *
+ * @generated from protobuf message com.merabills.storefront.User
+ */
+export interface User {
+    /**
+     * @generated from protobuf field: com.merabills.storefront.Entity entity = 1
+     */
+    entity?: Entity;
+    /**
+     * At most Constants.USER_NAME_MAX_LENGTH
+     *
+     * @generated from protobuf field: string firstName = 2
+     */
+    firstName: string;
+    /**
+     * At most Constants.USER_NAME_MAX_LENGTH
+     *
+     * @generated from protobuf field: optional string lastName = 3
+     */
+    lastName?: string;
+    /**
+     * E.164 formatted mobile phone number
+     *
+     * @generated from protobuf field: string mobilePhoneNumber = 4
+     */
+    mobilePhoneNumber: string;
+    /**
+     * Delivery addresses of this user, and the id of the default one
+     *
+     * @generated from protobuf field: com.merabills.storefront.AddressList addresses = 5
+     */
+    addresses?: AddressList;
+    /**
+     * BCP 47 / ISO 639 language code (at most Constants.USER_LANGUAGE_CODE_MAX_LENGTH)
+     *
+     * @generated from protobuf field: optional string preferredLanguageCode = 6
+     */
+    preferredLanguageCode?: string;
+}
+declare class User$Type extends MessageType<User> {
+    constructor();
+    create(value?: PartialMessage<User>): User;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: User): User;
+    internalBinaryWrite(message: User, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.User
+ */
+export declare const User: User$Type;
+export {};

package/dist/generated/User.js

@@ -0,0 +1,89 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { AddressList } from "./AddressList";
+import { Entity } from "./Entity";
+// @generated message type with reflection information, may provide speed optimized methods
+class User$Type extends MessageType {
+    constructor() {
+        super("com.merabills.storefront.User", [
+            { no: 1, name: "entity", kind: "message", T: () => Entity },
+            { no: 2, name: "firstName", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "lastName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "mobilePhoneNumber", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "addresses", kind: "message", T: () => AddressList },
+            { no: 6, name: "preferredLanguageCode", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.firstName = "";
+        message.mobilePhoneNumber = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* com.merabills.storefront.Entity entity */ 1:
+                    message.entity = Entity.internalBinaryRead(reader, reader.uint32(), options, message.entity);
+                    break;
+                case /* string firstName */ 2:
+                    message.firstName = reader.string();
+                    break;
+                case /* optional string lastName */ 3:
+                    message.lastName = reader.string();
+                    break;
+                case /* string mobilePhoneNumber */ 4:
+                    message.mobilePhoneNumber = reader.string();
+                    break;
+                case /* com.merabills.storefront.AddressList addresses */ 5:
+                    message.addresses = AddressList.internalBinaryRead(reader, reader.uint32(), options, message.addresses);
+                    break;
+                case /* optional string preferredLanguageCode */ 6:
+                    message.preferredLanguageCode = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* com.merabills.storefront.Entity entity = 1; */
+        if (message.entity)
+            Entity.internalBinaryWrite(message.entity, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string firstName = 2; */
+        if (message.firstName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.firstName);
+        /* optional string lastName = 3; */
+        if (message.lastName !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.lastName);
+        /* string mobilePhoneNumber = 4; */
+        if (message.mobilePhoneNumber !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.mobilePhoneNumber);
+        /* com.merabills.storefront.AddressList addresses = 5; */
+        if (message.addresses)
+            AddressList.internalBinaryWrite(message.addresses, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* optional string preferredLanguageCode = 6; */
+        if (message.preferredLanguageCode !== undefined)
+            writer.tag(6, WireType.LengthDelimited).string(message.preferredLanguageCode);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.User
+ */
+export const User = new User$Type();

package/dist/generated/Weight.d.ts

@@ -0,0 +1,33 @@
+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 { WeightUnit } from "./WeightUnit";
+/**
+ * The weight of a package. The value is greater than zero.
+ *
+ * @generated from protobuf message com.merabills.storefront.Weight
+ */
+export interface Weight {
+    /**
+     * @generated from protobuf field: com.merabills.storefront.WeightUnit unit = 1
+     */
+    unit: WeightUnit;
+    /**
+     * @generated from protobuf field: float value = 2
+     */
+    value: number;
+}
+declare class Weight$Type extends MessageType<Weight> {
+    constructor();
+    create(value?: PartialMessage<Weight>): Weight;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Weight): Weight;
+    internalBinaryWrite(message: Weight, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.Weight
+ */
+export declare const Weight: Weight$Type;
+export {};

package/dist/generated/Weight.js

@@ -0,0 +1,60 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { WeightUnit } from "./WeightUnit";
+// @generated message type with reflection information, may provide speed optimized methods
+class Weight$Type extends MessageType {
+    constructor() {
+        super("com.merabills.storefront.Weight", [
+            { no: 1, name: "unit", kind: "enum", T: () => ["com.merabills.storefront.WeightUnit", WeightUnit] },
+            { no: 2, name: "value", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.unit = 0;
+        message.value = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* com.merabills.storefront.WeightUnit unit */ 1:
+                    message.unit = reader.int32();
+                    break;
+                case /* float value */ 2:
+                    message.value = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* com.merabills.storefront.WeightUnit unit = 1; */
+        if (message.unit !== 0)
+            writer.tag(1, WireType.Varint).int32(message.unit);
+        /* float value = 2; */
+        if (message.value !== 0)
+            writer.tag(2, WireType.Bit32).float(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.Weight
+ */
+export const Weight = new Weight$Type();

package/dist/generated/WeightUnit.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Unit in which the weight of a package is expressed.
+ * Values match the ids of the corresponding Java enum entries and must never be changed.
+ *
+ * @generated from protobuf enum com.merabills.storefront.WeightUnit
+ */
+export declare enum WeightUnit {
+    /**
+     * @generated from protobuf enum value: GRAMS = 0;
+     */
+    GRAMS = 0,
+    /**
+     * @generated from protobuf enum value: MILLIGRAMS = 1;
+     */
+    MILLIGRAMS = 1,
+    /**
+     * @generated from protobuf enum value: KILOGRAMS = 2;
+     */
+    KILOGRAMS = 2,
+    /**
+     * @generated from protobuf enum value: OUNCES = 3;
+     */
+    OUNCES = 3,
+    /**
+     * @generated from protobuf enum value: POUNDS = 4;
+     */
+    POUNDS = 4
+}

package/dist/generated/WeightUnit.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+// @generated by protobuf-ts 2.11.1 with parameter long_type_bigint
+// @generated from protobuf file "WeightUnit.proto" (package "com.merabills.storefront", syntax proto3)
+// tslint:disable
+/**
+ * Unit in which the weight of a package is expressed.
+ * Values match the ids of the corresponding Java enum entries and must never be changed.
+ *
+ * @generated from protobuf enum com.merabills.storefront.WeightUnit
+ */
+export var WeightUnit;
+(function (WeightUnit) {
+    /**
+     * @generated from protobuf enum value: GRAMS = 0;
+     */
+    WeightUnit[WeightUnit["GRAMS"] = 0] = "GRAMS";
+    /**
+     * @generated from protobuf enum value: MILLIGRAMS = 1;
+     */
+    WeightUnit[WeightUnit["MILLIGRAMS"] = 1] = "MILLIGRAMS";
+    /**
+     * @generated from protobuf enum value: KILOGRAMS = 2;
+     */
+    WeightUnit[WeightUnit["KILOGRAMS"] = 2] = "KILOGRAMS";
+    /**
+     * @generated from protobuf enum value: OUNCES = 3;
+     */
+    WeightUnit[WeightUnit["OUNCES"] = 3] = "OUNCES";
+    /**
+     * @generated from protobuf enum value: POUNDS = 4;
+     */
+    WeightUnit[WeightUnit["POUNDS"] = 4] = "POUNDS";
+})(WeightUnit || (WeightUnit = {}));

package/dist/generated/WorkingDays.d.ts

@@ -0,0 +1,42 @@
+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 { WorkingHours } from "./WorkingHours";
+/**
+ * The days of the week on which a business works, and the hours it works on each of them.
+ * Not included because it is derived: includesAllDaysOfWeek, isWorkingDay, isOpenAllDay and
+ * isOpenAt.
+ *
+ * @generated from protobuf message com.merabills.storefront.WorkingDays
+ */
+export interface WorkingDays {
+    /**
+     * Up to Constants.DAYS_IN_WEEK values, index 0 = Sunday. True means the business works that day;
+     * missing means false. An absent WorkingDays means every day is worked (the default).
+     *
+     * @generated from protobuf field: repeated bool days = 1
+     */
+    days: boolean[];
+    /**
+     * Working hours of each day, indexed as days above (entry 0 = Sunday); up to
+     * Constants.DAYS_IN_WEEK entries, fewer is normal. A missing entry, or one with no ranges, means
+     * work all day; only meaningful on a day whose days entry is true.
+     *
+     * @generated from protobuf field: repeated com.merabills.storefront.WorkingHours workingHours = 2
+     */
+    workingHours: WorkingHours[];
+}
+declare class WorkingDays$Type extends MessageType<WorkingDays> {
+    constructor();
+    create(value?: PartialMessage<WorkingDays>): WorkingDays;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WorkingDays): WorkingDays;
+    internalBinaryWrite(message: WorkingDays, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.WorkingDays
+ */
+export declare const WorkingDays: WorkingDays$Type;
+export {};

package/dist/generated/WorkingDays.js

@@ -0,0 +1,68 @@
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { WorkingHours } from "./WorkingHours";
+// @generated message type with reflection information, may provide speed optimized methods
+class WorkingDays$Type extends MessageType {
+    constructor() {
+        super("com.merabills.storefront.WorkingDays", [
+            { no: 1, name: "days", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "workingHours", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => WorkingHours }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.days = [];
+        message.workingHours = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated bool days */ 1:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.days.push(reader.bool());
+                    else
+                        message.days.push(reader.bool());
+                    break;
+                case /* repeated com.merabills.storefront.WorkingHours workingHours */ 2:
+                    message.workingHours.push(WorkingHours.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated bool days = 1; */
+        if (message.days.length) {
+            writer.tag(1, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.days.length; i++)
+                writer.bool(message.days[i]);
+            writer.join();
+        }
+        /* repeated com.merabills.storefront.WorkingHours workingHours = 2; */
+        for (let i = 0; i < message.workingHours.length; i++)
+            WorkingHours.internalBinaryWrite(message.workingHours[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.WorkingDays
+ */
+export const WorkingDays = new WorkingDays$Type();

package/dist/generated/WorkingHours.d.ts

@@ -0,0 +1,33 @@
+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 { WorkingHoursRange } from "./WorkingHoursRange";
+/**
+ * The working hours of a single day.
+ * Not included because they are computed: rangeCount, isAllDay and contains.
+ *
+ * @generated from protobuf message com.merabills.storefront.WorkingHours
+ */
+export interface WorkingHours {
+    /**
+     * Stretches worked in the day (at most Constants.WORKING_HOURS_MAX_RANGES): non-overlapping,
+     * ordered by openMinute, and merged when adjacent. No ranges means work goes on all day.
+     *
+     * @generated from protobuf field: repeated com.merabills.storefront.WorkingHoursRange ranges = 1
+     */
+    ranges: WorkingHoursRange[];
+}
+declare class WorkingHours$Type extends MessageType<WorkingHours> {
+    constructor();
+    create(value?: PartialMessage<WorkingHours>): WorkingHours;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WorkingHours): WorkingHours;
+    internalBinaryWrite(message: WorkingHours, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.WorkingHours
+ */
+export declare const WorkingHours: WorkingHours$Type;
+export {};

package/dist/generated/WorkingHours.js

@@ -0,0 +1,52 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { WorkingHoursRange } from "./WorkingHoursRange";
+// @generated message type with reflection information, may provide speed optimized methods
+class WorkingHours$Type extends MessageType {
+    constructor() {
+        super("com.merabills.storefront.WorkingHours", [
+            { no: 1, name: "ranges", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => WorkingHoursRange }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.ranges = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated com.merabills.storefront.WorkingHoursRange ranges */ 1:
+                    message.ranges.push(WorkingHoursRange.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated com.merabills.storefront.WorkingHoursRange ranges = 1; */
+        for (let i = 0; i < message.ranges.length; i++)
+            WorkingHoursRange.internalBinaryWrite(message.ranges[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.WorkingHours
+ */
+export const WorkingHours = new WorkingHours$Type();

package/dist/generated/WorkingHoursRange.d.ts

@@ -0,0 +1,42 @@
+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";
+/**
+ * A single stretch of working hours within a day, in minutes after local midnight (no time zone is
+ * carried - resolve using the business address's time zone).
+ * A range never spans midnight; work past midnight is two ranges - one closing at
+ * Constants.MINUTES_PER_DAY, one opening at 0 the next day.
+ * Not included because it is derived: isAllDay, contains, overlaps.
+ *
+ * @generated from protobuf message com.merabills.storefront.WorkingHoursRange
+ */
+export interface WorkingHoursRange {
+    /**
+     * Minute at which work starts, from 0 to Constants.MINUTES_PER_DAY - 1. This minute is worked.
+     *
+     * @generated from protobuf field: int32 openMinute = 1
+     */
+    openMinute: number;
+    /**
+     * Minute at which work stops, from 1 to Constants.MINUTES_PER_DAY, and always greater than
+     * openMinute. This minute is not worked, so Constants.MINUTES_PER_DAY means work stops at
+     * midnight.
+     *
+     * @generated from protobuf field: int32 closeMinute = 2
+     */
+    closeMinute: number;
+}
+declare class WorkingHoursRange$Type extends MessageType<WorkingHoursRange> {
+    constructor();
+    create(value?: PartialMessage<WorkingHoursRange>): WorkingHoursRange;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WorkingHoursRange): WorkingHoursRange;
+    internalBinaryWrite(message: WorkingHoursRange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.WorkingHoursRange
+ */
+export declare const WorkingHoursRange: WorkingHoursRange$Type;
+export {};