npm-core-sdk/slotbooking.ts

// @generated by protobuf-ts 2.9.6 with parameter use_proto_field_name
// @generated from protobuf file "slotbooking.proto" (package "api", syntax proto3)
// tslint:disable
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import { WireType } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { TimeRange } from "./shared";
import { WeekDay } from "./shared";
import { LabelByLanguage } from "./shared";
/**
 * @generated from protobuf message api.Unit
 */
export interface Unit {
    /**
     * @generated from protobuf field: string UnitID = 1 [json_name = "UnitID"];
     */
    UnitID: string;
    /**
     * @generated from protobuf field: repeated api.LabelByLanguage Labels = 2 [json_name = "Labels"];
     */
    Labels: LabelByLanguage[]; // @option language
}
/**
 * @generated from protobuf message api.QuantityByUnit
 */
export interface QuantityByUnit {
    /**
     * referring to the Unit ID defined by the Site
     *
     * @generated from protobuf field: api.Unit UnitID = 1 [json_name = "UnitID"];
     */
    UnitID?: Unit;
    /**
     * Number of the specified unit
     *
     * @generated from protobuf field: double Value = 2 [json_name = "Value"];
     */
    Value: number;
}
/**
 * @generated from protobuf message api.Period
 */
export interface Period {
    /**
     * @generated from protobuf field: int64 Value = 1 [json_name = "Value"];
     */
    Value: bigint;
    /**
     * @generated from protobuf field: api.PeriodUnit Unit = 2 [json_name = "Unit"];
     */
    Unit: PeriodUnit;
}
/**
 * @generated from protobuf message api.Slot
 */
export interface Slot {
    /**
     * Slot start date time,
     *  format yyyy-mm-jjThh:mm:ss (iso8601 without timezone, because the time zone is defined by the site on which the slot is booked)
     *
     * @generated from protobuf field: string StartDateTime = 1 [json_name = "StartDateTime"];
     */
    StartDateTime: string;
    /**
     * Slot duration in seconds.
     *
     * @generated from protobuf field: uint64 DurationInSeconds = 3 [json_name = "DurationInSeconds"];
     */
    DurationInSeconds: bigint;
}
/**
 * Segmentations
 *
 * @generated from protobuf message api.Segmentation
 */
export interface Segmentation {
    /**
     * Identifier of the Segmentation
     *
     * @generated from protobuf field: string SegmentationID = 1 [json_name = "SegmentationID"];
     */
    SegmentationID: string;
    /**
     * Translated labels of the Segmentation
     *
     * @generated from protobuf field: repeated api.LabelByLanguage SegmentationLabel = 2 [json_name = "SegmentationLabel"];
     */
    SegmentationLabel: LabelByLanguage[]; // @option language
    /**
     * Possible values of the Segmentation
     *
     * @generated from protobuf field: repeated api.SegmentationValue Values = 3 [json_name = "Values"];
     */
    Values: SegmentationValue[];
}
/**
 * @generated from protobuf message api.SegmentationValue
 */
export interface SegmentationValue {
    /**
     * Identifier of the Segmentation value
     *
     * @generated from protobuf field: string ID = 1 [json_name = "ID"];
     */
    ID: string;
    /**
     * Translated labels of the Segmentation value
     *
     * @generated from protobuf field: repeated api.LabelByLanguage Label = 2 [json_name = "Label"];
     */
    Label: LabelByLanguage[]; // @option language
}
/**
 * Rules
 *
 * @generated from protobuf message api.OpeningRule
 */
export interface OpeningRule {
    /**
     * Start date of the opening rule validity, format yyyy-mm-jj
     * TODO Add time
     *
     * @generated from protobuf field: string StartDate = 1 [json_name = "StartDate"];
     */
    StartDate: string;
    /**
     * End date of the opening rule validity, format yyyy-mm-jj
     *
     * @generated from protobuf field: string EndDate = 2 [json_name = "EndDate"];
     */
    EndDate: string;
    /**
     * Definition of the opening rules by week day
     *
     * @generated from protobuf field: repeated api.OpeningDefinition OpeningDays = 3 [json_name = "OpeningDays"];
     */
    OpeningDays: OpeningDefinition[];
    /**
     * The identifier of the calendar to be used within this period of time
     *
     * @generated from protobuf field: string CalendarID = 4 [json_name = "CalendarID"];
     */
    CalendarID: string;
    /**
     * Label of the Rule
     *
     * @generated from protobuf field: string Label = 5 [json_name = "Label"];
     */
    Label: string;
}
/**
 * @generated from protobuf message api.OpeningDefinition
 */
export interface OpeningDefinition {
    /**
     * Day of the week
     *
     * @generated from protobuf field: api.WeekDay WeekDay = 1 [json_name = "WeekDay"];
     */
    WeekDay: WeekDay;
    /**
     * Opening hours definition according to filters
     *
     * @generated from protobuf field: repeated api.OpeningDayDefinition Definition = 2 [json_name = "Definition"];
     */
    Definition: OpeningDayDefinition[];
}
/**
 * @generated from protobuf message api.OpeningDayDefinition
 */
export interface OpeningDayDefinition {
    /**
     * List of opening hours
     *
     * @generated from protobuf field: repeated api.TimeRange TimeRanges = 2 [json_name = "TimeRanges"];
     */
    TimeRanges: TimeRange[];
    /**
     * Validity filters for this opening rule definition
     *
     * @generated from protobuf field: api.RuleFilter Filter = 3 [json_name = "Filter"];
     */
    Filter?: RuleFilter;
    /**
     * Order in which the Rule will be applied
     *
     * @generated from protobuf field: int32 OrderAppliance = 4 [json_name = "OrderAppliance"];
     */
    OrderAppliance: number;
}
/**
 * @generated from protobuf message api.CapacityRule
 */
export interface CapacityRule {
    /**
     *  Start date of the capacity rule validity, format yyyy-mm-jj.
     *
     * @generated from protobuf field: string StartDate = 1 [json_name = "StartDate"];
     */
    StartDate: string;
    /**
     * End date of the capacity rule validity, format yyyy-mm-jj.
     *
     * @generated from protobuf field: string EndDate = 2 [json_name = "EndDate"];
     */
    EndDate: string;
    /**
     * Label of the Rule
     *
     * @generated from protobuf field: string Label = 5 [json_name = "Label"];
     */
    Label: string;
    /**
     * List of the days on which this rule is applied.
     *
     * @generated from protobuf field: repeated api.WeekDay Days = 3 [json_name = "Days"];
     */
    Days: WeekDay[];
    /**
     * Definition of the capacity rules.
     *
     * @generated from protobuf field: repeated api.CapacityDefinition Capacities = 4 [json_name = "Capacities"];
     */
    Capacities: CapacityDefinition[];
}
/**
 * @generated from protobuf message api.CapacityDefinition
 */
export interface CapacityDefinition {
    /**
     * Validity filters for this capacity rule definition.
     *
     * @generated from protobuf field: api.RuleFilter Filter = 1 [json_name = "Filter"];
     */
    Filter?: RuleFilter;
    /**
     * Scope of the rule, simultaneous or daily.
     *
     * @generated from protobuf field: api.CapacityRuleScope Scope = 2 [json_name = "Scope"];
     */
    Scope: CapacityRuleScope;
    /**
     * The capacity constraint to apply.
     *
     * @generated from protobuf field: int64 MaximalCapacity = 3 [json_name = "MaximalCapacity"];
     */
    MaximalCapacity: bigint;
    /**
     * Site unit identifier of the capacity if not 'APPOINTMENT'.
     *
     * @generated from protobuf field: string UnitID = 4 [json_name = "UnitID"];
     */
    UnitID: string;
}
/**
 * @generated from protobuf message api.DurationRule
 */
export interface DurationRule {
    /**
     * Validity filters for this duration rule definition.
     *
     * @generated from protobuf field: api.RuleFilter Filter = 1 [json_name = "Filter"];
     */
    Filter?: RuleFilter;
    /**
     * Base duration in seconds
     *
     * @generated from protobuf field: uint64 BaseDurationInSeconds = 2 [json_name = "BaseDurationInSeconds"];
     */
    BaseDurationInSeconds: bigint;
    /**
     * Variable duration definition by site unit.
     *
     * @generated from protobuf field: repeated api.VariableDuration VariableDurations = 3 [json_name = "VariableDurations"];
     */
    VariableDurations: VariableDuration[];
    /**
     * Order in which the Rule will be applied
     *
     * @generated from protobuf field: int32 OrderAppliance = 4 [json_name = "OrderAppliance"];
     */
    OrderAppliance: number;
}
/**
 * @generated from protobuf message api.VariableDuration
 */
export interface VariableDuration {
    /**
     * Site unit identifier
     *
     * @generated from protobuf field: string UnitID = 1 [json_name = "UnitID"];
     */
    UnitID: string;
    /**
     * Duration in seconds
     *
     * @generated from protobuf field: uint64 DurationInSeconds = 2 [json_name = "DurationInSeconds"];
     */
    DurationInSeconds: bigint;
}
/**
 * Conditions on ProjectID, AppointmentType or/and Segmentation keys
 *
 * @generated from protobuf message api.RuleFilter
 */
export interface RuleFilter {
    /**
     * Filter on appointment type (expedition or reception).
     *
     * @generated from protobuf field: api.AppointmentType Type = 1 [json_name = "Type"];
     */
    Type: AppointmentType;
    /**
     * Filter on project identifier.
     *
     * @generated from protobuf field: repeated string ProjectID = 2 [json_name = "ProjectID"];
     */
    ProjectID: string[];
    /**
     * Filter on site Segmentation keys.
     *
     * @generated from protobuf field: repeated api.SegmentationFilter SegmentationKeys = 3 [json_name = "SegmentationKeys"];
     */
    SegmentationKeys: SegmentationFilter[];
}
/**
 * @generated from protobuf message api.SegmentationFilter
 */
export interface SegmentationFilter {
    /**
     * Identifier of the Segmentation key.
     *
     * @generated from protobuf field: string SegmentationID = 1 [json_name = "SegmentationID"];
     */
    SegmentationID: string;
    /**
     * Identifiers of the Segmentation key values.
     *
     * @generated from protobuf field: repeated string SegmentationValueIDs = 2 [json_name = "SegmentationValueIDs"];
     */
    SegmentationValueIDs: string[];
}
/**
 * The five following messages are pretty similar, for each added object, they can add a translated version
 *
 * @generated from protobuf message api.CarrierInformation
 */
export interface CarrierInformation {
    /**
     * @generated from protobuf field: string CarrierInformationID = 1 [json_name = "CarrierInformationID"];
     */
    CarrierInformationID: string;
    /**
     * @generated from protobuf field: repeated api.LabelByLanguage Label = 2 [json_name = "Label"];
     */
    Label: LabelByLanguage[]; // @option language
    /**
     * @generated from protobuf field: api.CarrierInformationType Type = 3 [json_name = "Type"];
     */
    Type: CarrierInformationType;
    /**
     * @generated from protobuf field: bool IsMandatory = 4 [json_name = "IsMandatory"];
     */
    IsMandatory: boolean;
    /**
     * @generated from protobuf field: bool FormatCheck = 5 [json_name = "FormatCheck"];
     */
    FormatCheck: boolean;
}
/**
 * we anticipate that they want to put several but if they only have one with all the language, it should still work
 *
 * @generated from protobuf message api.Document
 */
export interface Document {
    /**
     * @generated from protobuf field: string DocID = 1 [json_name = "DocID"];
     */
    DocID: string;
    /**
     * @generated from protobuf field: repeated api.DocumentByLanguage DocsByLang = 2 [json_name = "DocsByLang"];
     */
    DocsByLang: DocumentByLanguage[]; // @option language
    /**
     * @generated from protobuf field: bool AckRequired = 3 [json_name = "AckRequired"];
     */
    AckRequired: boolean;
}
/**
 * @generated from protobuf message api.DocumentByLanguage
 */
export interface DocumentByLanguage {
    /**
     * @generated from protobuf field: string Name = 1 [json_name = "Name"];
     */
    Name: string;
    /**
     * @generated from protobuf field: bytes Doc = 2 [json_name = "Doc"];
     */
    Doc: Uint8Array;
    /**
     * @generated from protobuf field: string LanguageCodeISO6391 = 3 [json_name = "LanguageCodeISO6391"];
     */
    LanguageCodeISO6391: string;
}
/**
 * Authorisation
 *
 * @generated from protobuf message api.ProjectAuthorisation
 */
export interface ProjectAuthorisation {
    /**
     * Identifier of the organisation
     *
     * @generated from protobuf field: string OrganisationID = 1 [json_name = "OrganisationID"];
     */
    OrganisationID: string;
    /**
     * Identifier of the project
     *
     * @generated from protobuf field: string ProjectID = 2 [json_name = "ProjectID"];
     */
    ProjectID: string;
    /**
     * TODO Do we need explicit flags to show if receipt / ship is allowed / forbidden ?
     * Constraints applied for reception appointment
     *
     * @generated from protobuf field: api.ProjectConstraints InConstraints = 3 [json_name = "InConstraints"];
     */
    InConstraints?: ProjectConstraints;
    /**
     * Constraints applied for expedition appointment
     *
     * @generated from protobuf field: api.ProjectConstraints OutConstraints = 4 [json_name = "OutConstraints"];
     */
    OutConstraints?: ProjectConstraints;
}
/**
 * @generated from protobuf message api.ProjectConstraints
 */
export interface ProjectConstraints {
    /**
     * Specific Segmentation constraints applicable for the project
     *
     * @generated from protobuf field: repeated api.SegmentationConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"];
     */
    SegmentationConstraints: SegmentationConstraint[];
    /**
     * Minimal notice delay to book or cancel an appointment
     *
     * @generated from protobuf field: api.Period MinNoticePeriod = 2 [json_name = "MinNoticePeriod"];
     */
    MinNoticePeriod?: Period;
    /**
     * Maximal delay to book an appointment
     *
     * @generated from protobuf field: api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"];
     */
    MaxBookingPeriod?: Period;
}
/**
 * @generated from protobuf message api.SegmentationConstraint
 */
export interface SegmentationConstraint {
    /**
     * Identifier of the Segmentation key to constraint
     *
     * @generated from protobuf field: string SegmentationID = 1 [json_name = "SegmentationID"];
     */
    SegmentationID: string;
    /**
     * If some Segmentation values are restricted, define here the identifiers to keep
     *
     * @generated from protobuf field: repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"];
     */
    RestrictedValueIDs: bigint[];
    /**
     * Set to not apply Segmentation value restriction and keep all the values
     *
     * @generated from protobuf field: bool AllValues = 3 [json_name = "AllValues"];
     */
    AllValues: boolean;
}
/**
 * @generated from protobuf message api.ActorAuthorisation
 */
export interface ActorAuthorisation {
    // TODO Do we need explicit flags to show if receipt / ship is allowed / forbidden ?

    /**
     * Constraints applied for reception appointment
     *
     * @generated from protobuf field: api.ActorConstraints InConstraints = 3 [json_name = "InConstraints"];
     */
    InConstraints?: ActorConstraints;
    /**
     * Constraints applied for expedition appointment
     *
     * @generated from protobuf field: api.ActorConstraints OutConstraints = 4 [json_name = "OutConstraints"];
     */
    OutConstraints?: ActorConstraints;
}
/**
 * @generated from protobuf message api.ActorConstraints
 */
export interface ActorConstraints {
    /**
     * Specific Segmentation constraints applicable for the project
     *
     * @generated from protobuf field: repeated api.SegmentationActorConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"];
     */
    SegmentationConstraints: SegmentationActorConstraint[];
    /**
     * Maximal delay to book an appointment
     *
     * @generated from protobuf field: api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"];
     */
    MaxBookingPeriod?: Period;
}
/**
 * TODO Need to add here all the Segmentation definition by language
 *  in order to avoid to have to retrieve the site payload to display Segmentation values
 *
 * @generated from protobuf message api.SegmentationActorConstraint
 */
export interface SegmentationActorConstraint {
    /**
     * Identifier of the Segmentation key to constraint
     *
     * @generated from protobuf field: string SegmentationID = 1 [json_name = "SegmentationID"];
     */
    SegmentationID: string;
    /**
     * If some Segmentation values are restricted, define here the identifiers to keep
     *
     * @generated from protobuf field: repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"];
     */
    RestrictedValueIDs: bigint[];
    /**
     * In case of user value choice, to restrict Segmentation values
     *
     * @generated from protobuf field: bool AllValues = 3 [json_name = "AllValues"];
     */
    AllValues: boolean;
    /**
     * Define the type of restriction applied on the Segmentation key
     *
     * @generated from protobuf field: api.SegmentationConstraintType Type = 4 [json_name = "Type"];
     */
    Type: SegmentationConstraintType;
    /**
     * In case of order attribute choice, to define the attribute path
     *
     * @generated from protobuf field: string AttributePath = 5 [json_name = "AttributePath"];
     */
    AttributePath: string;
}
/**
 * @generated from protobuf enum api.AppointmentType
 */
export enum AppointmentType {
    /**
     * @generated from protobuf enum value: APPOINTMENTTYPE_UNKNOWN = 0;
     */
    APPOINTMENTTYPE_UNKNOWN = 0,
    /**
     * @generated from protobuf enum value: APPOINTMENTTYPE_EXPEDITION = 1;
     */
    APPOINTMENTTYPE_EXPEDITION = 1,
    /**
     * @generated from protobuf enum value: APPOINTMENTTYPE_RECEPTION = 2;
     */
    APPOINTMENTTYPE_RECEPTION = 2,
    /**
     * @generated from protobuf enum value: APPOINTMENTTYPE_UNDEFINED = 3;
     */
    APPOINTMENTTYPE_UNDEFINED = 3,
    /**
     * @generated from protobuf enum value: APPOINTMENTTYPE_BOTH = 4;
     */
    APPOINTMENTTYPE_BOTH = 4
}
/**
 * @generated from protobuf enum api.PeriodUnit
 */
export enum PeriodUnit {
    /**
     * @generated from protobuf enum value: PERIODUNIT_UNDEFINED = 0;
     */
    PERIODUNIT_UNDEFINED = 0,
    /**
     * @generated from protobuf enum value: PERIODUNIT_WORK_HOUR = 1;
     */
    PERIODUNIT_WORK_HOUR = 1,
    /**
     * @generated from protobuf enum value: PERIODUNIT_WORK_DAY = 2;
     */
    PERIODUNIT_WORK_DAY = 2,
    /**
     * Google Duration class only expresses durations in seconds and nanoseconds
     * To get it in calendar days, working days, it is more complex because all year days do not have the same length...
     * Some go libraries will be required
     *
     * @generated from protobuf enum value: PERIODUNIT_CALENDAR_DAY = 3;
     */
    PERIODUNIT_CALENDAR_DAY = 3
}
/**
 * @generated from protobuf enum api.CapacityRuleScope
 */
export enum CapacityRuleScope {
    /**
     * @generated from protobuf enum value: CAPACITY_RULE_SCOPE_UNKNOWN = 0;
     */
    UNKNOWN = 0,
    /**
     * @generated from protobuf enum value: CAPACITY_RULE_SCOPE_SIMULTANEOUS = 1;
     */
    SIMULTANEOUS = 1,
    /**
     * @generated from protobuf enum value: CAPACITY_RULE_SCOPE_DAILY = 2;
     */
    DAILY = 2
}
/**
 * @generated from protobuf enum api.CarrierInformationType
 */
export enum CarrierInformationType {
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_UNKNOWN = 0;
     */
    CARRIERINFORMATIONTYPE_UNKNOWN = 0,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_SHORT_TEXT = 1;
     */
    CARRIERINFORMATIONTYPE_SHORT_TEXT = 1,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_LONG_TEXT = 2;
     */
    CARRIERINFORMATIONTYPE_LONG_TEXT = 2,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_PHONE = 3;
     */
    CARRIERINFORMATIONTYPE_PHONE = 3,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_MAIL = 4;
     */
    CARRIERINFORMATIONTYPE_MAIL = 4,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_LICENSE_NUMBER = 5;
     */
    CARRIERINFORMATIONTYPE_LICENSE_NUMBER = 5,
    /**
     * @generated from protobuf enum value: CARRIERINFORMATIONTYPE_DOCUMENT = 6;
     */
    CARRIERINFORMATIONTYPE_DOCUMENT = 6
}
/**
 * @generated from protobuf enum api.SegmentationConstraintType
 */
export enum SegmentationConstraintType {
    /**
     * @generated from protobuf enum value: SegmentationConstraintType_UNKNOWN = 0;
     */
    SegmentationConstraintType_UNKNOWN = 0,
    /**
     * @generated from protobuf enum value: SegmentationConstraintType_USER_CHOICE = 1;
     */
    SegmentationConstraintType_USER_CHOICE = 1,
    /**
     * @generated from protobuf enum value: SegmentationConstraintType_ORDER_ATTRIBUTE = 2;
     */
    SegmentationConstraintType_ORDER_ATTRIBUTE = 2,
    /**
     * @generated from protobuf enum value: SegmentationConstraintType_ENFORCED = 3;
     */
    SegmentationConstraintType_ENFORCED = 3
}
// @generated message type with reflection information, may provide speed optimized methods
class Unit$Type extends MessageType<Unit> {
    constructor() {
        super("api.Unit", [
            { no: 1, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "Labels", kind: "message", localName: "Labels", jsonName: "Labels", repeat: 1 /*RepeatType.PACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } }
        ]);
    }
    create(value?: PartialMessage<Unit>): Unit {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.UnitID = "";
        message.Labels = [];
        if (value !== undefined)
            reflectionMergePartial<Unit>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unit): Unit {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string UnitID = 1 [json_name = "UnitID"];*/ 1:
                    message.UnitID = reader.string();
                    break;
                case /* repeated api.LabelByLanguage Labels = 2 [json_name = "Labels"];*/ 2:
                    message.Labels.push(LabelByLanguage.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: Unit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string UnitID = 1 [json_name = "UnitID"]; */
        if (message.UnitID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.UnitID);
        /* repeated api.LabelByLanguage Labels = 2 [json_name = "Labels"]; */
        for (let i = 0; i < message.Labels.length; i++)
            LabelByLanguage.internalBinaryWrite(message.Labels[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 api.Unit
 */
export const Unit = new Unit$Type();
// @generated message type with reflection information, may provide speed optimized methods
class QuantityByUnit$Type extends MessageType<QuantityByUnit> {
    constructor() {
        super("api.QuantityByUnit", [
            { no: 1, name: "UnitID", kind: "message", localName: "UnitID", jsonName: "UnitID", T: () => Unit },
            { no: 2, name: "Value", kind: "scalar", localName: "Value", jsonName: "Value", T: 1 /*ScalarType.DOUBLE*/, options: { "validate.rules": { double: { gte: 0 } } } }
        ]);
    }
    create(value?: PartialMessage<QuantityByUnit>): QuantityByUnit {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Value = 0;
        if (value !== undefined)
            reflectionMergePartial<QuantityByUnit>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: QuantityByUnit): QuantityByUnit {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.Unit UnitID = 1 [json_name = "UnitID"];*/ 1:
                    message.UnitID = Unit.internalBinaryRead(reader, reader.uint32(), options, message.UnitID);
                    break;
                case /* double Value = 2 [json_name = "Value"];*/ 2:
                    message.Value = reader.double();
                    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: QuantityByUnit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.Unit UnitID = 1 [json_name = "UnitID"]; */
        if (message.UnitID)
            Unit.internalBinaryWrite(message.UnitID, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* double Value = 2 [json_name = "Value"]; */
        if (message.Value !== 0)
            writer.tag(2, WireType.Bit64).double(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 api.QuantityByUnit
 */
export const QuantityByUnit = new QuantityByUnit$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Period$Type extends MessageType<Period> {
    constructor() {
        super("api.Period", [
            { no: 1, name: "Value", kind: "scalar", localName: "Value", jsonName: "Value", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "Unit", kind: "enum", localName: "Unit", jsonName: "Unit", T: () => ["api.PeriodUnit", PeriodUnit] }
        ]);
    }
    create(value?: PartialMessage<Period>): Period {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Value = 0n;
        message.Unit = 0;
        if (value !== undefined)
            reflectionMergePartial<Period>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Period): Period {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* int64 Value = 1 [json_name = "Value"];*/ 1:
                    message.Value = reader.int64().toBigInt();
                    break;
                case /* api.PeriodUnit Unit = 2 [json_name = "Unit"];*/ 2:
                    message.Unit = reader.int32();
                    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: Period, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* int64 Value = 1 [json_name = "Value"]; */
        if (message.Value !== 0n)
            writer.tag(1, WireType.Varint).int64(message.Value);
        /* api.PeriodUnit Unit = 2 [json_name = "Unit"]; */
        if (message.Unit !== 0)
            writer.tag(2, WireType.Varint).int32(message.Unit);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.Period
 */
export const Period = new Period$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Slot$Type extends MessageType<Slot> {
    constructor() {
        super("api.Slot", [
            { no: 1, name: "StartDateTime", kind: "scalar", localName: "StartDateTime", jsonName: "StartDateTime", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T[01][0-9]|2[0-3]:[0-5][0-9]:[0-5][0-9]$" } } } },
            { no: 3, name: "DurationInSeconds", kind: "scalar", localName: "DurationInSeconds", jsonName: "DurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
        ]);
    }
    create(value?: PartialMessage<Slot>): Slot {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.StartDateTime = "";
        message.DurationInSeconds = 0n;
        if (value !== undefined)
            reflectionMergePartial<Slot>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Slot): Slot {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string StartDateTime = 1 [json_name = "StartDateTime"];*/ 1:
                    message.StartDateTime = reader.string();
                    break;
                case /* uint64 DurationInSeconds = 3 [json_name = "DurationInSeconds"];*/ 3:
                    message.DurationInSeconds = reader.uint64().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: Slot, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string StartDateTime = 1 [json_name = "StartDateTime"]; */
        if (message.StartDateTime !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.StartDateTime);
        /* uint64 DurationInSeconds = 3 [json_name = "DurationInSeconds"]; */
        if (message.DurationInSeconds !== 0n)
            writer.tag(3, WireType.Varint).uint64(message.DurationInSeconds);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.Slot
 */
export const Slot = new Slot$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Segmentation$Type extends MessageType<Segmentation> {
    constructor() {
        super("api.Segmentation", [
            { no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "SegmentationLabel", kind: "message", localName: "SegmentationLabel", jsonName: "SegmentationLabel", repeat: 1 /*RepeatType.PACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
            { no: 3, name: "Values", kind: "message", localName: "Values", jsonName: "Values", repeat: 1 /*RepeatType.PACKED*/, T: () => SegmentationValue }
        ]);
    }
    create(value?: PartialMessage<Segmentation>): Segmentation {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationID = "";
        message.SegmentationLabel = [];
        message.Values = [];
        if (value !== undefined)
            reflectionMergePartial<Segmentation>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Segmentation): Segmentation {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string SegmentationID = 1 [json_name = "SegmentationID"];*/ 1:
                    message.SegmentationID = reader.string();
                    break;
                case /* repeated api.LabelByLanguage SegmentationLabel = 2 [json_name = "SegmentationLabel"];*/ 2:
                    message.SegmentationLabel.push(LabelByLanguage.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* repeated api.SegmentationValue Values = 3 [json_name = "Values"];*/ 3:
                    message.Values.push(SegmentationValue.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: Segmentation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string SegmentationID = 1 [json_name = "SegmentationID"]; */
        if (message.SegmentationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
        /* repeated api.LabelByLanguage SegmentationLabel = 2 [json_name = "SegmentationLabel"]; */
        for (let i = 0; i < message.SegmentationLabel.length; i++)
            LabelByLanguage.internalBinaryWrite(message.SegmentationLabel[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* repeated api.SegmentationValue Values = 3 [json_name = "Values"]; */
        for (let i = 0; i < message.Values.length; i++)
            SegmentationValue.internalBinaryWrite(message.Values[i], writer.tag(3, 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 api.Segmentation
 */
export const Segmentation = new Segmentation$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SegmentationValue$Type extends MessageType<SegmentationValue> {
    constructor() {
        super("api.SegmentationValue", [
            { no: 1, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "Label", kind: "message", localName: "Label", jsonName: "Label", repeat: 1 /*RepeatType.PACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } }
        ]);
    }
    create(value?: PartialMessage<SegmentationValue>): SegmentationValue {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        message.Label = [];
        if (value !== undefined)
            reflectionMergePartial<SegmentationValue>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationValue): SegmentationValue {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string ID = 1 [json_name = "ID"];*/ 1:
                    message.ID = reader.string();
                    break;
                case /* repeated api.LabelByLanguage Label = 2 [json_name = "Label"];*/ 2:
                    message.Label.push(LabelByLanguage.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: SegmentationValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string ID = 1 [json_name = "ID"]; */
        if (message.ID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.ID);
        /* repeated api.LabelByLanguage Label = 2 [json_name = "Label"]; */
        for (let i = 0; i < message.Label.length; i++)
            LabelByLanguage.internalBinaryWrite(message.Label[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 api.SegmentationValue
 */
export const SegmentationValue = new SegmentationValue$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OpeningRule$Type extends MessageType<OpeningRule> {
    constructor() {
        super("api.OpeningRule", [
            { no: 1, name: "StartDate", kind: "scalar", localName: "StartDate", jsonName: "StartDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
            { no: 2, name: "EndDate", kind: "scalar", localName: "EndDate", jsonName: "EndDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
            { no: 3, name: "OpeningDays", kind: "message", localName: "OpeningDays", jsonName: "OpeningDays", repeat: 1 /*RepeatType.PACKED*/, T: () => OpeningDefinition, options: { "api.aggKey": "WeekDay" } },
            { no: 4, name: "CalendarID", kind: "scalar", localName: "CalendarID", jsonName: "CalendarID", T: 9 /*ScalarType.STRING*/ },
            { no: 5, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<OpeningRule>): OpeningRule {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.StartDate = "";
        message.EndDate = "";
        message.OpeningDays = [];
        message.CalendarID = "";
        message.Label = "";
        if (value !== undefined)
            reflectionMergePartial<OpeningRule>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningRule): OpeningRule {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string StartDate = 1 [json_name = "StartDate"];*/ 1:
                    message.StartDate = reader.string();
                    break;
                case /* string EndDate = 2 [json_name = "EndDate"];*/ 2:
                    message.EndDate = reader.string();
                    break;
                case /* repeated api.OpeningDefinition OpeningDays = 3 [json_name = "OpeningDays"];*/ 3:
                    message.OpeningDays.push(OpeningDefinition.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* string CalendarID = 4 [json_name = "CalendarID"];*/ 4:
                    message.CalendarID = reader.string();
                    break;
                case /* string Label = 5 [json_name = "Label"];*/ 5:
                    message.Label = 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: OpeningRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string StartDate = 1 [json_name = "StartDate"]; */
        if (message.StartDate !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.StartDate);
        /* string EndDate = 2 [json_name = "EndDate"]; */
        if (message.EndDate !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.EndDate);
        /* repeated api.OpeningDefinition OpeningDays = 3 [json_name = "OpeningDays"]; */
        for (let i = 0; i < message.OpeningDays.length; i++)
            OpeningDefinition.internalBinaryWrite(message.OpeningDays[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* string CalendarID = 4 [json_name = "CalendarID"]; */
        if (message.CalendarID !== "")
            writer.tag(4, WireType.LengthDelimited).string(message.CalendarID);
        /* string Label = 5 [json_name = "Label"]; */
        if (message.Label !== "")
            writer.tag(5, WireType.LengthDelimited).string(message.Label);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.OpeningRule
 */
export const OpeningRule = new OpeningRule$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OpeningDefinition$Type extends MessageType<OpeningDefinition> {
    constructor() {
        super("api.OpeningDefinition", [
            { no: 1, name: "WeekDay", kind: "enum", localName: "WeekDay", jsonName: "WeekDay", T: () => ["api.WeekDay", WeekDay] },
            { no: 2, name: "Definition", kind: "message", localName: "Definition", jsonName: "Definition", repeat: 1 /*RepeatType.PACKED*/, T: () => OpeningDayDefinition }
        ]);
    }
    create(value?: PartialMessage<OpeningDefinition>): OpeningDefinition {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.WeekDay = 0;
        message.Definition = [];
        if (value !== undefined)
            reflectionMergePartial<OpeningDefinition>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningDefinition): OpeningDefinition {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.WeekDay WeekDay = 1 [json_name = "WeekDay"];*/ 1:
                    message.WeekDay = reader.int32();
                    break;
                case /* repeated api.OpeningDayDefinition Definition = 2 [json_name = "Definition"];*/ 2:
                    message.Definition.push(OpeningDayDefinition.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: OpeningDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.WeekDay WeekDay = 1 [json_name = "WeekDay"]; */
        if (message.WeekDay !== 0)
            writer.tag(1, WireType.Varint).int32(message.WeekDay);
        /* repeated api.OpeningDayDefinition Definition = 2 [json_name = "Definition"]; */
        for (let i = 0; i < message.Definition.length; i++)
            OpeningDayDefinition.internalBinaryWrite(message.Definition[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 api.OpeningDefinition
 */
export const OpeningDefinition = new OpeningDefinition$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OpeningDayDefinition$Type extends MessageType<OpeningDayDefinition> {
    constructor() {
        super("api.OpeningDayDefinition", [
            { no: 2, name: "TimeRanges", kind: "message", localName: "TimeRanges", jsonName: "TimeRanges", repeat: 1 /*RepeatType.PACKED*/, T: () => TimeRange },
            { no: 3, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
            { no: 4, name: "OrderAppliance", kind: "scalar", localName: "OrderAppliance", jsonName: "OrderAppliance", T: 5 /*ScalarType.INT32*/ }
        ]);
    }
    create(value?: PartialMessage<OpeningDayDefinition>): OpeningDayDefinition {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.TimeRanges = [];
        message.OrderAppliance = 0;
        if (value !== undefined)
            reflectionMergePartial<OpeningDayDefinition>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningDayDefinition): OpeningDayDefinition {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.TimeRange TimeRanges = 2 [json_name = "TimeRanges"];*/ 2:
                    message.TimeRanges.push(TimeRange.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* api.RuleFilter Filter = 3 [json_name = "Filter"];*/ 3:
                    message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
                    break;
                case /* int32 OrderAppliance = 4 [json_name = "OrderAppliance"];*/ 4:
                    message.OrderAppliance = reader.int32();
                    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: OpeningDayDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.TimeRange TimeRanges = 2 [json_name = "TimeRanges"]; */
        for (let i = 0; i < message.TimeRanges.length; i++)
            TimeRange.internalBinaryWrite(message.TimeRanges[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* api.RuleFilter Filter = 3 [json_name = "Filter"]; */
        if (message.Filter)
            RuleFilter.internalBinaryWrite(message.Filter, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* int32 OrderAppliance = 4 [json_name = "OrderAppliance"]; */
        if (message.OrderAppliance !== 0)
            writer.tag(4, WireType.Varint).int32(message.OrderAppliance);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.OpeningDayDefinition
 */
export const OpeningDayDefinition = new OpeningDayDefinition$Type();
// @generated message type with reflection information, may provide speed optimized methods
class CapacityRule$Type extends MessageType<CapacityRule> {
    constructor() {
        super("api.CapacityRule", [
            { no: 1, name: "StartDate", kind: "scalar", localName: "StartDate", jsonName: "StartDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
            { no: 2, name: "EndDate", kind: "scalar", localName: "EndDate", jsonName: "EndDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
            { no: 5, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "Days", kind: "enum", localName: "Days", jsonName: "Days", repeat: 1 /*RepeatType.PACKED*/, T: () => ["api.WeekDay", WeekDay] },
            { no: 4, name: "Capacities", kind: "message", localName: "Capacities", jsonName: "Capacities", repeat: 1 /*RepeatType.PACKED*/, T: () => CapacityDefinition }
        ]);
    }
    create(value?: PartialMessage<CapacityRule>): CapacityRule {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.StartDate = "";
        message.EndDate = "";
        message.Label = "";
        message.Days = [];
        message.Capacities = [];
        if (value !== undefined)
            reflectionMergePartial<CapacityRule>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CapacityRule): CapacityRule {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string StartDate = 1 [json_name = "StartDate"];*/ 1:
                    message.StartDate = reader.string();
                    break;
                case /* string EndDate = 2 [json_name = "EndDate"];*/ 2:
                    message.EndDate = reader.string();
                    break;
                case /* string Label = 5 [json_name = "Label"];*/ 5:
                    message.Label = reader.string();
                    break;
                case /* repeated api.WeekDay Days = 3 [json_name = "Days"];*/ 3:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.Days.push(reader.int32());
                    else
                        message.Days.push(reader.int32());
                    break;
                case /* repeated api.CapacityDefinition Capacities = 4 [json_name = "Capacities"];*/ 4:
                    message.Capacities.push(CapacityDefinition.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: CapacityRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string StartDate = 1 [json_name = "StartDate"]; */
        if (message.StartDate !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.StartDate);
        /* string EndDate = 2 [json_name = "EndDate"]; */
        if (message.EndDate !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.EndDate);
        /* string Label = 5 [json_name = "Label"]; */
        if (message.Label !== "")
            writer.tag(5, WireType.LengthDelimited).string(message.Label);
        /* repeated api.WeekDay Days = 3 [json_name = "Days"]; */
        if (message.Days.length) {
            writer.tag(3, WireType.LengthDelimited).fork();
            for (let i = 0; i < message.Days.length; i++)
                writer.int32(message.Days[i]);
            writer.join();
        }
        /* repeated api.CapacityDefinition Capacities = 4 [json_name = "Capacities"]; */
        for (let i = 0; i < message.Capacities.length; i++)
            CapacityDefinition.internalBinaryWrite(message.Capacities[i], writer.tag(4, 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 api.CapacityRule
 */
export const CapacityRule = new CapacityRule$Type();
// @generated message type with reflection information, may provide speed optimized methods
class CapacityDefinition$Type extends MessageType<CapacityDefinition> {
    constructor() {
        super("api.CapacityDefinition", [
            { no: 1, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
            { no: 2, name: "Scope", kind: "enum", localName: "Scope", jsonName: "Scope", T: () => ["api.CapacityRuleScope", CapacityRuleScope, "CAPACITY_RULE_SCOPE_"] },
            { no: 3, name: "MaximalCapacity", kind: "scalar", localName: "MaximalCapacity", jsonName: "MaximalCapacity", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<CapacityDefinition>): CapacityDefinition {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Scope = 0;
        message.MaximalCapacity = 0n;
        message.UnitID = "";
        if (value !== undefined)
            reflectionMergePartial<CapacityDefinition>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CapacityDefinition): CapacityDefinition {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RuleFilter Filter = 1 [json_name = "Filter"];*/ 1:
                    message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
                    break;
                case /* api.CapacityRuleScope Scope = 2 [json_name = "Scope"];*/ 2:
                    message.Scope = reader.int32();
                    break;
                case /* int64 MaximalCapacity = 3 [json_name = "MaximalCapacity"];*/ 3:
                    message.MaximalCapacity = reader.int64().toBigInt();
                    break;
                case /* string UnitID = 4 [json_name = "UnitID"];*/ 4:
                    message.UnitID = 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: CapacityDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RuleFilter Filter = 1 [json_name = "Filter"]; */
        if (message.Filter)
            RuleFilter.internalBinaryWrite(message.Filter, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.CapacityRuleScope Scope = 2 [json_name = "Scope"]; */
        if (message.Scope !== 0)
            writer.tag(2, WireType.Varint).int32(message.Scope);
        /* int64 MaximalCapacity = 3 [json_name = "MaximalCapacity"]; */
        if (message.MaximalCapacity !== 0n)
            writer.tag(3, WireType.Varint).int64(message.MaximalCapacity);
        /* string UnitID = 4 [json_name = "UnitID"]; */
        if (message.UnitID !== "")
            writer.tag(4, WireType.LengthDelimited).string(message.UnitID);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.CapacityDefinition
 */
export const CapacityDefinition = new CapacityDefinition$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DurationRule$Type extends MessageType<DurationRule> {
    constructor() {
        super("api.DurationRule", [
            { no: 1, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
            { no: 2, name: "BaseDurationInSeconds", kind: "scalar", localName: "BaseDurationInSeconds", jsonName: "BaseDurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "VariableDurations", kind: "message", localName: "VariableDurations", jsonName: "VariableDurations", repeat: 1 /*RepeatType.PACKED*/, T: () => VariableDuration, options: { "api.aggKey": "UnitID" } },
            { no: 4, name: "OrderAppliance", kind: "scalar", localName: "OrderAppliance", jsonName: "OrderAppliance", T: 5 /*ScalarType.INT32*/ }
        ]);
    }
    create(value?: PartialMessage<DurationRule>): DurationRule {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.BaseDurationInSeconds = 0n;
        message.VariableDurations = [];
        message.OrderAppliance = 0;
        if (value !== undefined)
            reflectionMergePartial<DurationRule>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DurationRule): DurationRule {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RuleFilter Filter = 1 [json_name = "Filter"];*/ 1:
                    message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
                    break;
                case /* uint64 BaseDurationInSeconds = 2 [json_name = "BaseDurationInSeconds"];*/ 2:
                    message.BaseDurationInSeconds = reader.uint64().toBigInt();
                    break;
                case /* repeated api.VariableDuration VariableDurations = 3 [json_name = "VariableDurations"];*/ 3:
                    message.VariableDurations.push(VariableDuration.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* int32 OrderAppliance = 4 [json_name = "OrderAppliance"];*/ 4:
                    message.OrderAppliance = reader.int32();
                    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: DurationRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RuleFilter Filter = 1 [json_name = "Filter"]; */
        if (message.Filter)
            RuleFilter.internalBinaryWrite(message.Filter, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* uint64 BaseDurationInSeconds = 2 [json_name = "BaseDurationInSeconds"]; */
        if (message.BaseDurationInSeconds !== 0n)
            writer.tag(2, WireType.Varint).uint64(message.BaseDurationInSeconds);
        /* repeated api.VariableDuration VariableDurations = 3 [json_name = "VariableDurations"]; */
        for (let i = 0; i < message.VariableDurations.length; i++)
            VariableDuration.internalBinaryWrite(message.VariableDurations[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* int32 OrderAppliance = 4 [json_name = "OrderAppliance"]; */
        if (message.OrderAppliance !== 0)
            writer.tag(4, WireType.Varint).int32(message.OrderAppliance);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DurationRule
 */
export const DurationRule = new DurationRule$Type();
// @generated message type with reflection information, may provide speed optimized methods
class VariableDuration$Type extends MessageType<VariableDuration> {
    constructor() {
        super("api.VariableDuration", [
            { no: 1, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "DurationInSeconds", kind: "scalar", localName: "DurationInSeconds", jsonName: "DurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
        ]);
    }
    create(value?: PartialMessage<VariableDuration>): VariableDuration {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.UnitID = "";
        message.DurationInSeconds = 0n;
        if (value !== undefined)
            reflectionMergePartial<VariableDuration>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VariableDuration): VariableDuration {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string UnitID = 1 [json_name = "UnitID"];*/ 1:
                    message.UnitID = reader.string();
                    break;
                case /* uint64 DurationInSeconds = 2 [json_name = "DurationInSeconds"];*/ 2:
                    message.DurationInSeconds = reader.uint64().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: VariableDuration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string UnitID = 1 [json_name = "UnitID"]; */
        if (message.UnitID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.UnitID);
        /* uint64 DurationInSeconds = 2 [json_name = "DurationInSeconds"]; */
        if (message.DurationInSeconds !== 0n)
            writer.tag(2, WireType.Varint).uint64(message.DurationInSeconds);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.VariableDuration
 */
export const VariableDuration = new VariableDuration$Type();
// @generated message type with reflection information, may provide speed optimized methods
class RuleFilter$Type extends MessageType<RuleFilter> {
    constructor() {
        super("api.RuleFilter", [
            { no: 1, name: "Type", kind: "enum", localName: "Type", jsonName: "Type", T: () => ["api.AppointmentType", AppointmentType] },
            { no: 2, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "SegmentationKeys", kind: "message", localName: "SegmentationKeys", jsonName: "SegmentationKeys", repeat: 1 /*RepeatType.PACKED*/, T: () => SegmentationFilter }
        ]);
    }
    create(value?: PartialMessage<RuleFilter>): RuleFilter {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Type = 0;
        message.ProjectID = [];
        message.SegmentationKeys = [];
        if (value !== undefined)
            reflectionMergePartial<RuleFilter>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RuleFilter): RuleFilter {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.AppointmentType Type = 1 [json_name = "Type"];*/ 1:
                    message.Type = reader.int32();
                    break;
                case /* repeated string ProjectID = 2 [json_name = "ProjectID"];*/ 2:
                    message.ProjectID.push(reader.string());
                    break;
                case /* repeated api.SegmentationFilter SegmentationKeys = 3 [json_name = "SegmentationKeys"];*/ 3:
                    message.SegmentationKeys.push(SegmentationFilter.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: RuleFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.AppointmentType Type = 1 [json_name = "Type"]; */
        if (message.Type !== 0)
            writer.tag(1, WireType.Varint).int32(message.Type);
        /* repeated string ProjectID = 2 [json_name = "ProjectID"]; */
        for (let i = 0; i < message.ProjectID.length; i++)
            writer.tag(2, WireType.LengthDelimited).string(message.ProjectID[i]);
        /* repeated api.SegmentationFilter SegmentationKeys = 3 [json_name = "SegmentationKeys"]; */
        for (let i = 0; i < message.SegmentationKeys.length; i++)
            SegmentationFilter.internalBinaryWrite(message.SegmentationKeys[i], writer.tag(3, 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 api.RuleFilter
 */
export const RuleFilter = new RuleFilter$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SegmentationFilter$Type extends MessageType<SegmentationFilter> {
    constructor() {
        super("api.SegmentationFilter", [
            { no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "SegmentationValueIDs", kind: "scalar", localName: "SegmentationValueIDs", jsonName: "SegmentationValueIDs", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<SegmentationFilter>): SegmentationFilter {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationID = "";
        message.SegmentationValueIDs = [];
        if (value !== undefined)
            reflectionMergePartial<SegmentationFilter>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationFilter): SegmentationFilter {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string SegmentationID = 1 [json_name = "SegmentationID"];*/ 1:
                    message.SegmentationID = reader.string();
                    break;
                case /* repeated string SegmentationValueIDs = 2 [json_name = "SegmentationValueIDs"];*/ 2:
                    message.SegmentationValueIDs.push(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: SegmentationFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string SegmentationID = 1 [json_name = "SegmentationID"]; */
        if (message.SegmentationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
        /* repeated string SegmentationValueIDs = 2 [json_name = "SegmentationValueIDs"]; */
        for (let i = 0; i < message.SegmentationValueIDs.length; i++)
            writer.tag(2, WireType.LengthDelimited).string(message.SegmentationValueIDs[i]);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.SegmentationFilter
 */
export const SegmentationFilter = new SegmentationFilter$Type();
// @generated message type with reflection information, may provide speed optimized methods
class CarrierInformation$Type extends MessageType<CarrierInformation> {
    constructor() {
        super("api.CarrierInformation", [
            { no: 1, name: "CarrierInformationID", kind: "scalar", localName: "CarrierInformationID", jsonName: "CarrierInformationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "Label", kind: "message", localName: "Label", jsonName: "Label", repeat: 1 /*RepeatType.PACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
            { no: 3, name: "Type", kind: "enum", localName: "Type", jsonName: "Type", T: () => ["api.CarrierInformationType", CarrierInformationType] },
            { no: 4, name: "IsMandatory", kind: "scalar", localName: "IsMandatory", jsonName: "IsMandatory", T: 8 /*ScalarType.BOOL*/ },
            { no: 5, name: "FormatCheck", kind: "scalar", localName: "FormatCheck", jsonName: "FormatCheck", T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<CarrierInformation>): CarrierInformation {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.CarrierInformationID = "";
        message.Label = [];
        message.Type = 0;
        message.IsMandatory = false;
        message.FormatCheck = false;
        if (value !== undefined)
            reflectionMergePartial<CarrierInformation>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CarrierInformation): CarrierInformation {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string CarrierInformationID = 1 [json_name = "CarrierInformationID"];*/ 1:
                    message.CarrierInformationID = reader.string();
                    break;
                case /* repeated api.LabelByLanguage Label = 2 [json_name = "Label"];*/ 2:
                    message.Label.push(LabelByLanguage.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* api.CarrierInformationType Type = 3 [json_name = "Type"];*/ 3:
                    message.Type = reader.int32();
                    break;
                case /* bool IsMandatory = 4 [json_name = "IsMandatory"];*/ 4:
                    message.IsMandatory = reader.bool();
                    break;
                case /* bool FormatCheck = 5 [json_name = "FormatCheck"];*/ 5:
                    message.FormatCheck = reader.bool();
                    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: CarrierInformation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string CarrierInformationID = 1 [json_name = "CarrierInformationID"]; */
        if (message.CarrierInformationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.CarrierInformationID);
        /* repeated api.LabelByLanguage Label = 2 [json_name = "Label"]; */
        for (let i = 0; i < message.Label.length; i++)
            LabelByLanguage.internalBinaryWrite(message.Label[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* api.CarrierInformationType Type = 3 [json_name = "Type"]; */
        if (message.Type !== 0)
            writer.tag(3, WireType.Varint).int32(message.Type);
        /* bool IsMandatory = 4 [json_name = "IsMandatory"]; */
        if (message.IsMandatory !== false)
            writer.tag(4, WireType.Varint).bool(message.IsMandatory);
        /* bool FormatCheck = 5 [json_name = "FormatCheck"]; */
        if (message.FormatCheck !== false)
            writer.tag(5, WireType.Varint).bool(message.FormatCheck);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.CarrierInformation
 */
export const CarrierInformation = new CarrierInformation$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Document$Type extends MessageType<Document> {
    constructor() {
        super("api.Document", [
            { no: 1, name: "DocID", kind: "scalar", localName: "DocID", jsonName: "DocID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "DocsByLang", kind: "message", localName: "DocsByLang", jsonName: "DocsByLang", repeat: 1 /*RepeatType.PACKED*/, T: () => DocumentByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
            { no: 3, name: "AckRequired", kind: "scalar", localName: "AckRequired", jsonName: "AckRequired", T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<Document>): Document {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.DocID = "";
        message.DocsByLang = [];
        message.AckRequired = false;
        if (value !== undefined)
            reflectionMergePartial<Document>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Document): Document {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string DocID = 1 [json_name = "DocID"];*/ 1:
                    message.DocID = reader.string();
                    break;
                case /* repeated api.DocumentByLanguage DocsByLang = 2 [json_name = "DocsByLang"];*/ 2:
                    message.DocsByLang.push(DocumentByLanguage.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* bool AckRequired = 3 [json_name = "AckRequired"];*/ 3:
                    message.AckRequired = reader.bool();
                    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: Document, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string DocID = 1 [json_name = "DocID"]; */
        if (message.DocID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.DocID);
        /* repeated api.DocumentByLanguage DocsByLang = 2 [json_name = "DocsByLang"]; */
        for (let i = 0; i < message.DocsByLang.length; i++)
            DocumentByLanguage.internalBinaryWrite(message.DocsByLang[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* bool AckRequired = 3 [json_name = "AckRequired"]; */
        if (message.AckRequired !== false)
            writer.tag(3, WireType.Varint).bool(message.AckRequired);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.Document
 */
export const Document = new Document$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DocumentByLanguage$Type extends MessageType<DocumentByLanguage> {
    constructor() {
        super("api.DocumentByLanguage", [
            { no: 1, name: "Name", kind: "scalar", localName: "Name", jsonName: "Name", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "Doc", kind: "scalar", localName: "Doc", jsonName: "Doc", T: 12 /*ScalarType.BYTES*/ },
            { no: 3, name: "LanguageCodeISO6391", kind: "scalar", localName: "LanguageCodeISO6391", jsonName: "LanguageCodeISO6391", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "2", maxLen: "3", languageIso639: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "<a href='https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes'>ISO 639 code</a> message language", example: "\"en\"" } } }
        ]);
    }
    create(value?: PartialMessage<DocumentByLanguage>): DocumentByLanguage {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Name = "";
        message.Doc = new Uint8Array(0);
        message.LanguageCodeISO6391 = "";
        if (value !== undefined)
            reflectionMergePartial<DocumentByLanguage>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DocumentByLanguage): DocumentByLanguage {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string Name = 1 [json_name = "Name"];*/ 1:
                    message.Name = reader.string();
                    break;
                case /* bytes Doc = 2 [json_name = "Doc"];*/ 2:
                    message.Doc = reader.bytes();
                    break;
                case /* string LanguageCodeISO6391 = 3 [json_name = "LanguageCodeISO6391"];*/ 3:
                    message.LanguageCodeISO6391 = 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: DocumentByLanguage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string Name = 1 [json_name = "Name"]; */
        if (message.Name !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.Name);
        /* bytes Doc = 2 [json_name = "Doc"]; */
        if (message.Doc.length)
            writer.tag(2, WireType.LengthDelimited).bytes(message.Doc);
        /* string LanguageCodeISO6391 = 3 [json_name = "LanguageCodeISO6391"]; */
        if (message.LanguageCodeISO6391 !== "")
            writer.tag(3, WireType.LengthDelimited).string(message.LanguageCodeISO6391);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DocumentByLanguage
 */
export const DocumentByLanguage = new DocumentByLanguage$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ProjectAuthorisation$Type extends MessageType<ProjectAuthorisation> {
    constructor() {
        super("api.ProjectAuthorisation", [
            { no: 1, name: "OrganisationID", kind: "scalar", localName: "OrganisationID", jsonName: "OrganisationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "InConstraints", kind: "message", localName: "InConstraints", jsonName: "InConstraints", T: () => ProjectConstraints },
            { no: 4, name: "OutConstraints", kind: "message", localName: "OutConstraints", jsonName: "OutConstraints", T: () => ProjectConstraints }
        ]);
    }
    create(value?: PartialMessage<ProjectAuthorisation>): ProjectAuthorisation {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.OrganisationID = "";
        message.ProjectID = "";
        if (value !== undefined)
            reflectionMergePartial<ProjectAuthorisation>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ProjectAuthorisation): ProjectAuthorisation {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string OrganisationID = 1 [json_name = "OrganisationID"];*/ 1:
                    message.OrganisationID = reader.string();
                    break;
                case /* string ProjectID = 2 [json_name = "ProjectID"];*/ 2:
                    message.ProjectID = reader.string();
                    break;
                case /* api.ProjectConstraints InConstraints = 3 [json_name = "InConstraints"];*/ 3:
                    message.InConstraints = ProjectConstraints.internalBinaryRead(reader, reader.uint32(), options, message.InConstraints);
                    break;
                case /* api.ProjectConstraints OutConstraints = 4 [json_name = "OutConstraints"];*/ 4:
                    message.OutConstraints = ProjectConstraints.internalBinaryRead(reader, reader.uint32(), options, message.OutConstraints);
                    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: ProjectAuthorisation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string OrganisationID = 1 [json_name = "OrganisationID"]; */
        if (message.OrganisationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.OrganisationID);
        /* string ProjectID = 2 [json_name = "ProjectID"]; */
        if (message.ProjectID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ProjectID);
        /* api.ProjectConstraints InConstraints = 3 [json_name = "InConstraints"]; */
        if (message.InConstraints)
            ProjectConstraints.internalBinaryWrite(message.InConstraints, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* api.ProjectConstraints OutConstraints = 4 [json_name = "OutConstraints"]; */
        if (message.OutConstraints)
            ProjectConstraints.internalBinaryWrite(message.OutConstraints, writer.tag(4, 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 api.ProjectAuthorisation
 */
export const ProjectAuthorisation = new ProjectAuthorisation$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ProjectConstraints$Type extends MessageType<ProjectConstraints> {
    constructor() {
        super("api.ProjectConstraints", [
            { no: 1, name: "SegmentationConstraints", kind: "message", localName: "SegmentationConstraints", jsonName: "SegmentationConstraints", repeat: 1 /*RepeatType.PACKED*/, T: () => SegmentationConstraint, options: { "api.aggKey": "SegmentationID" } },
            { no: 2, name: "MinNoticePeriod", kind: "message", localName: "MinNoticePeriod", jsonName: "MinNoticePeriod", T: () => Period },
            { no: 3, name: "MaxBookingPeriod", kind: "message", localName: "MaxBookingPeriod", jsonName: "MaxBookingPeriod", T: () => Period }
        ]);
    }
    create(value?: PartialMessage<ProjectConstraints>): ProjectConstraints {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationConstraints = [];
        if (value !== undefined)
            reflectionMergePartial<ProjectConstraints>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ProjectConstraints): ProjectConstraints {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.SegmentationConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"];*/ 1:
                    message.SegmentationConstraints.push(SegmentationConstraint.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* api.Period MinNoticePeriod = 2 [json_name = "MinNoticePeriod"];*/ 2:
                    message.MinNoticePeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MinNoticePeriod);
                    break;
                case /* api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"];*/ 3:
                    message.MaxBookingPeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MaxBookingPeriod);
                    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: ProjectConstraints, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.SegmentationConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"]; */
        for (let i = 0; i < message.SegmentationConstraints.length; i++)
            SegmentationConstraint.internalBinaryWrite(message.SegmentationConstraints[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.Period MinNoticePeriod = 2 [json_name = "MinNoticePeriod"]; */
        if (message.MinNoticePeriod)
            Period.internalBinaryWrite(message.MinNoticePeriod, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"]; */
        if (message.MaxBookingPeriod)
            Period.internalBinaryWrite(message.MaxBookingPeriod, writer.tag(3, 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 api.ProjectConstraints
 */
export const ProjectConstraints = new ProjectConstraints$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SegmentationConstraint$Type extends MessageType<SegmentationConstraint> {
    constructor() {
        super("api.SegmentationConstraint", [
            { no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "RestrictedValueIDs", kind: "scalar", localName: "RestrictedValueIDs", jsonName: "RestrictedValueIDs", repeat: 1 /*RepeatType.PACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "AllValues", kind: "scalar", localName: "AllValues", jsonName: "AllValues", T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<SegmentationConstraint>): SegmentationConstraint {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationID = "";
        message.RestrictedValueIDs = [];
        message.AllValues = false;
        if (value !== undefined)
            reflectionMergePartial<SegmentationConstraint>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationConstraint): SegmentationConstraint {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string SegmentationID = 1 [json_name = "SegmentationID"];*/ 1:
                    message.SegmentationID = reader.string();
                    break;
                case /* repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"];*/ 2:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.RestrictedValueIDs.push(reader.int64().toBigInt());
                    else
                        message.RestrictedValueIDs.push(reader.int64().toBigInt());
                    break;
                case /* bool AllValues = 3 [json_name = "AllValues"];*/ 3:
                    message.AllValues = reader.bool();
                    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: SegmentationConstraint, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string SegmentationID = 1 [json_name = "SegmentationID"]; */
        if (message.SegmentationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
        /* repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"]; */
        if (message.RestrictedValueIDs.length) {
            writer.tag(2, WireType.LengthDelimited).fork();
            for (let i = 0; i < message.RestrictedValueIDs.length; i++)
                writer.int64(message.RestrictedValueIDs[i]);
            writer.join();
        }
        /* bool AllValues = 3 [json_name = "AllValues"]; */
        if (message.AllValues !== false)
            writer.tag(3, WireType.Varint).bool(message.AllValues);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.SegmentationConstraint
 */
export const SegmentationConstraint = new SegmentationConstraint$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorAuthorisation$Type extends MessageType<ActorAuthorisation> {
    constructor() {
        super("api.ActorAuthorisation", [
            { no: 3, name: "InConstraints", kind: "message", localName: "InConstraints", jsonName: "InConstraints", T: () => ActorConstraints },
            { no: 4, name: "OutConstraints", kind: "message", localName: "OutConstraints", jsonName: "OutConstraints", T: () => ActorConstraints }
        ]);
    }
    create(value?: PartialMessage<ActorAuthorisation>): ActorAuthorisation {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<ActorAuthorisation>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorAuthorisation): ActorAuthorisation {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.ActorConstraints InConstraints = 3 [json_name = "InConstraints"];*/ 3:
                    message.InConstraints = ActorConstraints.internalBinaryRead(reader, reader.uint32(), options, message.InConstraints);
                    break;
                case /* api.ActorConstraints OutConstraints = 4 [json_name = "OutConstraints"];*/ 4:
                    message.OutConstraints = ActorConstraints.internalBinaryRead(reader, reader.uint32(), options, message.OutConstraints);
                    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: ActorAuthorisation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.ActorConstraints InConstraints = 3 [json_name = "InConstraints"]; */
        if (message.InConstraints)
            ActorConstraints.internalBinaryWrite(message.InConstraints, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* api.ActorConstraints OutConstraints = 4 [json_name = "OutConstraints"]; */
        if (message.OutConstraints)
            ActorConstraints.internalBinaryWrite(message.OutConstraints, writer.tag(4, 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 api.ActorAuthorisation
 */
export const ActorAuthorisation = new ActorAuthorisation$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorConstraints$Type extends MessageType<ActorConstraints> {
    constructor() {
        super("api.ActorConstraints", [
            { no: 1, name: "SegmentationConstraints", kind: "message", localName: "SegmentationConstraints", jsonName: "SegmentationConstraints", repeat: 1 /*RepeatType.PACKED*/, T: () => SegmentationActorConstraint, options: { "api.aggKey": "SegmentationID" } },
            { no: 3, name: "MaxBookingPeriod", kind: "message", localName: "MaxBookingPeriod", jsonName: "MaxBookingPeriod", T: () => Period }
        ]);
    }
    create(value?: PartialMessage<ActorConstraints>): ActorConstraints {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationConstraints = [];
        if (value !== undefined)
            reflectionMergePartial<ActorConstraints>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorConstraints): ActorConstraints {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.SegmentationActorConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"];*/ 1:
                    message.SegmentationConstraints.push(SegmentationActorConstraint.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"];*/ 3:
                    message.MaxBookingPeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MaxBookingPeriod);
                    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: ActorConstraints, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.SegmentationActorConstraint SegmentationConstraints = 1 [json_name = "SegmentationConstraints"]; */
        for (let i = 0; i < message.SegmentationConstraints.length; i++)
            SegmentationActorConstraint.internalBinaryWrite(message.SegmentationConstraints[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.Period MaxBookingPeriod = 3 [json_name = "MaxBookingPeriod"]; */
        if (message.MaxBookingPeriod)
            Period.internalBinaryWrite(message.MaxBookingPeriod, writer.tag(3, 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 api.ActorConstraints
 */
export const ActorConstraints = new ActorConstraints$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SegmentationActorConstraint$Type extends MessageType<SegmentationActorConstraint> {
    constructor() {
        super("api.SegmentationActorConstraint", [
            { no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "RestrictedValueIDs", kind: "scalar", localName: "RestrictedValueIDs", jsonName: "RestrictedValueIDs", repeat: 1 /*RepeatType.PACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "AllValues", kind: "scalar", localName: "AllValues", jsonName: "AllValues", T: 8 /*ScalarType.BOOL*/ },
            { no: 4, name: "Type", kind: "enum", localName: "Type", jsonName: "Type", T: () => ["api.SegmentationConstraintType", SegmentationConstraintType] },
            { no: 5, name: "AttributePath", kind: "scalar", localName: "AttributePath", jsonName: "AttributePath", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<SegmentationActorConstraint>): SegmentationActorConstraint {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.SegmentationID = "";
        message.RestrictedValueIDs = [];
        message.AllValues = false;
        message.Type = 0;
        message.AttributePath = "";
        if (value !== undefined)
            reflectionMergePartial<SegmentationActorConstraint>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationActorConstraint): SegmentationActorConstraint {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string SegmentationID = 1 [json_name = "SegmentationID"];*/ 1:
                    message.SegmentationID = reader.string();
                    break;
                case /* repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"];*/ 2:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.RestrictedValueIDs.push(reader.int64().toBigInt());
                    else
                        message.RestrictedValueIDs.push(reader.int64().toBigInt());
                    break;
                case /* bool AllValues = 3 [json_name = "AllValues"];*/ 3:
                    message.AllValues = reader.bool();
                    break;
                case /* api.SegmentationConstraintType Type = 4 [json_name = "Type"];*/ 4:
                    message.Type = reader.int32();
                    break;
                case /* string AttributePath = 5 [json_name = "AttributePath"];*/ 5:
                    message.AttributePath = 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: SegmentationActorConstraint, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string SegmentationID = 1 [json_name = "SegmentationID"]; */
        if (message.SegmentationID !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
        /* repeated int64 RestrictedValueIDs = 2 [json_name = "RestrictedValueIDs"]; */
        if (message.RestrictedValueIDs.length) {
            writer.tag(2, WireType.LengthDelimited).fork();
            for (let i = 0; i < message.RestrictedValueIDs.length; i++)
                writer.int64(message.RestrictedValueIDs[i]);
            writer.join();
        }
        /* bool AllValues = 3 [json_name = "AllValues"]; */
        if (message.AllValues !== false)
            writer.tag(3, WireType.Varint).bool(message.AllValues);
        /* api.SegmentationConstraintType Type = 4 [json_name = "Type"]; */
        if (message.Type !== 0)
            writer.tag(4, WireType.Varint).int32(message.Type);
        /* string AttributePath = 5 [json_name = "AttributePath"]; */
        if (message.AttributePath !== "")
            writer.tag(5, WireType.LengthDelimited).string(message.AttributePath);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.SegmentationActorConstraint
 */
export const SegmentationActorConstraint = new SegmentationActorConstraint$Type();