@headspace/protos-events 1.296.0 → 1.297.0

package/lib/index.js

@@ -24892,6 +24892,785 @@ $root.elf = (function() {
         return ImportJob;
     })();
 
+    elf.NormalizationJob = (function() {
+
+        /**
+         * Properties of a NormalizationJob.
+         * @memberof elf
+         * @interface INormalizationJob
+         * @property {string|null} [s3Bucket] NormalizationJob s3Bucket
+         * @property {string|null} [s3Key] NormalizationJob s3Key
+         * @property {string|null} [elfKeyField] NormalizationJob elfKeyField
+         * @property {Array.<string>|null} [elfRequiredFields] NormalizationJob elfRequiredFields
+         * @property {Object.<string,string>|null} [customVariables] NormalizationJob customVariables
+         */
+
+        /**
+         * Constructs a new NormalizationJob.
+         * @memberof elf
+         * @classdesc Represents a NormalizationJob.
+         * @implements INormalizationJob
+         * @constructor
+         * @param {elf.INormalizationJob=} [properties] Properties to set
+         */
+        function NormalizationJob(properties) {
+            this.elfRequiredFields = [];
+            this.customVariables = {};
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * NormalizationJob s3Bucket.
+         * @member {string} s3Bucket
+         * @memberof elf.NormalizationJob
+         * @instance
+         */
+        NormalizationJob.prototype.s3Bucket = "";
+
+        /**
+         * NormalizationJob s3Key.
+         * @member {string} s3Key
+         * @memberof elf.NormalizationJob
+         * @instance
+         */
+        NormalizationJob.prototype.s3Key = "";
+
+        /**
+         * NormalizationJob elfKeyField.
+         * @member {string} elfKeyField
+         * @memberof elf.NormalizationJob
+         * @instance
+         */
+        NormalizationJob.prototype.elfKeyField = "";
+
+        /**
+         * NormalizationJob elfRequiredFields.
+         * @member {Array.<string>} elfRequiredFields
+         * @memberof elf.NormalizationJob
+         * @instance
+         */
+        NormalizationJob.prototype.elfRequiredFields = $util.emptyArray;
+
+        /**
+         * NormalizationJob customVariables.
+         * @member {Object.<string,string>} customVariables
+         * @memberof elf.NormalizationJob
+         * @instance
+         */
+        NormalizationJob.prototype.customVariables = $util.emptyObject;
+
+        /**
+         * Creates a new NormalizationJob instance using the specified properties.
+         * @function create
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {elf.INormalizationJob=} [properties] Properties to set
+         * @returns {elf.NormalizationJob} NormalizationJob instance
+         */
+        NormalizationJob.create = function create(properties) {
+            return new NormalizationJob(properties);
+        };
+
+        /**
+         * Encodes the specified NormalizationJob message. Does not implicitly {@link elf.NormalizationJob.verify|verify} messages.
+         * @function encode
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {elf.INormalizationJob} message NormalizationJob message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJob.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.s3Bucket);
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                writer.uint32(/* id 2, wireType 2 =*/18).string(message.s3Key);
+            if (message.elfKeyField != null && message.hasOwnProperty("elfKeyField"))
+                writer.uint32(/* id 3, wireType 2 =*/26).string(message.elfKeyField);
+            if (message.elfRequiredFields != null && message.elfRequiredFields.length)
+                for (var i = 0; i < message.elfRequiredFields.length; ++i)
+                    writer.uint32(/* id 4, wireType 2 =*/34).string(message.elfRequiredFields[i]);
+            if (message.customVariables != null && message.hasOwnProperty("customVariables"))
+                for (var keys = Object.keys(message.customVariables), i = 0; i < keys.length; ++i)
+                    writer.uint32(/* id 5, wireType 2 =*/42).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.customVariables[keys[i]]).ldelim();
+            return writer;
+        };
+
+        /**
+         * Encodes the specified NormalizationJob message, length delimited. Does not implicitly {@link elf.NormalizationJob.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {elf.INormalizationJob} message NormalizationJob message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJob.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a NormalizationJob message from the specified reader or buffer.
+         * @function decode
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {elf.NormalizationJob} NormalizationJob
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJob.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.elf.NormalizationJob(), key;
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.s3Bucket = reader.string();
+                    break;
+                case 2:
+                    message.s3Key = reader.string();
+                    break;
+                case 3:
+                    message.elfKeyField = reader.string();
+                    break;
+                case 4:
+                    if (!(message.elfRequiredFields && message.elfRequiredFields.length))
+                        message.elfRequiredFields = [];
+                    message.elfRequiredFields.push(reader.string());
+                    break;
+                case 5:
+                    reader.skip().pos++;
+                    if (message.customVariables === $util.emptyObject)
+                        message.customVariables = {};
+                    key = reader.string();
+                    reader.pos++;
+                    message.customVariables[key] = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a NormalizationJob message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {elf.NormalizationJob} NormalizationJob
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJob.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a NormalizationJob message.
+         * @function verify
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        NormalizationJob.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                if (!$util.isString(message.s3Bucket))
+                    return "s3Bucket: string expected";
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                if (!$util.isString(message.s3Key))
+                    return "s3Key: string expected";
+            if (message.elfKeyField != null && message.hasOwnProperty("elfKeyField"))
+                if (!$util.isString(message.elfKeyField))
+                    return "elfKeyField: string expected";
+            if (message.elfRequiredFields != null && message.hasOwnProperty("elfRequiredFields")) {
+                if (!Array.isArray(message.elfRequiredFields))
+                    return "elfRequiredFields: array expected";
+                for (var i = 0; i < message.elfRequiredFields.length; ++i)
+                    if (!$util.isString(message.elfRequiredFields[i]))
+                        return "elfRequiredFields: string[] expected";
+            }
+            if (message.customVariables != null && message.hasOwnProperty("customVariables")) {
+                if (!$util.isObject(message.customVariables))
+                    return "customVariables: object expected";
+                var key = Object.keys(message.customVariables);
+                for (var i = 0; i < key.length; ++i)
+                    if (!$util.isString(message.customVariables[key[i]]))
+                        return "customVariables: string{k:string} expected";
+            }
+            return null;
+        };
+
+        /**
+         * Creates a NormalizationJob message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {elf.NormalizationJob} NormalizationJob
+         */
+        NormalizationJob.fromObject = function fromObject(object) {
+            if (object instanceof $root.elf.NormalizationJob)
+                return object;
+            var message = new $root.elf.NormalizationJob();
+            if (object.s3Bucket != null)
+                message.s3Bucket = String(object.s3Bucket);
+            if (object.s3Key != null)
+                message.s3Key = String(object.s3Key);
+            if (object.elfKeyField != null)
+                message.elfKeyField = String(object.elfKeyField);
+            if (object.elfRequiredFields) {
+                if (!Array.isArray(object.elfRequiredFields))
+                    throw TypeError(".elf.NormalizationJob.elfRequiredFields: array expected");
+                message.elfRequiredFields = [];
+                for (var i = 0; i < object.elfRequiredFields.length; ++i)
+                    message.elfRequiredFields[i] = String(object.elfRequiredFields[i]);
+            }
+            if (object.customVariables) {
+                if (typeof object.customVariables !== "object")
+                    throw TypeError(".elf.NormalizationJob.customVariables: object expected");
+                message.customVariables = {};
+                for (var keys = Object.keys(object.customVariables), i = 0; i < keys.length; ++i)
+                    message.customVariables[keys[i]] = String(object.customVariables[keys[i]]);
+            }
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a NormalizationJob message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof elf.NormalizationJob
+         * @static
+         * @param {elf.NormalizationJob} message NormalizationJob
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        NormalizationJob.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.arrays || options.defaults)
+                object.elfRequiredFields = [];
+            if (options.objects || options.defaults)
+                object.customVariables = {};
+            if (options.defaults) {
+                object.s3Bucket = "";
+                object.s3Key = "";
+                object.elfKeyField = "";
+            }
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                object.s3Bucket = message.s3Bucket;
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                object.s3Key = message.s3Key;
+            if (message.elfKeyField != null && message.hasOwnProperty("elfKeyField"))
+                object.elfKeyField = message.elfKeyField;
+            if (message.elfRequiredFields && message.elfRequiredFields.length) {
+                object.elfRequiredFields = [];
+                for (var j = 0; j < message.elfRequiredFields.length; ++j)
+                    object.elfRequiredFields[j] = message.elfRequiredFields[j];
+            }
+            var keys2;
+            if (message.customVariables && (keys2 = Object.keys(message.customVariables)).length) {
+                object.customVariables = {};
+                for (var j = 0; j < keys2.length; ++j)
+                    object.customVariables[keys2[j]] = message.customVariables[keys2[j]];
+            }
+            return object;
+        };
+
+        /**
+         * Converts this NormalizationJob to JSON.
+         * @function toJSON
+         * @memberof elf.NormalizationJob
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        NormalizationJob.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return NormalizationJob;
+    })();
+
+    elf.NormalizationJobResult = (function() {
+
+        /**
+         * Properties of a NormalizationJobResult.
+         * @memberof elf
+         * @interface INormalizationJobResult
+         * @property {string|null} [s3Bucket] NormalizationJobResult s3Bucket
+         * @property {string|null} [s3Key] NormalizationJobResult s3Key
+         * @property {Object.<string,number>|null} [counters] NormalizationJobResult counters
+         */
+
+        /**
+         * Constructs a new NormalizationJobResult.
+         * @memberof elf
+         * @classdesc Represents a NormalizationJobResult.
+         * @implements INormalizationJobResult
+         * @constructor
+         * @param {elf.INormalizationJobResult=} [properties] Properties to set
+         */
+        function NormalizationJobResult(properties) {
+            this.counters = {};
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * NormalizationJobResult s3Bucket.
+         * @member {string} s3Bucket
+         * @memberof elf.NormalizationJobResult
+         * @instance
+         */
+        NormalizationJobResult.prototype.s3Bucket = "";
+
+        /**
+         * NormalizationJobResult s3Key.
+         * @member {string} s3Key
+         * @memberof elf.NormalizationJobResult
+         * @instance
+         */
+        NormalizationJobResult.prototype.s3Key = "";
+
+        /**
+         * NormalizationJobResult counters.
+         * @member {Object.<string,number>} counters
+         * @memberof elf.NormalizationJobResult
+         * @instance
+         */
+        NormalizationJobResult.prototype.counters = $util.emptyObject;
+
+        /**
+         * Creates a new NormalizationJobResult instance using the specified properties.
+         * @function create
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {elf.INormalizationJobResult=} [properties] Properties to set
+         * @returns {elf.NormalizationJobResult} NormalizationJobResult instance
+         */
+        NormalizationJobResult.create = function create(properties) {
+            return new NormalizationJobResult(properties);
+        };
+
+        /**
+         * Encodes the specified NormalizationJobResult message. Does not implicitly {@link elf.NormalizationJobResult.verify|verify} messages.
+         * @function encode
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {elf.INormalizationJobResult} message NormalizationJobResult message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJobResult.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.s3Bucket);
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                writer.uint32(/* id 2, wireType 2 =*/18).string(message.s3Key);
+            if (message.counters != null && message.hasOwnProperty("counters"))
+                for (var keys = Object.keys(message.counters), i = 0; i < keys.length; ++i)
+                    writer.uint32(/* id 3, wireType 2 =*/26).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 0 =*/16).int32(message.counters[keys[i]]).ldelim();
+            return writer;
+        };
+
+        /**
+         * Encodes the specified NormalizationJobResult message, length delimited. Does not implicitly {@link elf.NormalizationJobResult.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {elf.INormalizationJobResult} message NormalizationJobResult message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJobResult.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a NormalizationJobResult message from the specified reader or buffer.
+         * @function decode
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {elf.NormalizationJobResult} NormalizationJobResult
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJobResult.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.elf.NormalizationJobResult(), key;
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.s3Bucket = reader.string();
+                    break;
+                case 2:
+                    message.s3Key = reader.string();
+                    break;
+                case 3:
+                    reader.skip().pos++;
+                    if (message.counters === $util.emptyObject)
+                        message.counters = {};
+                    key = reader.string();
+                    reader.pos++;
+                    message.counters[key] = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a NormalizationJobResult message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {elf.NormalizationJobResult} NormalizationJobResult
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJobResult.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a NormalizationJobResult message.
+         * @function verify
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        NormalizationJobResult.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                if (!$util.isString(message.s3Bucket))
+                    return "s3Bucket: string expected";
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                if (!$util.isString(message.s3Key))
+                    return "s3Key: string expected";
+            if (message.counters != null && message.hasOwnProperty("counters")) {
+                if (!$util.isObject(message.counters))
+                    return "counters: object expected";
+                var key = Object.keys(message.counters);
+                for (var i = 0; i < key.length; ++i)
+                    if (!$util.isInteger(message.counters[key[i]]))
+                        return "counters: integer{k:string} expected";
+            }
+            return null;
+        };
+
+        /**
+         * Creates a NormalizationJobResult message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {elf.NormalizationJobResult} NormalizationJobResult
+         */
+        NormalizationJobResult.fromObject = function fromObject(object) {
+            if (object instanceof $root.elf.NormalizationJobResult)
+                return object;
+            var message = new $root.elf.NormalizationJobResult();
+            if (object.s3Bucket != null)
+                message.s3Bucket = String(object.s3Bucket);
+            if (object.s3Key != null)
+                message.s3Key = String(object.s3Key);
+            if (object.counters) {
+                if (typeof object.counters !== "object")
+                    throw TypeError(".elf.NormalizationJobResult.counters: object expected");
+                message.counters = {};
+                for (var keys = Object.keys(object.counters), i = 0; i < keys.length; ++i)
+                    message.counters[keys[i]] = object.counters[keys[i]] | 0;
+            }
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a NormalizationJobResult message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof elf.NormalizationJobResult
+         * @static
+         * @param {elf.NormalizationJobResult} message NormalizationJobResult
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        NormalizationJobResult.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.objects || options.defaults)
+                object.counters = {};
+            if (options.defaults) {
+                object.s3Bucket = "";
+                object.s3Key = "";
+            }
+            if (message.s3Bucket != null && message.hasOwnProperty("s3Bucket"))
+                object.s3Bucket = message.s3Bucket;
+            if (message.s3Key != null && message.hasOwnProperty("s3Key"))
+                object.s3Key = message.s3Key;
+            var keys2;
+            if (message.counters && (keys2 = Object.keys(message.counters)).length) {
+                object.counters = {};
+                for (var j = 0; j < keys2.length; ++j)
+                    object.counters[keys2[j]] = message.counters[keys2[j]];
+            }
+            return object;
+        };
+
+        /**
+         * Converts this NormalizationJobResult to JSON.
+         * @function toJSON
+         * @memberof elf.NormalizationJobResult
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        NormalizationJobResult.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return NormalizationJobResult;
+    })();
+
+    elf.NormalizationJobError = (function() {
+
+        /**
+         * Properties of a NormalizationJobError.
+         * @memberof elf
+         * @interface INormalizationJobError
+         * @property {string|null} [code] NormalizationJobError code
+         * @property {string|null} [message] NormalizationJobError message
+         */
+
+        /**
+         * Constructs a new NormalizationJobError.
+         * @memberof elf
+         * @classdesc Represents a NormalizationJobError.
+         * @implements INormalizationJobError
+         * @constructor
+         * @param {elf.INormalizationJobError=} [properties] Properties to set
+         */
+        function NormalizationJobError(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * NormalizationJobError code.
+         * @member {string} code
+         * @memberof elf.NormalizationJobError
+         * @instance
+         */
+        NormalizationJobError.prototype.code = "";
+
+        /**
+         * NormalizationJobError message.
+         * @member {string} message
+         * @memberof elf.NormalizationJobError
+         * @instance
+         */
+        NormalizationJobError.prototype.message = "";
+
+        /**
+         * Creates a new NormalizationJobError instance using the specified properties.
+         * @function create
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {elf.INormalizationJobError=} [properties] Properties to set
+         * @returns {elf.NormalizationJobError} NormalizationJobError instance
+         */
+        NormalizationJobError.create = function create(properties) {
+            return new NormalizationJobError(properties);
+        };
+
+        /**
+         * Encodes the specified NormalizationJobError message. Does not implicitly {@link elf.NormalizationJobError.verify|verify} messages.
+         * @function encode
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {elf.INormalizationJobError} message NormalizationJobError message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJobError.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.code != null && message.hasOwnProperty("code"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.code);
+            if (message.message != null && message.hasOwnProperty("message"))
+                writer.uint32(/* id 2, wireType 2 =*/18).string(message.message);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified NormalizationJobError message, length delimited. Does not implicitly {@link elf.NormalizationJobError.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {elf.INormalizationJobError} message NormalizationJobError message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        NormalizationJobError.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a NormalizationJobError message from the specified reader or buffer.
+         * @function decode
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {elf.NormalizationJobError} NormalizationJobError
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJobError.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.elf.NormalizationJobError();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.string();
+                    break;
+                case 2:
+                    message.message = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a NormalizationJobError message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {elf.NormalizationJobError} NormalizationJobError
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        NormalizationJobError.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a NormalizationJobError message.
+         * @function verify
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        NormalizationJobError.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.code != null && message.hasOwnProperty("code"))
+                if (!$util.isString(message.code))
+                    return "code: string expected";
+            if (message.message != null && message.hasOwnProperty("message"))
+                if (!$util.isString(message.message))
+                    return "message: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a NormalizationJobError message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {elf.NormalizationJobError} NormalizationJobError
+         */
+        NormalizationJobError.fromObject = function fromObject(object) {
+            if (object instanceof $root.elf.NormalizationJobError)
+                return object;
+            var message = new $root.elf.NormalizationJobError();
+            if (object.code != null)
+                message.code = String(object.code);
+            if (object.message != null)
+                message.message = String(object.message);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a NormalizationJobError message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof elf.NormalizationJobError
+         * @static
+         * @param {elf.NormalizationJobError} message NormalizationJobError
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        NormalizationJobError.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                object.code = "";
+                object.message = "";
+            }
+            if (message.code != null && message.hasOwnProperty("code"))
+                object.code = message.code;
+            if (message.message != null && message.hasOwnProperty("message"))
+                object.message = message.message;
+            return object;
+        };
+
+        /**
+         * Converts this NormalizationJobError to JSON.
+         * @function toJSON
+         * @memberof elf.NormalizationJobError
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        NormalizationJobError.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return NormalizationJobError;
+    })();
+
     return elf;
 })();
 
@@ -80084,6 +80863,446 @@ $root.ElfImportJobRejected = (function() {
     return ElfImportJobRejected;
 })();
 
+$root.ElfNormalizationJobCompleted = (function() {
+
+    /**
+     * Properties of an ElfNormalizationJobCompleted.
+     * @exports IElfNormalizationJobCompleted
+     * @interface IElfNormalizationJobCompleted
+     * @property {elf.INormalizationJob|null} [job] ElfNormalizationJobCompleted job
+     * @property {elf.INormalizationJobResult|null} [result] ElfNormalizationJobCompleted result
+     */
+
+    /**
+     * Constructs a new ElfNormalizationJobCompleted.
+     * @exports ElfNormalizationJobCompleted
+     * @classdesc Represents an ElfNormalizationJobCompleted.
+     * @implements IElfNormalizationJobCompleted
+     * @constructor
+     * @param {IElfNormalizationJobCompleted=} [properties] Properties to set
+     */
+    function ElfNormalizationJobCompleted(properties) {
+        if (properties)
+            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * ElfNormalizationJobCompleted job.
+     * @member {elf.INormalizationJob|null|undefined} job
+     * @memberof ElfNormalizationJobCompleted
+     * @instance
+     */
+    ElfNormalizationJobCompleted.prototype.job = null;
+
+    /**
+     * ElfNormalizationJobCompleted result.
+     * @member {elf.INormalizationJobResult|null|undefined} result
+     * @memberof ElfNormalizationJobCompleted
+     * @instance
+     */
+    ElfNormalizationJobCompleted.prototype.result = null;
+
+    /**
+     * Creates a new ElfNormalizationJobCompleted instance using the specified properties.
+     * @function create
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {IElfNormalizationJobCompleted=} [properties] Properties to set
+     * @returns {ElfNormalizationJobCompleted} ElfNormalizationJobCompleted instance
+     */
+    ElfNormalizationJobCompleted.create = function create(properties) {
+        return new ElfNormalizationJobCompleted(properties);
+    };
+
+    /**
+     * Encodes the specified ElfNormalizationJobCompleted message. Does not implicitly {@link ElfNormalizationJobCompleted.verify|verify} messages.
+     * @function encode
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {IElfNormalizationJobCompleted} message ElfNormalizationJobCompleted message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ElfNormalizationJobCompleted.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.job != null && message.hasOwnProperty("job"))
+            $root.elf.NormalizationJob.encode(message.job, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+        if (message.result != null && message.hasOwnProperty("result"))
+            $root.elf.NormalizationJobResult.encode(message.result, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+        return writer;
+    };
+
+    /**
+     * Encodes the specified ElfNormalizationJobCompleted message, length delimited. Does not implicitly {@link ElfNormalizationJobCompleted.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {IElfNormalizationJobCompleted} message ElfNormalizationJobCompleted message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ElfNormalizationJobCompleted.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes an ElfNormalizationJobCompleted message from the specified reader or buffer.
+     * @function decode
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ElfNormalizationJobCompleted} ElfNormalizationJobCompleted
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ElfNormalizationJobCompleted.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ElfNormalizationJobCompleted();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 1:
+                message.job = $root.elf.NormalizationJob.decode(reader, reader.uint32());
+                break;
+            case 2:
+                message.result = $root.elf.NormalizationJobResult.decode(reader, reader.uint32());
+                break;
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes an ElfNormalizationJobCompleted message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ElfNormalizationJobCompleted} ElfNormalizationJobCompleted
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ElfNormalizationJobCompleted.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies an ElfNormalizationJobCompleted message.
+     * @function verify
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    ElfNormalizationJobCompleted.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.job != null && message.hasOwnProperty("job")) {
+            var error = $root.elf.NormalizationJob.verify(message.job);
+            if (error)
+                return "job." + error;
+        }
+        if (message.result != null && message.hasOwnProperty("result")) {
+            var error = $root.elf.NormalizationJobResult.verify(message.result);
+            if (error)
+                return "result." + error;
+        }
+        return null;
+    };
+
+    /**
+     * Creates an ElfNormalizationJobCompleted message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ElfNormalizationJobCompleted} ElfNormalizationJobCompleted
+     */
+    ElfNormalizationJobCompleted.fromObject = function fromObject(object) {
+        if (object instanceof $root.ElfNormalizationJobCompleted)
+            return object;
+        var message = new $root.ElfNormalizationJobCompleted();
+        if (object.job != null) {
+            if (typeof object.job !== "object")
+                throw TypeError(".ElfNormalizationJobCompleted.job: object expected");
+            message.job = $root.elf.NormalizationJob.fromObject(object.job);
+        }
+        if (object.result != null) {
+            if (typeof object.result !== "object")
+                throw TypeError(".ElfNormalizationJobCompleted.result: object expected");
+            message.result = $root.elf.NormalizationJobResult.fromObject(object.result);
+        }
+        return message;
+    };
+
+    /**
+     * Creates a plain object from an ElfNormalizationJobCompleted message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ElfNormalizationJobCompleted
+     * @static
+     * @param {ElfNormalizationJobCompleted} message ElfNormalizationJobCompleted
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    ElfNormalizationJobCompleted.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        var object = {};
+        if (options.defaults) {
+            object.job = null;
+            object.result = null;
+        }
+        if (message.job != null && message.hasOwnProperty("job"))
+            object.job = $root.elf.NormalizationJob.toObject(message.job, options);
+        if (message.result != null && message.hasOwnProperty("result"))
+            object.result = $root.elf.NormalizationJobResult.toObject(message.result, options);
+        return object;
+    };
+
+    /**
+     * Converts this ElfNormalizationJobCompleted to JSON.
+     * @function toJSON
+     * @memberof ElfNormalizationJobCompleted
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    ElfNormalizationJobCompleted.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return ElfNormalizationJobCompleted;
+})();
+
+$root.ElfNormalizationJobFailed = (function() {
+
+    /**
+     * Properties of an ElfNormalizationJobFailed.
+     * @exports IElfNormalizationJobFailed
+     * @interface IElfNormalizationJobFailed
+     * @property {elf.INormalizationJob|null} [job] ElfNormalizationJobFailed job
+     * @property {elf.INormalizationJobError|null} [error] ElfNormalizationJobFailed error
+     */
+
+    /**
+     * Constructs a new ElfNormalizationJobFailed.
+     * @exports ElfNormalizationJobFailed
+     * @classdesc Represents an ElfNormalizationJobFailed.
+     * @implements IElfNormalizationJobFailed
+     * @constructor
+     * @param {IElfNormalizationJobFailed=} [properties] Properties to set
+     */
+    function ElfNormalizationJobFailed(properties) {
+        if (properties)
+            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * ElfNormalizationJobFailed job.
+     * @member {elf.INormalizationJob|null|undefined} job
+     * @memberof ElfNormalizationJobFailed
+     * @instance
+     */
+    ElfNormalizationJobFailed.prototype.job = null;
+
+    /**
+     * ElfNormalizationJobFailed error.
+     * @member {elf.INormalizationJobError|null|undefined} error
+     * @memberof ElfNormalizationJobFailed
+     * @instance
+     */
+    ElfNormalizationJobFailed.prototype.error = null;
+
+    /**
+     * Creates a new ElfNormalizationJobFailed instance using the specified properties.
+     * @function create
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {IElfNormalizationJobFailed=} [properties] Properties to set
+     * @returns {ElfNormalizationJobFailed} ElfNormalizationJobFailed instance
+     */
+    ElfNormalizationJobFailed.create = function create(properties) {
+        return new ElfNormalizationJobFailed(properties);
+    };
+
+    /**
+     * Encodes the specified ElfNormalizationJobFailed message. Does not implicitly {@link ElfNormalizationJobFailed.verify|verify} messages.
+     * @function encode
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {IElfNormalizationJobFailed} message ElfNormalizationJobFailed message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ElfNormalizationJobFailed.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.job != null && message.hasOwnProperty("job"))
+            $root.elf.NormalizationJob.encode(message.job, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+        if (message.error != null && message.hasOwnProperty("error"))
+            $root.elf.NormalizationJobError.encode(message.error, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+        return writer;
+    };
+
+    /**
+     * Encodes the specified ElfNormalizationJobFailed message, length delimited. Does not implicitly {@link ElfNormalizationJobFailed.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {IElfNormalizationJobFailed} message ElfNormalizationJobFailed message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ElfNormalizationJobFailed.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes an ElfNormalizationJobFailed message from the specified reader or buffer.
+     * @function decode
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ElfNormalizationJobFailed} ElfNormalizationJobFailed
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ElfNormalizationJobFailed.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ElfNormalizationJobFailed();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 1:
+                message.job = $root.elf.NormalizationJob.decode(reader, reader.uint32());
+                break;
+            case 2:
+                message.error = $root.elf.NormalizationJobError.decode(reader, reader.uint32());
+                break;
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes an ElfNormalizationJobFailed message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ElfNormalizationJobFailed} ElfNormalizationJobFailed
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ElfNormalizationJobFailed.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies an ElfNormalizationJobFailed message.
+     * @function verify
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    ElfNormalizationJobFailed.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.job != null && message.hasOwnProperty("job")) {
+            var error = $root.elf.NormalizationJob.verify(message.job);
+            if (error)
+                return "job." + error;
+        }
+        if (message.error != null && message.hasOwnProperty("error")) {
+            var error = $root.elf.NormalizationJobError.verify(message.error);
+            if (error)
+                return "error." + error;
+        }
+        return null;
+    };
+
+    /**
+     * Creates an ElfNormalizationJobFailed message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ElfNormalizationJobFailed} ElfNormalizationJobFailed
+     */
+    ElfNormalizationJobFailed.fromObject = function fromObject(object) {
+        if (object instanceof $root.ElfNormalizationJobFailed)
+            return object;
+        var message = new $root.ElfNormalizationJobFailed();
+        if (object.job != null) {
+            if (typeof object.job !== "object")
+                throw TypeError(".ElfNormalizationJobFailed.job: object expected");
+            message.job = $root.elf.NormalizationJob.fromObject(object.job);
+        }
+        if (object.error != null) {
+            if (typeof object.error !== "object")
+                throw TypeError(".ElfNormalizationJobFailed.error: object expected");
+            message.error = $root.elf.NormalizationJobError.fromObject(object.error);
+        }
+        return message;
+    };
+
+    /**
+     * Creates a plain object from an ElfNormalizationJobFailed message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ElfNormalizationJobFailed
+     * @static
+     * @param {ElfNormalizationJobFailed} message ElfNormalizationJobFailed
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    ElfNormalizationJobFailed.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        var object = {};
+        if (options.defaults) {
+            object.job = null;
+            object.error = null;
+        }
+        if (message.job != null && message.hasOwnProperty("job"))
+            object.job = $root.elf.NormalizationJob.toObject(message.job, options);
+        if (message.error != null && message.hasOwnProperty("error"))
+            object.error = $root.elf.NormalizationJobError.toObject(message.error, options);
+        return object;
+    };
+
+    /**
+     * Converts this ElfNormalizationJobFailed to JSON.
+     * @function toJSON
+     * @memberof ElfNormalizationJobFailed
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    ElfNormalizationJobFailed.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return ElfNormalizationJobFailed;
+})();
+
 $root.EnterpriseUserEnrollmentCreated = (function() {
 
     /**