@aneoconsultingfr/armonik.api.angular 3.11.0-edge.89.ab31d7c → 3.11.0

package/esm2022/lib/generated/sessions-fields.pb.mjs

@@ -0,0 +1,504 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+export var SessionRawEnumField;
+(function (SessionRawEnumField) {
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_UNSPECIFIED"] = 0] = "SESSION_RAW_ENUM_FIELD_UNSPECIFIED";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_SESSION_ID"] = 1] = "SESSION_RAW_ENUM_FIELD_SESSION_ID";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_STATUS"] = 2] = "SESSION_RAW_ENUM_FIELD_STATUS";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_PARTITION_IDS"] = 3] = "SESSION_RAW_ENUM_FIELD_PARTITION_IDS";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_OPTIONS"] = 4] = "SESSION_RAW_ENUM_FIELD_OPTIONS";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_CREATED_AT"] = 5] = "SESSION_RAW_ENUM_FIELD_CREATED_AT";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_CANCELLED_AT"] = 6] = "SESSION_RAW_ENUM_FIELD_CANCELLED_AT";
+    SessionRawEnumField[SessionRawEnumField["SESSION_RAW_ENUM_FIELD_DURATION"] = 7] = "SESSION_RAW_ENUM_FIELD_DURATION";
+})(SessionRawEnumField || (SessionRawEnumField = {}));
+export var TaskOptionEnumField;
+(function (TaskOptionEnumField) {
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_UNSPECIFIED"] = 0] = "TASK_OPTION_ENUM_FIELD_UNSPECIFIED";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_MAX_DURATION"] = 1] = "TASK_OPTION_ENUM_FIELD_MAX_DURATION";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_MAX_RETRIES"] = 2] = "TASK_OPTION_ENUM_FIELD_MAX_RETRIES";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_PRIORITY"] = 3] = "TASK_OPTION_ENUM_FIELD_PRIORITY";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_PARTITION_ID"] = 4] = "TASK_OPTION_ENUM_FIELD_PARTITION_ID";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_APPLICATION_NAME"] = 5] = "TASK_OPTION_ENUM_FIELD_APPLICATION_NAME";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_APPLICATION_VERSION"] = 6] = "TASK_OPTION_ENUM_FIELD_APPLICATION_VERSION";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_APPLICATION_NAMESPACE"] = 7] = "TASK_OPTION_ENUM_FIELD_APPLICATION_NAMESPACE";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_APPLICATION_SERVICE"] = 8] = "TASK_OPTION_ENUM_FIELD_APPLICATION_SERVICE";
+    TaskOptionEnumField[TaskOptionEnumField["TASK_OPTION_ENUM_FIELD_ENGINE_TYPE"] = 9] = "TASK_OPTION_ENUM_FIELD_ENGINE_TYPE";
+})(TaskOptionEnumField || (TaskOptionEnumField = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.sessions.SessionRawField
+ */
+export class SessionRawField {
+    static { this.id = 'armonik.api.grpc.v1.sessions.SessionRawField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SessionRawField();
+        SessionRawField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.field = _instance.field || 0;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.field = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SessionRawField.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.field) {
+            _writer.writeEnum(1, _instance.field);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SessionRawField to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.field = _value.field;
+        SessionRawField.refineValues(this);
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SessionRawField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            field: this.field
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            field: SessionRawEnumField[this.field === null || this.field === undefined ? 0 : this.field]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.sessions.TaskOptionField
+ */
+export class TaskOptionField {
+    static { this.id = 'armonik.api.grpc.v1.sessions.TaskOptionField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskOptionField();
+        TaskOptionField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.field = _instance.field || 0;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.field = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskOptionField.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.field) {
+            _writer.writeEnum(1, _instance.field);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOptionField to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.field = _value.field;
+        TaskOptionField.refineValues(this);
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskOptionField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            field: this.field
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            field: TaskOptionEnumField[this.field === null || this.field === undefined ? 0 : this.field]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.sessions.TaskOptionGenericField
+ */
+export class TaskOptionGenericField {
+    static { this.id = 'armonik.api.grpc.v1.sessions.TaskOptionGenericField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskOptionGenericField();
+        TaskOptionGenericField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.field = _instance.field || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.field = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskOptionGenericField.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.field) {
+            _writer.writeString(1, _instance.field);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOptionGenericField to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.field = _value.field;
+        TaskOptionGenericField.refineValues(this);
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskOptionGenericField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            field: this.field
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            field: this.field
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.sessions.SessionField
+ */
+export class SessionField {
+    static { this.id = 'armonik.api.grpc.v1.sessions.SessionField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SessionField();
+        SessionField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.sessionRawField = new SessionRawField();
+                    _reader.readMessage(_instance.sessionRawField, SessionRawField.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.taskOptionField = new TaskOptionField();
+                    _reader.readMessage(_instance.taskOptionField, TaskOptionField.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.taskOptionGenericField = new TaskOptionGenericField();
+                    _reader.readMessage(_instance.taskOptionGenericField, TaskOptionGenericField.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SessionField.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.sessionRawField) {
+            _writer.writeMessage(1, _instance.sessionRawField, SessionRawField.serializeBinaryToWriter);
+        }
+        if (_instance.taskOptionField) {
+            _writer.writeMessage(2, _instance.taskOptionField, TaskOptionField.serializeBinaryToWriter);
+        }
+        if (_instance.taskOptionGenericField) {
+            _writer.writeMessage(3, _instance.taskOptionGenericField, TaskOptionGenericField.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SessionField to deeply clone from
+     */
+    constructor(_value) {
+        this._field = SessionField.FieldCase.none;
+        _value = _value || {};
+        this.sessionRawField = _value.sessionRawField
+            ? new SessionRawField(_value.sessionRawField)
+            : undefined;
+        this.taskOptionField = _value.taskOptionField
+            ? new TaskOptionField(_value.taskOptionField)
+            : undefined;
+        this.taskOptionGenericField = _value.taskOptionGenericField
+            ? new TaskOptionGenericField(_value.taskOptionGenericField)
+            : undefined;
+        SessionField.refineValues(this);
+    }
+    get sessionRawField() {
+        return this._sessionRawField;
+    }
+    set sessionRawField(value) {
+        if (value !== undefined && value !== null) {
+            this._taskOptionField = this._taskOptionGenericField = undefined;
+            this._field = SessionField.FieldCase.sessionRawField;
+        }
+        this._sessionRawField = value;
+    }
+    get taskOptionField() {
+        return this._taskOptionField;
+    }
+    set taskOptionField(value) {
+        if (value !== undefined && value !== null) {
+            this._sessionRawField = this._taskOptionGenericField = undefined;
+            this._field = SessionField.FieldCase.taskOptionField;
+        }
+        this._taskOptionField = value;
+    }
+    get taskOptionGenericField() {
+        return this._taskOptionGenericField;
+    }
+    set taskOptionGenericField(value) {
+        if (value !== undefined && value !== null) {
+            this._sessionRawField = this._taskOptionField = undefined;
+            this._field = SessionField.FieldCase.taskOptionGenericField;
+        }
+        this._taskOptionGenericField = value;
+    }
+    get field() {
+        return this._field;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SessionField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            sessionRawField: this.sessionRawField
+                ? this.sessionRawField.toObject()
+                : undefined,
+            taskOptionField: this.taskOptionField
+                ? this.taskOptionField.toObject()
+                : undefined,
+            taskOptionGenericField: this.taskOptionGenericField
+                ? this.taskOptionGenericField.toObject()
+                : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            sessionRawField: this.sessionRawField
+                ? this.sessionRawField.toProtobufJSON(options)
+                : null,
+            taskOptionField: this.taskOptionField
+                ? this.taskOptionField.toProtobufJSON(options)
+                : null,
+            taskOptionGenericField: this.taskOptionGenericField
+                ? this.taskOptionGenericField.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+(function (SessionField) {
+    let FieldCase;
+    (function (FieldCase) {
+        FieldCase[FieldCase["none"] = 0] = "none";
+        FieldCase[FieldCase["sessionRawField"] = 1] = "sessionRawField";
+        FieldCase[FieldCase["taskOptionField"] = 2] = "taskOptionField";
+        FieldCase[FieldCase["taskOptionGenericField"] = 3] = "taskOptionGenericField";
+    })(FieldCase = SessionField.FieldCase || (SessionField.FieldCase = {}));
+})(SessionField || (SessionField = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sessions-fields.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/sessions-fields.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nexport enum SessionRawEnumField {\n  SESSION_RAW_ENUM_FIELD_UNSPECIFIED = 0,\n  SESSION_RAW_ENUM_FIELD_SESSION_ID = 1,\n  SESSION_RAW_ENUM_FIELD_STATUS = 2,\n  SESSION_RAW_ENUM_FIELD_PARTITION_IDS = 3,\n  SESSION_RAW_ENUM_FIELD_OPTIONS = 4,\n  SESSION_RAW_ENUM_FIELD_CREATED_AT = 5,\n  SESSION_RAW_ENUM_FIELD_CANCELLED_AT = 6,\n  SESSION_RAW_ENUM_FIELD_DURATION = 7\n}\nexport enum TaskOptionEnumField {\n  TASK_OPTION_ENUM_FIELD_UNSPECIFIED = 0,\n  TASK_OPTION_ENUM_FIELD_MAX_DURATION = 1,\n  TASK_OPTION_ENUM_FIELD_MAX_RETRIES = 2,\n  TASK_OPTION_ENUM_FIELD_PRIORITY = 3,\n  TASK_OPTION_ENUM_FIELD_PARTITION_ID = 4,\n  TASK_OPTION_ENUM_FIELD_APPLICATION_NAME = 5,\n  TASK_OPTION_ENUM_FIELD_APPLICATION_VERSION = 6,\n  TASK_OPTION_ENUM_FIELD_APPLICATION_NAMESPACE = 7,\n  TASK_OPTION_ENUM_FIELD_APPLICATION_SERVICE = 8,\n  TASK_OPTION_ENUM_FIELD_ENGINE_TYPE = 9\n}\n/**\n * Message implementation for armonik.api.grpc.v1.sessions.SessionRawField\n */\nexport class SessionRawField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.sessions.SessionRawField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SessionRawField();\n    SessionRawField.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: SessionRawField) {\n    _instance.field = _instance.field || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: SessionRawField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.field = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SessionRawField.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: SessionRawField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.field) {\n      _writer.writeEnum(1, _instance.field);\n    }\n  }\n\n  private _field: SessionRawEnumField;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SessionRawField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SessionRawField.AsObject>) {\n    _value = _value || {};\n    this.field = _value.field;\n    SessionRawField.refineValues(this);\n  }\n  get field(): SessionRawEnumField {\n    return this._field;\n  }\n  set field(value: SessionRawEnumField) {\n    this._field = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SessionRawField.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): SessionRawField.AsObject {\n    return {\n      field: this.field\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SessionRawField.AsProtobufJSON {\n    return {\n      field:\n        SessionRawEnumField[\n          this.field === null || this.field === undefined ? 0 : this.field\n        ]\n    };\n  }\n}\nexport module SessionRawField {\n  /**\n   * Standard JavaScript object representation for SessionRawField\n   */\n  export interface AsObject {\n    field: SessionRawEnumField;\n  }\n\n  /**\n   * Protobuf JSON representation for SessionRawField\n   */\n  export interface AsProtobufJSON {\n    field: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.sessions.TaskOptionField\n */\nexport class TaskOptionField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.sessions.TaskOptionField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskOptionField();\n    TaskOptionField.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: TaskOptionField) {\n    _instance.field = _instance.field || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: TaskOptionField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.field = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskOptionField.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: TaskOptionField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.field) {\n      _writer.writeEnum(1, _instance.field);\n    }\n  }\n\n  private _field: TaskOptionEnumField;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskOptionField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskOptionField.AsObject>) {\n    _value = _value || {};\n    this.field = _value.field;\n    TaskOptionField.refineValues(this);\n  }\n  get field(): TaskOptionEnumField {\n    return this._field;\n  }\n  set field(value: TaskOptionEnumField) {\n    this._field = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskOptionField.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): TaskOptionField.AsObject {\n    return {\n      field: this.field\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): TaskOptionField.AsProtobufJSON {\n    return {\n      field:\n        TaskOptionEnumField[\n          this.field === null || this.field === undefined ? 0 : this.field\n        ]\n    };\n  }\n}\nexport module TaskOptionField {\n  /**\n   * Standard JavaScript object representation for TaskOptionField\n   */\n  export interface AsObject {\n    field: TaskOptionEnumField;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskOptionField\n   */\n  export interface AsProtobufJSON {\n    field: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.sessions.TaskOptionGenericField\n */\nexport class TaskOptionGenericField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.sessions.TaskOptionGenericField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskOptionGenericField();\n    TaskOptionGenericField.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: TaskOptionGenericField) {\n    _instance.field = _instance.field || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: TaskOptionGenericField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.field = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskOptionGenericField.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: TaskOptionGenericField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.field) {\n      _writer.writeString(1, _instance.field);\n    }\n  }\n\n  private _field: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskOptionGenericField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskOptionGenericField.AsObject>) {\n    _value = _value || {};\n    this.field = _value.field;\n    TaskOptionGenericField.refineValues(this);\n  }\n  get field(): string {\n    return this._field;\n  }\n  set field(value: string) {\n    this._field = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskOptionGenericField.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): TaskOptionGenericField.AsObject {\n    return {\n      field: this.field\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): TaskOptionGenericField.AsProtobufJSON {\n    return {\n      field: this.field\n    };\n  }\n}\nexport module TaskOptionGenericField {\n  /**\n   * Standard JavaScript object representation for TaskOptionGenericField\n   */\n  export interface AsObject {\n    field: string;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskOptionGenericField\n   */\n  export interface AsProtobufJSON {\n    field: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.sessions.SessionField\n */\nexport class SessionField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.sessions.SessionField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SessionField();\n    SessionField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: SessionField) {}\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: SessionField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.sessionRawField = new SessionRawField();\n          _reader.readMessage(\n            _instance.sessionRawField,\n            SessionRawField.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.taskOptionField = new TaskOptionField();\n          _reader.readMessage(\n            _instance.taskOptionField,\n            TaskOptionField.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.taskOptionGenericField = new TaskOptionGenericField();\n          _reader.readMessage(\n            _instance.taskOptionGenericField,\n            TaskOptionGenericField.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SessionField.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: SessionField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.sessionRawField) {\n      _writer.writeMessage(\n        1,\n        _instance.sessionRawField as any,\n        SessionRawField.serializeBinaryToWriter\n      );\n    }\n    if (_instance.taskOptionField) {\n      _writer.writeMessage(\n        2,\n        _instance.taskOptionField as any,\n        TaskOptionField.serializeBinaryToWriter\n      );\n    }\n    if (_instance.taskOptionGenericField) {\n      _writer.writeMessage(\n        3,\n        _instance.taskOptionGenericField as any,\n        TaskOptionGenericField.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _sessionRawField?: SessionRawField;\n  private _taskOptionField?: TaskOptionField;\n  private _taskOptionGenericField?: TaskOptionGenericField;\n\n  private _field: SessionField.FieldCase = SessionField.FieldCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SessionField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SessionField.AsObject>) {\n    _value = _value || {};\n    this.sessionRawField = _value.sessionRawField\n      ? new SessionRawField(_value.sessionRawField)\n      : undefined;\n    this.taskOptionField = _value.taskOptionField\n      ? new TaskOptionField(_value.taskOptionField)\n      : undefined;\n    this.taskOptionGenericField = _value.taskOptionGenericField\n      ? new TaskOptionGenericField(_value.taskOptionGenericField)\n      : undefined;\n    SessionField.refineValues(this);\n  }\n  get sessionRawField(): SessionRawField | undefined {\n    return this._sessionRawField;\n  }\n  set sessionRawField(value: SessionRawField | undefined) {\n    if (value !== undefined && value !== null) {\n      this._taskOptionField = this._taskOptionGenericField = undefined;\n      this._field = SessionField.FieldCase.sessionRawField;\n    }\n    this._sessionRawField = value;\n  }\n  get taskOptionField(): TaskOptionField | undefined {\n    return this._taskOptionField;\n  }\n  set taskOptionField(value: TaskOptionField | undefined) {\n    if (value !== undefined && value !== null) {\n      this._sessionRawField = this._taskOptionGenericField = undefined;\n      this._field = SessionField.FieldCase.taskOptionField;\n    }\n    this._taskOptionField = value;\n  }\n  get taskOptionGenericField(): TaskOptionGenericField | undefined {\n    return this._taskOptionGenericField;\n  }\n  set taskOptionGenericField(value: TaskOptionGenericField | undefined) {\n    if (value !== undefined && value !== null) {\n      this._sessionRawField = this._taskOptionField = undefined;\n      this._field = SessionField.FieldCase.taskOptionGenericField;\n    }\n    this._taskOptionGenericField = value;\n  }\n  get field() {\n    return this._field;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SessionField.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): SessionField.AsObject {\n    return {\n      sessionRawField: this.sessionRawField\n        ? this.sessionRawField.toObject()\n        : undefined,\n      taskOptionField: this.taskOptionField\n        ? this.taskOptionField.toObject()\n        : undefined,\n      taskOptionGenericField: this.taskOptionGenericField\n        ? this.taskOptionGenericField.toObject()\n        : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SessionField.AsProtobufJSON {\n    return {\n      sessionRawField: this.sessionRawField\n        ? this.sessionRawField.toProtobufJSON(options)\n        : null,\n      taskOptionField: this.taskOptionField\n        ? this.taskOptionField.toProtobufJSON(options)\n        : null,\n      taskOptionGenericField: this.taskOptionGenericField\n        ? this.taskOptionGenericField.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module SessionField {\n  /**\n   * Standard JavaScript object representation for SessionField\n   */\n  export interface AsObject {\n    sessionRawField?: SessionRawField.AsObject;\n    taskOptionField?: TaskOptionField.AsObject;\n    taskOptionGenericField?: TaskOptionGenericField.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for SessionField\n   */\n  export interface AsProtobufJSON {\n    sessionRawField: SessionRawField.AsProtobufJSON | null;\n    taskOptionField: TaskOptionField.AsProtobufJSON | null;\n    taskOptionGenericField: TaskOptionGenericField.AsProtobufJSON | null;\n  }\n  export enum FieldCase {\n    none = 0,\n    sessionRawField = 1,\n    taskOptionField = 2,\n    taskOptionGenericField = 3\n  }\n}\n"]}