npm-core-sdk/ruleEngine_services.ts

// @generated by protobuf-ts 2.11.1 with parameter use_proto_field_name,keep_enum_prefix
// @generated from protobuf file "ruleEngine_services.proto" (package "api", syntax proto3)
// tslint:disable
import { ServiceType } from "@protobuf-ts/runtime-rpc";
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 { MappingTable } from "./ruleEngine_model";
import { MappingTableEntry } from "./ruleEngine_model";
import { MappingTableOutputField } from "./ruleEngine_model";
import { MappingTableInputDescription } from "./ruleEngine_model";
import { Computation } from "./ruleEngine_model";
import { ComputationCustomFunction } from "./ruleEngine_model";
import { ComputationStatusDuration } from "./ruleEngine_model";
import { ComputationDueDate } from "./ruleEngine_model";
import { ComputationDateDuration } from "./ruleEngine_model";
import { EngineRuleTriggerType } from "./ruleEngine_model";
import { EngineRule } from "./ruleEngine_model";
import { EngineRuleAction } from "./ruleEngine_model";
import { EngineRuleCondition } from "./ruleEngine_model";
import { EngineRuleMilestoneTrigger } from "./ruleEngine_model";
import { EngineRuleEventTrigger } from "./ruleEngine_model";
import { EngineRuleScheduledTrigger } from "./ruleEngine_model";
import { EntityType } from "./shared";
import { EngineRuleValidityType } from "./ruleEngine_model";
import { RequestProjectHeader } from "./shared";
// ========== REQUESTS & RESPONSE MESSAGES ==========

/**
 * Put
 *
 * @generated from protobuf message api.PutEngineRuleRequest
 */
export interface PutEngineRuleRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string Code = 10
     */
    Code: string; // Unique code for the rule, e.g. "ApplyFreeShipping". Used as the identifier: an existing rule with the same code will be updated.
    /**
     * @generated from protobuf field: string Label = 20
     */
    Label: string; // Human-readable label of the rule's purpose
    /**
     * @generated from protobuf field: api.EngineRuleValidityType ValidityType = 30
     */
    ValidityType: EngineRuleValidityType;
    /**
     * @generated from protobuf field: string ValidFrom = 31
     */
    ValidFrom: string; // optional start date for the rule's validity, only if ValidityType = DATE_RANGE
    /**
     * @generated from protobuf field: string ValidUntil = 32
     */
    ValidUntil: string; // optional end date for the rule's validity, only if ValidityType = DATE_RANGE
    /**
     * @generated from protobuf field: api.EntityType Entity = 40
     */
    Entity: EntityType; // Entity type this rule applies to (Order, HandlingUnit, etc.)
    /**
     * What causes the rule to be evaluated
     *
     * @generated from protobuf oneof: Trigger
     */
    Trigger: {
        oneofKind: "ScheduledTrigger";
        /**
         * @generated from protobuf field: api.EngineRuleScheduledTrigger ScheduledTrigger = 50
         */
        ScheduledTrigger: EngineRuleScheduledTrigger; // triggered on a schedule defined by a partial RRule model
    } | {
        oneofKind: "EventTrigger";
        /**
         * @generated from protobuf field: api.EngineRuleEventTrigger EventTrigger = 51
         */
        EventTrigger: EngineRuleEventTrigger; // triggered when the entity is created, deleted, or changes status
    } | {
        oneofKind: "MilestoneTrigger";
        /**
         * @generated from protobuf field: api.EngineRuleMilestoneTrigger MilestoneTrigger = 52
         */
        MilestoneTrigger: EngineRuleMilestoneTrigger; // triggered when a logistics milestone is reached
    } | {
        oneofKind: undefined;
    };
    /**
     * @generated from protobuf field: repeated api.EngineRuleCondition Conditions = 60
     */
    Conditions: EngineRuleCondition[]; // All conditions evaluated with AND semantics; no conditions = unconditional trigger
    /**
     * @generated from protobuf field: repeated api.EngineRuleAction Actions = 70
     */
    Actions: EngineRuleAction[]; // Actions to execute when the rule is triggered and conditions are met
    /**
     * @generated from protobuf field: bool IsActive = 80
     */
    IsActive: boolean; // whether the rule is currently active, independent of its ValidityType and ValidFrom/ValidUntil dates
}
/**
 * @generated from protobuf message api.PutEngineRuleResponse
 */
export interface PutEngineRuleResponse {
    /**
     * @generated from protobuf field: api.EngineRule EngineRule = 1
     */
    EngineRule?: EngineRule;
}
/**
 * Get
 *
 * @generated from protobuf message api.GetEngineRuleRequest
 */
export interface GetEngineRuleRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string Code = 2
     */
    Code: string;
}
/**
 * @generated from protobuf message api.GetEngineRuleResponse
 */
export interface GetEngineRuleResponse {
    /**
     * @generated from protobuf field: api.EngineRule EngineRule = 1
     */
    EngineRule?: EngineRule;
}
/**
 * List
 *
 * @generated from protobuf message api.ListEngineRuleRequest
 */
export interface ListEngineRuleRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: api.EntityType Entity = 2
     */
    Entity: EntityType; // Optional filter: only return rules applying to this entity type
    /**
     * @generated from protobuf field: api.EngineRuleTriggerType TriggerType = 3
     */
    TriggerType: EngineRuleTriggerType; // Optional filter: only return rules with this trigger type
    /**
     * @generated from protobuf field: bool IsCurrentlyValid = 4
     */
    IsCurrentlyValid: boolean; // Optional filter: if true, only return rules whose validity period (ValidityType/ValidFrom/ValidUntil) currently includes now and whose IsActive = true. false returns all rules regardless of validity period or IsActive status.
}
/**
 * @generated from protobuf message api.ListEngineRuleResponse
 */
export interface ListEngineRuleResponse {
    /**
     * @generated from protobuf field: repeated api.EngineRule EngineRules = 1
     */
    EngineRules: EngineRule[];
    /**
     * @generated from protobuf field: int64 DebugUntil = 2
     */
    DebugUntil: bigint; // Unix timestamp (seconds) until which debug mode is currently active for the project, if any; 0 if debug mode is not active
}
/**
 * Delete
 *
 * @generated from protobuf message api.DeleteEngineRuleRequest
 */
export interface DeleteEngineRuleRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string Code = 2
     */
    Code: string;
}
/**
 * @generated from protobuf message api.DeleteEngineRuleResponse
 */
export interface DeleteEngineRuleResponse {
}
/**
 * ToggleDebugOn
 *
 * @generated from protobuf message api.ToggleDebugOnRequest
 */
export interface ToggleDebugOnRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
}
/**
 * @generated from protobuf message api.ToggleDebugOnResponse
 */
export interface ToggleDebugOnResponse {
    /**
     * @generated from protobuf field: int64 DebugUntil = 1
     */
    DebugUntil: bigint; // Unix timestamp (seconds) until which debug mode will remain active for the project
}
// ========== REQUESTS & RESPONSE MESSAGES ==========

/**
 * Put
 *
 * @generated from protobuf message api.PutComputationRequest
 */
export interface PutComputationRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string; // If provided, updates the computation with this ID; if omitted, a new computation is created.
    /**
     * @generated from protobuf field: string Label = 20
     */
    Label: string; // Human-readable label for the computation, e.g. "Compute Discount"
    /**
     * @generated from protobuf field: api.EntityType Entity = 30
     */
    Entity: EntityType; // Entity type this computation applies to (Order, HandlingUnit, etc.)
    /**
     * The computation strategy to apply
     *
     * @generated from protobuf oneof: Type
     */
    Type: {
        oneofKind: "DateDuration";
        /**
         * @generated from protobuf field: api.ComputationDateDuration DateDuration = 40
         */
        DateDuration: ComputationDateDuration; // computes the duration between two date fields
    } | {
        oneofKind: "DueDate";
        /**
         * @generated from protobuf field: api.ComputationDueDate DueDate = 41
         */
        DueDate: ComputationDueDate; // computes a due date from a reference date and a duration
    } | {
        oneofKind: "StatusDuration";
        /**
         * @generated from protobuf field: api.ComputationStatusDuration StatusDuration = 42
         */
        StatusDuration: ComputationStatusDuration; // computes the cumulated duration spent in a set of statuses
    } | {
        oneofKind: "CustomFunction";
        /**
         * @generated from protobuf field: api.ComputationCustomFunction CustomFunction = 43
         */
        CustomFunction: ComputationCustomFunction; // applies an arithmetic operator between two fields
    } | {
        oneofKind: undefined;
    };
}
/**
 * @generated from protobuf message api.PutComputationResponse
 */
export interface PutComputationResponse {
    /**
     * @generated from protobuf field: api.Computation Computation = 1
     */
    Computation?: Computation;
}
/**
 * Get
 *
 * @generated from protobuf message api.GetComputationRequest
 */
export interface GetComputationRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string;
}
/**
 * @generated from protobuf message api.GetComputationResponse
 */
export interface GetComputationResponse {
    /**
     * @generated from protobuf field: api.Computation Computation = 1
     */
    Computation?: Computation;
}
/**
 * List
 *
 * @generated from protobuf message api.ListComputationRequest
 */
export interface ListComputationRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: api.EntityType Entity = 2
     */
    Entity: EntityType; // Optional filter: only return computations applying to this entity type
}
/**
 * @generated from protobuf message api.ListComputationResponse
 */
export interface ListComputationResponse {
    /**
     * @generated from protobuf field: repeated api.Computation Computations = 1
     */
    Computations: Computation[];
}
/**
 * Delete
 *
 * @generated from protobuf message api.DeleteComputationRequest
 */
export interface DeleteComputationRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string;
}
/**
 * @generated from protobuf message api.DeleteComputationResponse
 */
export interface DeleteComputationResponse {
}
// ========== REQUESTS & RESPONSE MESSAGES ==========

/**
 * Put
 *
 * @generated from protobuf message api.PutMappingTableRequest
 */
export interface PutMappingTableRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string; // If provided, updates the mapping table with this ID; if omitted, a new mapping table is created.
    /**
     * @generated from protobuf field: string Label = 3
     */
    Label: string; // Human-readable label for the mapping table, e.g. "Shipping Cost by Priority"
    /**
     * @generated from protobuf field: api.EntityType Entity = 4
     */
    Entity: EntityType; // Entity type this mapping applies to (Order, HandlingUnit, etc.)
    /**
     * @generated from protobuf field: repeated api.MappingTableInputDescription InputFields = 5
     */
    InputFields: MappingTableInputDescription[]; // declarative schema: fields the table reads from the entity, e.g. ["Order.Priority", "Order.DestinationZone"]; Entries only reference InputFields listed here
    /**
     * @generated from protobuf field: api.MappingTableOutputField OutputField = 6
     */
    OutputField?: MappingTableOutputField; // field resulting from the lookup, e.g. "Shipping cost"
    /**
     * @generated from protobuf field: repeated api.MappingTableEntry Entries = 7
     */
    Entries: MappingTableEntry[]; // mapping entries; must contain at least one entry
}
/**
 * @generated from protobuf message api.PutMappingTableResponse
 */
export interface PutMappingTableResponse {
    /**
     * @generated from protobuf field: api.MappingTable MappingTable = 1
     */
    MappingTable?: MappingTable;
}
/**
 * Get
 *
 * @generated from protobuf message api.GetMappingTableRequest
 */
export interface GetMappingTableRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string;
}
/**
 * @generated from protobuf message api.GetMappingTableResponse
 */
export interface GetMappingTableResponse {
    /**
     * @generated from protobuf field: api.MappingTable MappingTable = 1
     */
    MappingTable?: MappingTable;
}
/**
 * List
 *
 * @generated from protobuf message api.ListMappingTableRequest
 */
export interface ListMappingTableRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: api.EntityType Entity = 2
     */
    Entity: EntityType; // Optional filter: only return mapping tables applying to this entity type
}
/**
 * @generated from protobuf message api.ListMappingTableResponse
 */
export interface ListMappingTableResponse {
    /**
     * @generated from protobuf field: repeated api.MappingTable MappingTables = 1
     */
    MappingTables: MappingTable[];
}
/**
 * Delete
 *
 * @generated from protobuf message api.DeleteMappingTableRequest
 */
export interface DeleteMappingTableRequest {
    /**
     * @generated from protobuf field: api.RequestProjectHeader Header = 1
     */
    Header?: RequestProjectHeader;
    /**
     * @generated from protobuf field: string ID = 2
     */
    ID: string;
}
/**
 * @generated from protobuf message api.DeleteMappingTableResponse
 */
export interface DeleteMappingTableResponse {
}
// @generated message type with reflection information, may provide speed optimized methods
class PutEngineRuleRequest$Type extends MessageType<PutEngineRuleRequest> {
    constructor() {
        super("api.PutEngineRuleRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 10, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { pattern: "^[A-Za-z0-9_]+$" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[A-Za-z0-9_]+$" } } },
            { no: 20, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ },
            { no: 30, name: "ValidityType", kind: "enum", localName: "ValidityType", jsonName: "ValidityType", T: () => ["api.EngineRuleValidityType", EngineRuleValidityType], options: { "n1validate.rules": { enum: { definedOnly: true, notIn: [0] } } } },
            { no: 31, name: "ValidFrom", kind: "scalar", localName: "ValidFrom", jsonName: "ValidFrom", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { dateIso8601: true, ignoreEmpty: true } } } },
            { no: 32, name: "ValidUntil", kind: "scalar", localName: "ValidUntil", jsonName: "ValidUntil", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { dateIso8601: true, ignoreEmpty: true } } } },
            { no: 40, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType] },
            { no: 50, name: "ScheduledTrigger", kind: "message", localName: "ScheduledTrigger", jsonName: "ScheduledTrigger", oneof: "Trigger", T: () => EngineRuleScheduledTrigger },
            { no: 51, name: "EventTrigger", kind: "message", localName: "EventTrigger", jsonName: "EventTrigger", oneof: "Trigger", T: () => EngineRuleEventTrigger },
            { no: 52, name: "MilestoneTrigger", kind: "message", localName: "MilestoneTrigger", jsonName: "MilestoneTrigger", oneof: "Trigger", T: () => EngineRuleMilestoneTrigger },
            { no: 60, name: "Conditions", kind: "message", localName: "Conditions", jsonName: "Conditions", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EngineRuleCondition },
            { no: 70, name: "Actions", kind: "message", localName: "Actions", jsonName: "Actions", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EngineRuleAction, options: { "n1validate.rules": { repeated: { minItems: "1" } } } },
            { no: 80, name: "IsActive", kind: "scalar", localName: "IsActive", jsonName: "IsActive", T: 8 /*ScalarType.BOOL*/ }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code", "Actions", "Trigger"] } } });
    }
    create(value?: PartialMessage<PutEngineRuleRequest>): PutEngineRuleRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Code = "";
        message.Label = "";
        message.ValidityType = 0;
        message.ValidFrom = "";
        message.ValidUntil = "";
        message.Entity = 0;
        message.Trigger = { oneofKind: undefined };
        message.Conditions = [];
        message.Actions = [];
        message.IsActive = false;
        if (value !== undefined)
            reflectionMergePartial<PutEngineRuleRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutEngineRuleRequest): PutEngineRuleRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string Code */ 10:
                    message.Code = reader.string();
                    break;
                case /* string Label */ 20:
                    message.Label = reader.string();
                    break;
                case /* api.EngineRuleValidityType ValidityType */ 30:
                    message.ValidityType = reader.int32();
                    break;
                case /* string ValidFrom */ 31:
                    message.ValidFrom = reader.string();
                    break;
                case /* string ValidUntil */ 32:
                    message.ValidUntil = reader.string();
                    break;
                case /* api.EntityType Entity */ 40:
                    message.Entity = reader.int32();
                    break;
                case /* api.EngineRuleScheduledTrigger ScheduledTrigger */ 50:
                    message.Trigger = {
                        oneofKind: "ScheduledTrigger",
                        ScheduledTrigger: EngineRuleScheduledTrigger.internalBinaryRead(reader, reader.uint32(), options, (message.Trigger as any).ScheduledTrigger)
                    };
                    break;
                case /* api.EngineRuleEventTrigger EventTrigger */ 51:
                    message.Trigger = {
                        oneofKind: "EventTrigger",
                        EventTrigger: EngineRuleEventTrigger.internalBinaryRead(reader, reader.uint32(), options, (message.Trigger as any).EventTrigger)
                    };
                    break;
                case /* api.EngineRuleMilestoneTrigger MilestoneTrigger */ 52:
                    message.Trigger = {
                        oneofKind: "MilestoneTrigger",
                        MilestoneTrigger: EngineRuleMilestoneTrigger.internalBinaryRead(reader, reader.uint32(), options, (message.Trigger as any).MilestoneTrigger)
                    };
                    break;
                case /* repeated api.EngineRuleCondition Conditions */ 60:
                    message.Conditions.push(EngineRuleCondition.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* repeated api.EngineRuleAction Actions */ 70:
                    message.Actions.push(EngineRuleAction.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* bool IsActive */ 80:
                    message.IsActive = 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: PutEngineRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string Code = 10; */
        if (message.Code !== "")
            writer.tag(10, WireType.LengthDelimited).string(message.Code);
        /* string Label = 20; */
        if (message.Label !== "")
            writer.tag(20, WireType.LengthDelimited).string(message.Label);
        /* api.EngineRuleValidityType ValidityType = 30; */
        if (message.ValidityType !== 0)
            writer.tag(30, WireType.Varint).int32(message.ValidityType);
        /* string ValidFrom = 31; */
        if (message.ValidFrom !== "")
            writer.tag(31, WireType.LengthDelimited).string(message.ValidFrom);
        /* string ValidUntil = 32; */
        if (message.ValidUntil !== "")
            writer.tag(32, WireType.LengthDelimited).string(message.ValidUntil);
        /* api.EntityType Entity = 40; */
        if (message.Entity !== 0)
            writer.tag(40, WireType.Varint).int32(message.Entity);
        /* api.EngineRuleScheduledTrigger ScheduledTrigger = 50; */
        if (message.Trigger.oneofKind === "ScheduledTrigger")
            EngineRuleScheduledTrigger.internalBinaryWrite(message.Trigger.ScheduledTrigger, writer.tag(50, WireType.LengthDelimited).fork(), options).join();
        /* api.EngineRuleEventTrigger EventTrigger = 51; */
        if (message.Trigger.oneofKind === "EventTrigger")
            EngineRuleEventTrigger.internalBinaryWrite(message.Trigger.EventTrigger, writer.tag(51, WireType.LengthDelimited).fork(), options).join();
        /* api.EngineRuleMilestoneTrigger MilestoneTrigger = 52; */
        if (message.Trigger.oneofKind === "MilestoneTrigger")
            EngineRuleMilestoneTrigger.internalBinaryWrite(message.Trigger.MilestoneTrigger, writer.tag(52, WireType.LengthDelimited).fork(), options).join();
        /* repeated api.EngineRuleCondition Conditions = 60; */
        for (let i = 0; i < message.Conditions.length; i++)
            EngineRuleCondition.internalBinaryWrite(message.Conditions[i], writer.tag(60, WireType.LengthDelimited).fork(), options).join();
        /* repeated api.EngineRuleAction Actions = 70; */
        for (let i = 0; i < message.Actions.length; i++)
            EngineRuleAction.internalBinaryWrite(message.Actions[i], writer.tag(70, WireType.LengthDelimited).fork(), options).join();
        /* bool IsActive = 80; */
        if (message.IsActive !== false)
            writer.tag(80, WireType.Varint).bool(message.IsActive);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.PutEngineRuleRequest
 */
export const PutEngineRuleRequest = new PutEngineRuleRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PutEngineRuleResponse$Type extends MessageType<PutEngineRuleResponse> {
    constructor() {
        super("api.PutEngineRuleResponse", [
            { no: 1, name: "EngineRule", kind: "message", localName: "EngineRule", jsonName: "EngineRule", T: () => EngineRule, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<PutEngineRuleResponse>): PutEngineRuleResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<PutEngineRuleResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutEngineRuleResponse): PutEngineRuleResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.EngineRule EngineRule */ 1:
                    message.EngineRule = EngineRule.internalBinaryRead(reader, reader.uint32(), options, message.EngineRule);
                    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: PutEngineRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.EngineRule EngineRule = 1; */
        if (message.EngineRule)
            EngineRule.internalBinaryWrite(message.EngineRule, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.PutEngineRuleResponse
 */
export const PutEngineRuleResponse = new PutEngineRuleResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetEngineRuleRequest$Type extends MessageType<GetEngineRuleRequest> {
    constructor() {
        super("api.GetEngineRuleRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code"] } } });
    }
    create(value?: PartialMessage<GetEngineRuleRequest>): GetEngineRuleRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Code = "";
        if (value !== undefined)
            reflectionMergePartial<GetEngineRuleRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetEngineRuleRequest): GetEngineRuleRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string Code */ 2:
                    message.Code = 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: GetEngineRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string Code = 2; */
        if (message.Code !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.Code);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetEngineRuleRequest
 */
export const GetEngineRuleRequest = new GetEngineRuleRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetEngineRuleResponse$Type extends MessageType<GetEngineRuleResponse> {
    constructor() {
        super("api.GetEngineRuleResponse", [
            { no: 1, name: "EngineRule", kind: "message", localName: "EngineRule", jsonName: "EngineRule", T: () => EngineRule, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<GetEngineRuleResponse>): GetEngineRuleResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<GetEngineRuleResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetEngineRuleResponse): GetEngineRuleResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.EngineRule EngineRule */ 1:
                    message.EngineRule = EngineRule.internalBinaryRead(reader, reader.uint32(), options, message.EngineRule);
                    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: GetEngineRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.EngineRule EngineRule = 1; */
        if (message.EngineRule)
            EngineRule.internalBinaryWrite(message.EngineRule, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetEngineRuleResponse
 */
export const GetEngineRuleResponse = new GetEngineRuleResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListEngineRuleRequest$Type extends MessageType<ListEngineRuleRequest> {
    constructor() {
        super("api.ListEngineRuleRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType] },
            { no: 3, name: "TriggerType", kind: "enum", localName: "TriggerType", jsonName: "TriggerType", T: () => ["api.EngineRuleTriggerType", EngineRuleTriggerType] },
            { no: 4, name: "IsCurrentlyValid", kind: "scalar", localName: "IsCurrentlyValid", jsonName: "IsCurrentlyValid", T: 8 /*ScalarType.BOOL*/ }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
    }
    create(value?: PartialMessage<ListEngineRuleRequest>): ListEngineRuleRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Entity = 0;
        message.TriggerType = 0;
        message.IsCurrentlyValid = false;
        if (value !== undefined)
            reflectionMergePartial<ListEngineRuleRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListEngineRuleRequest): ListEngineRuleRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* api.EntityType Entity */ 2:
                    message.Entity = reader.int32();
                    break;
                case /* api.EngineRuleTriggerType TriggerType */ 3:
                    message.TriggerType = reader.int32();
                    break;
                case /* bool IsCurrentlyValid */ 4:
                    message.IsCurrentlyValid = 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: ListEngineRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.EntityType Entity = 2; */
        if (message.Entity !== 0)
            writer.tag(2, WireType.Varint).int32(message.Entity);
        /* api.EngineRuleTriggerType TriggerType = 3; */
        if (message.TriggerType !== 0)
            writer.tag(3, WireType.Varint).int32(message.TriggerType);
        /* bool IsCurrentlyValid = 4; */
        if (message.IsCurrentlyValid !== false)
            writer.tag(4, WireType.Varint).bool(message.IsCurrentlyValid);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListEngineRuleRequest
 */
export const ListEngineRuleRequest = new ListEngineRuleRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListEngineRuleResponse$Type extends MessageType<ListEngineRuleResponse> {
    constructor() {
        super("api.ListEngineRuleResponse", [
            { no: 1, name: "EngineRules", kind: "message", localName: "EngineRules", jsonName: "EngineRules", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EngineRule },
            { no: 2, name: "DebugUntil", kind: "scalar", localName: "DebugUntil", jsonName: "DebugUntil", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
        ]);
    }
    create(value?: PartialMessage<ListEngineRuleResponse>): ListEngineRuleResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.EngineRules = [];
        message.DebugUntil = 0n;
        if (value !== undefined)
            reflectionMergePartial<ListEngineRuleResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListEngineRuleResponse): ListEngineRuleResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.EngineRule EngineRules */ 1:
                    message.EngineRules.push(EngineRule.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* int64 DebugUntil */ 2:
                    message.DebugUntil = reader.int64().toBigInt();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ListEngineRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.EngineRule EngineRules = 1; */
        for (let i = 0; i < message.EngineRules.length; i++)
            EngineRule.internalBinaryWrite(message.EngineRules[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* int64 DebugUntil = 2; */
        if (message.DebugUntil !== 0n)
            writer.tag(2, WireType.Varint).int64(message.DebugUntil);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListEngineRuleResponse
 */
export const ListEngineRuleResponse = new ListEngineRuleResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteEngineRuleRequest$Type extends MessageType<DeleteEngineRuleRequest> {
    constructor() {
        super("api.DeleteEngineRuleRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code"] } } });
    }
    create(value?: PartialMessage<DeleteEngineRuleRequest>): DeleteEngineRuleRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Code = "";
        if (value !== undefined)
            reflectionMergePartial<DeleteEngineRuleRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteEngineRuleRequest): DeleteEngineRuleRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string Code */ 2:
                    message.Code = 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: DeleteEngineRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string Code = 2; */
        if (message.Code !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.Code);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteEngineRuleRequest
 */
export const DeleteEngineRuleRequest = new DeleteEngineRuleRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteEngineRuleResponse$Type extends MessageType<DeleteEngineRuleResponse> {
    constructor() {
        super("api.DeleteEngineRuleResponse", []);
    }
    create(value?: PartialMessage<DeleteEngineRuleResponse>): DeleteEngineRuleResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<DeleteEngineRuleResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteEngineRuleResponse): DeleteEngineRuleResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                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: DeleteEngineRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteEngineRuleResponse
 */
export const DeleteEngineRuleResponse = new DeleteEngineRuleResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ToggleDebugOnRequest$Type extends MessageType<ToggleDebugOnRequest> {
    constructor() {
        super("api.ToggleDebugOnRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
    }
    create(value?: PartialMessage<ToggleDebugOnRequest>): ToggleDebugOnRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<ToggleDebugOnRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ToggleDebugOnRequest): ToggleDebugOnRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    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: ToggleDebugOnRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ToggleDebugOnRequest
 */
export const ToggleDebugOnRequest = new ToggleDebugOnRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ToggleDebugOnResponse$Type extends MessageType<ToggleDebugOnResponse> {
    constructor() {
        super("api.ToggleDebugOnResponse", [
            { no: 1, name: "DebugUntil", kind: "scalar", localName: "DebugUntil", jsonName: "DebugUntil", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
        ]);
    }
    create(value?: PartialMessage<ToggleDebugOnResponse>): ToggleDebugOnResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.DebugUntil = 0n;
        if (value !== undefined)
            reflectionMergePartial<ToggleDebugOnResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ToggleDebugOnResponse): ToggleDebugOnResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* int64 DebugUntil */ 1:
                    message.DebugUntil = reader.int64().toBigInt();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ToggleDebugOnResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* int64 DebugUntil = 1; */
        if (message.DebugUntil !== 0n)
            writer.tag(1, WireType.Varint).int64(message.DebugUntil);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ToggleDebugOnResponse
 */
export const ToggleDebugOnResponse = new ToggleDebugOnResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PutComputationRequest$Type extends MessageType<PutComputationRequest> {
    constructor() {
        super("api.PutComputationRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/ },
            { no: 20, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } },
            { no: 30, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "n1validate.rules": { enum: { definedOnly: true, notIn: [0] } } } },
            { no: 40, name: "DateDuration", kind: "message", localName: "DateDuration", jsonName: "DateDuration", oneof: "Type", T: () => ComputationDateDuration },
            { no: 41, name: "DueDate", kind: "message", localName: "DueDate", jsonName: "DueDate", oneof: "Type", T: () => ComputationDueDate },
            { no: 42, name: "StatusDuration", kind: "message", localName: "StatusDuration", jsonName: "StatusDuration", oneof: "Type", T: () => ComputationStatusDuration },
            { no: 43, name: "CustomFunction", kind: "message", localName: "CustomFunction", jsonName: "CustomFunction", oneof: "Type", T: () => ComputationCustomFunction }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Label", "Entity", "Type"] } } });
    }
    create(value?: PartialMessage<PutComputationRequest>): PutComputationRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        message.Label = "";
        message.Entity = 0;
        message.Type = { oneofKind: undefined };
        if (value !== undefined)
            reflectionMergePartial<PutComputationRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutComputationRequest): PutComputationRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = reader.string();
                    break;
                case /* string Label */ 20:
                    message.Label = reader.string();
                    break;
                case /* api.EntityType Entity */ 30:
                    message.Entity = reader.int32();
                    break;
                case /* api.ComputationDateDuration DateDuration */ 40:
                    message.Type = {
                        oneofKind: "DateDuration",
                        DateDuration: ComputationDateDuration.internalBinaryRead(reader, reader.uint32(), options, (message.Type as any).DateDuration)
                    };
                    break;
                case /* api.ComputationDueDate DueDate */ 41:
                    message.Type = {
                        oneofKind: "DueDate",
                        DueDate: ComputationDueDate.internalBinaryRead(reader, reader.uint32(), options, (message.Type as any).DueDate)
                    };
                    break;
                case /* api.ComputationStatusDuration StatusDuration */ 42:
                    message.Type = {
                        oneofKind: "StatusDuration",
                        StatusDuration: ComputationStatusDuration.internalBinaryRead(reader, reader.uint32(), options, (message.Type as any).StatusDuration)
                    };
                    break;
                case /* api.ComputationCustomFunction CustomFunction */ 43:
                    message.Type = {
                        oneofKind: "CustomFunction",
                        CustomFunction: ComputationCustomFunction.internalBinaryRead(reader, reader.uint32(), options, (message.Type as any).CustomFunction)
                    };
                    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: PutComputationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        /* string Label = 20; */
        if (message.Label !== "")
            writer.tag(20, WireType.LengthDelimited).string(message.Label);
        /* api.EntityType Entity = 30; */
        if (message.Entity !== 0)
            writer.tag(30, WireType.Varint).int32(message.Entity);
        /* api.ComputationDateDuration DateDuration = 40; */
        if (message.Type.oneofKind === "DateDuration")
            ComputationDateDuration.internalBinaryWrite(message.Type.DateDuration, writer.tag(40, WireType.LengthDelimited).fork(), options).join();
        /* api.ComputationDueDate DueDate = 41; */
        if (message.Type.oneofKind === "DueDate")
            ComputationDueDate.internalBinaryWrite(message.Type.DueDate, writer.tag(41, WireType.LengthDelimited).fork(), options).join();
        /* api.ComputationStatusDuration StatusDuration = 42; */
        if (message.Type.oneofKind === "StatusDuration")
            ComputationStatusDuration.internalBinaryWrite(message.Type.StatusDuration, writer.tag(42, WireType.LengthDelimited).fork(), options).join();
        /* api.ComputationCustomFunction CustomFunction = 43; */
        if (message.Type.oneofKind === "CustomFunction")
            ComputationCustomFunction.internalBinaryWrite(message.Type.CustomFunction, writer.tag(43, 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.PutComputationRequest
 */
export const PutComputationRequest = new PutComputationRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PutComputationResponse$Type extends MessageType<PutComputationResponse> {
    constructor() {
        super("api.PutComputationResponse", [
            { no: 1, name: "Computation", kind: "message", localName: "Computation", jsonName: "Computation", T: () => Computation, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<PutComputationResponse>): PutComputationResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<PutComputationResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutComputationResponse): PutComputationResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.Computation Computation */ 1:
                    message.Computation = Computation.internalBinaryRead(reader, reader.uint32(), options, message.Computation);
                    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: PutComputationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.Computation Computation = 1; */
        if (message.Computation)
            Computation.internalBinaryWrite(message.Computation, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.PutComputationResponse
 */
export const PutComputationResponse = new PutComputationResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetComputationRequest$Type extends MessageType<GetComputationRequest> {
    constructor() {
        super("api.GetComputationRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID"] } } });
    }
    create(value?: PartialMessage<GetComputationRequest>): GetComputationRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        if (value !== undefined)
            reflectionMergePartial<GetComputationRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetComputationRequest): GetComputationRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = 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: GetComputationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetComputationRequest
 */
export const GetComputationRequest = new GetComputationRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetComputationResponse$Type extends MessageType<GetComputationResponse> {
    constructor() {
        super("api.GetComputationResponse", [
            { no: 1, name: "Computation", kind: "message", localName: "Computation", jsonName: "Computation", T: () => Computation, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<GetComputationResponse>): GetComputationResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<GetComputationResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetComputationResponse): GetComputationResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.Computation Computation */ 1:
                    message.Computation = Computation.internalBinaryRead(reader, reader.uint32(), options, message.Computation);
                    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: GetComputationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.Computation Computation = 1; */
        if (message.Computation)
            Computation.internalBinaryWrite(message.Computation, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetComputationResponse
 */
export const GetComputationResponse = new GetComputationResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListComputationRequest$Type extends MessageType<ListComputationRequest> {
    constructor() {
        super("api.ListComputationRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType] }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
    }
    create(value?: PartialMessage<ListComputationRequest>): ListComputationRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Entity = 0;
        if (value !== undefined)
            reflectionMergePartial<ListComputationRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListComputationRequest): ListComputationRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* api.EntityType Entity */ 2:
                    message.Entity = 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: ListComputationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.EntityType Entity = 2; */
        if (message.Entity !== 0)
            writer.tag(2, WireType.Varint).int32(message.Entity);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListComputationRequest
 */
export const ListComputationRequest = new ListComputationRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListComputationResponse$Type extends MessageType<ListComputationResponse> {
    constructor() {
        super("api.ListComputationResponse", [
            { no: 1, name: "Computations", kind: "message", localName: "Computations", jsonName: "Computations", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Computation }
        ]);
    }
    create(value?: PartialMessage<ListComputationResponse>): ListComputationResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Computations = [];
        if (value !== undefined)
            reflectionMergePartial<ListComputationResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListComputationResponse): ListComputationResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.Computation Computations */ 1:
                    message.Computations.push(Computation.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: ListComputationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.Computation Computations = 1; */
        for (let i = 0; i < message.Computations.length; i++)
            Computation.internalBinaryWrite(message.Computations[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListComputationResponse
 */
export const ListComputationResponse = new ListComputationResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteComputationRequest$Type extends MessageType<DeleteComputationRequest> {
    constructor() {
        super("api.DeleteComputationRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID"] } } });
    }
    create(value?: PartialMessage<DeleteComputationRequest>): DeleteComputationRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        if (value !== undefined)
            reflectionMergePartial<DeleteComputationRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteComputationRequest): DeleteComputationRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = 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: DeleteComputationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteComputationRequest
 */
export const DeleteComputationRequest = new DeleteComputationRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteComputationResponse$Type extends MessageType<DeleteComputationResponse> {
    constructor() {
        super("api.DeleteComputationResponse", []);
    }
    create(value?: PartialMessage<DeleteComputationResponse>): DeleteComputationResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<DeleteComputationResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteComputationResponse): DeleteComputationResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                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: DeleteComputationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteComputationResponse
 */
export const DeleteComputationResponse = new DeleteComputationResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PutMappingTableRequest$Type extends MessageType<PutMappingTableRequest> {
    constructor() {
        super("api.PutMappingTableRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } },
            { no: 4, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "n1validate.rules": { enum: { definedOnly: true, notIn: [0] } } } },
            { no: 5, name: "InputFields", kind: "message", localName: "InputFields", jsonName: "InputFields", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MappingTableInputDescription, options: { "n1validate.rules": { repeated: { minItems: "1" } } } },
            { no: 6, name: "OutputField", kind: "message", localName: "OutputField", jsonName: "OutputField", T: () => MappingTableOutputField, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 7, name: "Entries", kind: "message", localName: "Entries", jsonName: "Entries", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MappingTableEntry, options: { "n1validate.rules": { repeated: { minItems: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Label", "InputFields", "OutputField", "Entries", "Entity"] } } });
    }
    create(value?: PartialMessage<PutMappingTableRequest>): PutMappingTableRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        message.Label = "";
        message.Entity = 0;
        message.InputFields = [];
        message.Entries = [];
        if (value !== undefined)
            reflectionMergePartial<PutMappingTableRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutMappingTableRequest): PutMappingTableRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = reader.string();
                    break;
                case /* string Label */ 3:
                    message.Label = reader.string();
                    break;
                case /* api.EntityType Entity */ 4:
                    message.Entity = reader.int32();
                    break;
                case /* repeated api.MappingTableInputDescription InputFields */ 5:
                    message.InputFields.push(MappingTableInputDescription.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* api.MappingTableOutputField OutputField */ 6:
                    message.OutputField = MappingTableOutputField.internalBinaryRead(reader, reader.uint32(), options, message.OutputField);
                    break;
                case /* repeated api.MappingTableEntry Entries */ 7:
                    message.Entries.push(MappingTableEntry.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: PutMappingTableRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        /* string Label = 3; */
        if (message.Label !== "")
            writer.tag(3, WireType.LengthDelimited).string(message.Label);
        /* api.EntityType Entity = 4; */
        if (message.Entity !== 0)
            writer.tag(4, WireType.Varint).int32(message.Entity);
        /* repeated api.MappingTableInputDescription InputFields = 5; */
        for (let i = 0; i < message.InputFields.length; i++)
            MappingTableInputDescription.internalBinaryWrite(message.InputFields[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
        /* api.MappingTableOutputField OutputField = 6; */
        if (message.OutputField)
            MappingTableOutputField.internalBinaryWrite(message.OutputField, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
        /* repeated api.MappingTableEntry Entries = 7; */
        for (let i = 0; i < message.Entries.length; i++)
            MappingTableEntry.internalBinaryWrite(message.Entries[i], writer.tag(7, 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.PutMappingTableRequest
 */
export const PutMappingTableRequest = new PutMappingTableRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PutMappingTableResponse$Type extends MessageType<PutMappingTableResponse> {
    constructor() {
        super("api.PutMappingTableResponse", [
            { no: 1, name: "MappingTable", kind: "message", localName: "MappingTable", jsonName: "MappingTable", T: () => MappingTable, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<PutMappingTableResponse>): PutMappingTableResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<PutMappingTableResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PutMappingTableResponse): PutMappingTableResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.MappingTable MappingTable */ 1:
                    message.MappingTable = MappingTable.internalBinaryRead(reader, reader.uint32(), options, message.MappingTable);
                    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: PutMappingTableResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.MappingTable MappingTable = 1; */
        if (message.MappingTable)
            MappingTable.internalBinaryWrite(message.MappingTable, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.PutMappingTableResponse
 */
export const PutMappingTableResponse = new PutMappingTableResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetMappingTableRequest$Type extends MessageType<GetMappingTableRequest> {
    constructor() {
        super("api.GetMappingTableRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID"] } } });
    }
    create(value?: PartialMessage<GetMappingTableRequest>): GetMappingTableRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        if (value !== undefined)
            reflectionMergePartial<GetMappingTableRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetMappingTableRequest): GetMappingTableRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = 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: GetMappingTableRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetMappingTableRequest
 */
export const GetMappingTableRequest = new GetMappingTableRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class GetMappingTableResponse$Type extends MessageType<GetMappingTableResponse> {
    constructor() {
        super("api.GetMappingTableResponse", [
            { no: 1, name: "MappingTable", kind: "message", localName: "MappingTable", jsonName: "MappingTable", T: () => MappingTable, options: { "n1validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value?: PartialMessage<GetMappingTableResponse>): GetMappingTableResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<GetMappingTableResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetMappingTableResponse): GetMappingTableResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.MappingTable MappingTable */ 1:
                    message.MappingTable = MappingTable.internalBinaryRead(reader, reader.uint32(), options, message.MappingTable);
                    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: GetMappingTableResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.MappingTable MappingTable = 1; */
        if (message.MappingTable)
            MappingTable.internalBinaryWrite(message.MappingTable, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.GetMappingTableResponse
 */
export const GetMappingTableResponse = new GetMappingTableResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListMappingTableRequest$Type extends MessageType<ListMappingTableRequest> {
    constructor() {
        super("api.ListMappingTableRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType] }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
    }
    create(value?: PartialMessage<ListMappingTableRequest>): ListMappingTableRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.Entity = 0;
        if (value !== undefined)
            reflectionMergePartial<ListMappingTableRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListMappingTableRequest): ListMappingTableRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* api.EntityType Entity */ 2:
                    message.Entity = 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: ListMappingTableRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* api.EntityType Entity = 2; */
        if (message.Entity !== 0)
            writer.tag(2, WireType.Varint).int32(message.Entity);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListMappingTableRequest
 */
export const ListMappingTableRequest = new ListMappingTableRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ListMappingTableResponse$Type extends MessageType<ListMappingTableResponse> {
    constructor() {
        super("api.ListMappingTableResponse", [
            { no: 1, name: "MappingTables", kind: "message", localName: "MappingTables", jsonName: "MappingTables", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MappingTable }
        ]);
    }
    create(value?: PartialMessage<ListMappingTableResponse>): ListMappingTableResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.MappingTables = [];
        if (value !== undefined)
            reflectionMergePartial<ListMappingTableResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListMappingTableResponse): ListMappingTableResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated api.MappingTable MappingTables */ 1:
                    message.MappingTables.push(MappingTable.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: ListMappingTableResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* repeated api.MappingTable MappingTables = 1; */
        for (let i = 0; i < message.MappingTables.length; i++)
            MappingTable.internalBinaryWrite(message.MappingTables[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.ListMappingTableResponse
 */
export const ListMappingTableResponse = new ListMappingTableResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteMappingTableRequest$Type extends MessageType<DeleteMappingTableRequest> {
    constructor() {
        super("api.DeleteMappingTableRequest", [
            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
            { no: 2, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "n1validate.rules": { string: { minLen: "1" } } } }
        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID"] } } });
    }
    create(value?: PartialMessage<DeleteMappingTableRequest>): DeleteMappingTableRequest {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.ID = "";
        if (value !== undefined)
            reflectionMergePartial<DeleteMappingTableRequest>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteMappingTableRequest): DeleteMappingTableRequest {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* api.RequestProjectHeader Header */ 1:
                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
                    break;
                case /* string ID */ 2:
                    message.ID = 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: DeleteMappingTableRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* api.RequestProjectHeader Header = 1; */
        if (message.Header)
            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string ID = 2; */
        if (message.ID !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.ID);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteMappingTableRequest
 */
export const DeleteMappingTableRequest = new DeleteMappingTableRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DeleteMappingTableResponse$Type extends MessageType<DeleteMappingTableResponse> {
    constructor() {
        super("api.DeleteMappingTableResponse", []);
    }
    create(value?: PartialMessage<DeleteMappingTableResponse>): DeleteMappingTableResponse {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<DeleteMappingTableResponse>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteMappingTableResponse): DeleteMappingTableResponse {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                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: DeleteMappingTableResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message api.DeleteMappingTableResponse
 */
export const DeleteMappingTableResponse = new DeleteMappingTableResponse$Type();
/**
 * @generated ServiceType for protobuf service api.RuleEngineService
 */
export const RuleEngineService = new ServiceType("api.RuleEngineService", [
    { name: "Put", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["RuleEngine"], description: "Create or update an engine rule for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: PutEngineRuleRequest, O: PutEngineRuleResponse },
    { name: "Get", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["RuleEngine"], description: "Get an engine rule for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: GetEngineRuleRequest, O: GetEngineRuleResponse },
    { name: "List", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["RuleEngine"], description: "List engine rules for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: ListEngineRuleRequest, O: ListEngineRuleResponse },
    { name: "Delete", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["RuleEngine"], description: "Delete an engine rule for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteEngineRuleRequest, O: DeleteEngineRuleResponse },
    { name: "ToggleDebugOn", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["RuleEngine"], description: "Turn on debug mode for the rule engine on a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: ToggleDebugOnRequest, O: ToggleDebugOnResponse }
], { "api.k8sService": "rule-server" });
/**
 * @generated ServiceType for protobuf service api.ComputationService
 */
export const ComputationService = new ServiceType("api.ComputationService", [
    { name: "Put", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Computation"], description: "Create or update a computation for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: PutComputationRequest, O: PutComputationResponse },
    { name: "Get", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Computation"], description: "Get a computation for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: GetComputationRequest, O: GetComputationResponse },
    { name: "List", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Computation"], description: "List computations for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: ListComputationRequest, O: ListComputationResponse },
    { name: "Delete", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Computation"], description: "Delete a computation for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteComputationRequest, O: DeleteComputationResponse }
], { "api.k8sService": "rule-server" });
/**
 * @generated ServiceType for protobuf service api.MappingTableService
 */
export const MappingTableService = new ServiceType("api.MappingTableService", [
    { name: "Put", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["MappingTable"], description: "Create or update a mapping table for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: PutMappingTableRequest, O: PutMappingTableResponse },
    { name: "Get", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["MappingTable"], description: "Get a mapping table for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: GetMappingTableRequest, O: GetMappingTableResponse },
    { name: "List", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["MappingTable"], description: "List mapping tables for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: ListMappingTableRequest, O: ListMappingTableResponse },
    { name: "Delete", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["MappingTable"], description: "Delete a mapping table for a project" }, "api.rscType": "Project", "api.roles": "Platform.RuleEngine", "api.moduleID": "rules", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteMappingTableRequest, O: DeleteMappingTableResponse }
], { "api.k8sService": "rule-server" });