@aneoconsultingfr/armonik.api.angular 3.4.0

package/lib/generated/objects.pb.d.ts

@@ -0,0 +1,1673 @@
+import { GrpcMessage, RecursivePartial, ToProtobufJSONOptions } from '@ngx-grpc/common';
+import { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+import * as armonikApiGrpcV1Task_status001 from './task-status.pb';
+/**
+ * Message implementation for armonik.api.grpc.v1.Empty
+ */
+export declare class Empty implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Empty;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Empty): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Empty, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Empty, _writer: BinaryWriter): void;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Empty to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Empty.AsObject>);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Empty.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Empty.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Empty.AsProtobufJSON;
+}
+export declare module Empty {
+    /**
+     * Standard JavaScript object representation for Empty
+     */
+    interface AsObject {
+    }
+    /**
+     * Protobuf JSON representation for Empty
+     */
+    interface AsProtobufJSON {
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskOptions
+ */
+export declare class TaskOptions implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskOptions;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskOptions): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskOptions, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskOptions, _writer: BinaryWriter): void;
+    private _options;
+    private _maxDuration?;
+    private _maxRetries;
+    private _priority;
+    private _partitionId;
+    private _applicationName;
+    private _applicationVersion;
+    private _applicationNamespace;
+    private _applicationService;
+    private _engineType;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOptions to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskOptions.AsObject>);
+    get options(): {
+        [prop: string]: string;
+    };
+    set options(value: {
+        [prop: string]: string;
+    });
+    get maxDuration(): googleProtobuf000.Duration | undefined;
+    set maxDuration(value: googleProtobuf000.Duration | undefined);
+    get maxRetries(): number;
+    set maxRetries(value: number);
+    get priority(): number;
+    set priority(value: number);
+    get partitionId(): string;
+    set partitionId(value: string);
+    get applicationName(): string;
+    set applicationName(value: string);
+    get applicationVersion(): string;
+    set applicationVersion(value: string);
+    get applicationNamespace(): string;
+    set applicationNamespace(value: string);
+    get applicationService(): string;
+    set applicationService(value: string);
+    get engineType(): string;
+    set engineType(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskOptions.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskOptions.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskOptions.AsProtobufJSON;
+}
+export declare module TaskOptions {
+    /**
+     * Standard JavaScript object representation for TaskOptions
+     */
+    interface AsObject {
+        options: {
+            [prop: string]: string;
+        };
+        maxDuration?: googleProtobuf000.Duration.AsObject;
+        maxRetries: number;
+        priority: number;
+        partitionId: string;
+        applicationName: string;
+        applicationVersion: string;
+        applicationNamespace: string;
+        applicationService: string;
+        engineType: string;
+    }
+    /**
+     * Protobuf JSON representation for TaskOptions
+     */
+    interface AsProtobufJSON {
+        options: {
+            [prop: string]: string;
+        };
+        maxDuration: googleProtobuf000.Duration.AsProtobufJSON | null;
+        maxRetries: number;
+        priority: number;
+        partitionId: string;
+        applicationName: string;
+        applicationVersion: string;
+        applicationNamespace: string;
+        applicationService: string;
+        engineType: string;
+    }
+    /**
+     * Message implementation for armonik.api.grpc.v1.TaskOptions.OptionsEntry
+     */
+    class OptionsEntry implements GrpcMessage {
+        static id: string;
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes: ByteSource): OptionsEntry;
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance: OptionsEntry): void;
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance: OptionsEntry, _reader: BinaryReader): void;
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance: OptionsEntry, _writer: BinaryWriter): void;
+        private _key;
+        private _value;
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of OptionsEntry to deeply clone from
+         */
+        constructor(_value?: RecursivePartial<OptionsEntry.AsObject>);
+        get key(): string;
+        set key(value: string);
+        get value(): string;
+        set value(value: string);
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary(): Uint8Array;
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject(): OptionsEntry.AsObject;
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON(): OptionsEntry.AsObject;
+        /**
+         * 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(options?: ToProtobufJSONOptions): OptionsEntry.AsProtobufJSON;
+    }
+    module OptionsEntry {
+        /**
+         * Standard JavaScript object representation for OptionsEntry
+         */
+        interface AsObject {
+            key: string;
+            value: string;
+        }
+        /**
+         * Protobuf JSON representation for OptionsEntry
+         */
+        interface AsProtobufJSON {
+            key: string;
+            value: string;
+        }
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.Session
+ */
+export declare class Session implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Session;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Session): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Session, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Session, _writer: BinaryWriter): void;
+    private _id;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Session to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Session.AsObject>);
+    get id(): string;
+    set id(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Session.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Session.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Session.AsProtobufJSON;
+}
+export declare module Session {
+    /**
+     * Standard JavaScript object representation for Session
+     */
+    interface AsObject {
+        id: string;
+    }
+    /**
+     * Protobuf JSON representation for Session
+     */
+    interface AsProtobufJSON {
+        id: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.Configuration
+ */
+export declare class Configuration implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Configuration;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Configuration): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Configuration, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Configuration, _writer: BinaryWriter): void;
+    private _dataChunkMaxSize;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Configuration to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Configuration.AsObject>);
+    get dataChunkMaxSize(): number;
+    set dataChunkMaxSize(value: number);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Configuration.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Configuration.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Configuration.AsProtobufJSON;
+}
+export declare module Configuration {
+    /**
+     * Standard JavaScript object representation for Configuration
+     */
+    interface AsObject {
+        dataChunkMaxSize: number;
+    }
+    /**
+     * Protobuf JSON representation for Configuration
+     */
+    interface AsProtobufJSON {
+        dataChunkMaxSize: number;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.Output
+ */
+export declare class Output implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Output;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Output): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Output, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Output, _writer: BinaryWriter): void;
+    private _ok?;
+    private _error?;
+    private _type;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Output to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Output.AsObject>);
+    get ok(): Empty | undefined;
+    set ok(value: Empty | undefined);
+    get error(): Output.Error | undefined;
+    set error(value: Output.Error | undefined);
+    get type(): Output.TypeCase;
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Output.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Output.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Output.AsProtobufJSON;
+}
+export declare module Output {
+    /**
+     * Standard JavaScript object representation for Output
+     */
+    interface AsObject {
+        ok?: Empty.AsObject;
+        error?: Output.Error.AsObject;
+    }
+    /**
+     * Protobuf JSON representation for Output
+     */
+    interface AsProtobufJSON {
+        ok: Empty.AsProtobufJSON | null;
+        error: Output.Error.AsProtobufJSON | null;
+    }
+    enum TypeCase {
+        none = 0,
+        ok = 1,
+        error = 2
+    }
+    /**
+     * Message implementation for armonik.api.grpc.v1.Output.Error
+     */
+    class Error implements GrpcMessage {
+        static id: string;
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes: ByteSource): Error;
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance: Error): void;
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance: Error, _reader: BinaryReader): void;
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance: Error, _writer: BinaryWriter): void;
+        private _details;
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Error to deeply clone from
+         */
+        constructor(_value?: RecursivePartial<Error.AsObject>);
+        get details(): string;
+        set details(value: string);
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary(): Uint8Array;
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject(): Error.AsObject;
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON(): Error.AsObject;
+        /**
+         * 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(options?: ToProtobufJSONOptions): Error.AsProtobufJSON;
+    }
+    module Error {
+        /**
+         * Standard JavaScript object representation for Error
+         */
+        interface AsObject {
+            details: string;
+        }
+        /**
+         * Protobuf JSON representation for Error
+         */
+        interface AsProtobufJSON {
+            details: string;
+        }
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskRequest
+ */
+export declare class TaskRequest implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskRequest;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskRequest): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskRequest, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskRequest, _writer: BinaryWriter): void;
+    private _expectedOutputKeys;
+    private _dataDependencies;
+    private _payload;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskRequest to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskRequest.AsObject>);
+    get expectedOutputKeys(): string[];
+    set expectedOutputKeys(value: string[]);
+    get dataDependencies(): string[];
+    set dataDependencies(value: string[]);
+    get payload(): Uint8Array;
+    set payload(value: Uint8Array);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskRequest.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskRequest.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskRequest.AsProtobufJSON;
+}
+export declare module TaskRequest {
+    /**
+     * Standard JavaScript object representation for TaskRequest
+     */
+    interface AsObject {
+        expectedOutputKeys: string[];
+        dataDependencies: string[];
+        payload: Uint8Array;
+    }
+    /**
+     * Protobuf JSON representation for TaskRequest
+     */
+    interface AsProtobufJSON {
+        expectedOutputKeys: string[];
+        dataDependencies: string[];
+        payload: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.InitKeyedDataStream
+ */
+export declare class InitKeyedDataStream implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): InitKeyedDataStream;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: InitKeyedDataStream): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: InitKeyedDataStream, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: InitKeyedDataStream, _writer: BinaryWriter): void;
+    private _key;
+    private _lastResult;
+    private _type;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of InitKeyedDataStream to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<InitKeyedDataStream.AsObject>);
+    get key(): string;
+    set key(value: string);
+    get lastResult(): boolean;
+    set lastResult(value: boolean);
+    get type(): InitKeyedDataStream.TypeCase;
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): InitKeyedDataStream.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): InitKeyedDataStream.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): InitKeyedDataStream.AsProtobufJSON;
+}
+export declare module InitKeyedDataStream {
+    /**
+     * Standard JavaScript object representation for InitKeyedDataStream
+     */
+    interface AsObject {
+        key: string;
+        lastResult: boolean;
+    }
+    /**
+     * Protobuf JSON representation for InitKeyedDataStream
+     */
+    interface AsProtobufJSON {
+        key: string | null;
+        lastResult: boolean;
+    }
+    enum TypeCase {
+        none = 0,
+        key = 1,
+        lastResult = 2
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.DataChunk
+ */
+export declare class DataChunk implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): DataChunk;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: DataChunk): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: DataChunk, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: DataChunk, _writer: BinaryWriter): void;
+    private _data;
+    private _dataComplete;
+    private _type;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DataChunk to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<DataChunk.AsObject>);
+    get data(): Uint8Array;
+    set data(value: Uint8Array);
+    get dataComplete(): boolean;
+    set dataComplete(value: boolean);
+    get type(): DataChunk.TypeCase;
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): DataChunk.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): DataChunk.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): DataChunk.AsProtobufJSON;
+}
+export declare module DataChunk {
+    /**
+     * Standard JavaScript object representation for DataChunk
+     */
+    interface AsObject {
+        data: Uint8Array;
+        dataComplete: boolean;
+    }
+    /**
+     * Protobuf JSON representation for DataChunk
+     */
+    interface AsProtobufJSON {
+        data: string;
+        dataComplete: boolean;
+    }
+    enum TypeCase {
+        none = 0,
+        data = 1,
+        dataComplete = 2
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskRequestHeader
+ */
+export declare class TaskRequestHeader implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskRequestHeader;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskRequestHeader): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskRequestHeader, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskRequestHeader, _writer: BinaryWriter): void;
+    private _expectedOutputKeys;
+    private _dataDependencies;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskRequestHeader to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskRequestHeader.AsObject>);
+    get expectedOutputKeys(): string[];
+    set expectedOutputKeys(value: string[]);
+    get dataDependencies(): string[];
+    set dataDependencies(value: string[]);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskRequestHeader.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskRequestHeader.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskRequestHeader.AsProtobufJSON;
+}
+export declare module TaskRequestHeader {
+    /**
+     * Standard JavaScript object representation for TaskRequestHeader
+     */
+    interface AsObject {
+        expectedOutputKeys: string[];
+        dataDependencies: string[];
+    }
+    /**
+     * Protobuf JSON representation for TaskRequestHeader
+     */
+    interface AsProtobufJSON {
+        expectedOutputKeys: string[];
+        dataDependencies: string[];
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.InitTaskRequest
+ */
+export declare class InitTaskRequest implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): InitTaskRequest;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: InitTaskRequest): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: InitTaskRequest, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: InitTaskRequest, _writer: BinaryWriter): void;
+    private _header?;
+    private _lastTask;
+    private _type;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of InitTaskRequest to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<InitTaskRequest.AsObject>);
+    get header(): TaskRequestHeader | undefined;
+    set header(value: TaskRequestHeader | undefined);
+    get lastTask(): boolean;
+    set lastTask(value: boolean);
+    get type(): InitTaskRequest.TypeCase;
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): InitTaskRequest.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): InitTaskRequest.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): InitTaskRequest.AsProtobufJSON;
+}
+export declare module InitTaskRequest {
+    /**
+     * Standard JavaScript object representation for InitTaskRequest
+     */
+    interface AsObject {
+        header?: TaskRequestHeader.AsObject;
+        lastTask: boolean;
+    }
+    /**
+     * Protobuf JSON representation for InitTaskRequest
+     */
+    interface AsProtobufJSON {
+        header: TaskRequestHeader.AsProtobufJSON | null;
+        lastTask: boolean;
+    }
+    enum TypeCase {
+        none = 0,
+        header = 1,
+        lastTask = 2
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskId
+ */
+export declare class TaskId implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskId;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskId): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskId, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskId, _writer: BinaryWriter): void;
+    private _session;
+    private _task;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskId to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskId.AsObject>);
+    get session(): string;
+    set session(value: string);
+    get task(): string;
+    set task(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskId.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskId.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskId.AsProtobufJSON;
+}
+export declare module TaskId {
+    /**
+     * Standard JavaScript object representation for TaskId
+     */
+    interface AsObject {
+        session: string;
+        task: string;
+    }
+    /**
+     * Protobuf JSON representation for TaskId
+     */
+    interface AsProtobufJSON {
+        session: string;
+        task: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskIdList
+ */
+export declare class TaskIdList implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskIdList;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskIdList): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskIdList, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskIdList, _writer: BinaryWriter): void;
+    private _taskIds;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskIdList to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskIdList.AsObject>);
+    get taskIds(): string[];
+    set taskIds(value: string[]);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskIdList.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskIdList.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskIdList.AsProtobufJSON;
+}
+export declare module TaskIdList {
+    /**
+     * Standard JavaScript object representation for TaskIdList
+     */
+    interface AsObject {
+        taskIds: string[];
+    }
+    /**
+     * Protobuf JSON representation for TaskIdList
+     */
+    interface AsProtobufJSON {
+        taskIds: string[];
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.StatusCount
+ */
+export declare class StatusCount implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): StatusCount;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: StatusCount): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: StatusCount, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: StatusCount, _writer: BinaryWriter): void;
+    private _status;
+    private _count;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of StatusCount to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<StatusCount.AsObject>);
+    get status(): armonikApiGrpcV1Task_status001.TaskStatus;
+    set status(value: armonikApiGrpcV1Task_status001.TaskStatus);
+    get count(): number;
+    set count(value: number);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): StatusCount.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): StatusCount.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): StatusCount.AsProtobufJSON;
+}
+export declare module StatusCount {
+    /**
+     * Standard JavaScript object representation for StatusCount
+     */
+    interface AsObject {
+        status: armonikApiGrpcV1Task_status001.TaskStatus;
+        count: number;
+    }
+    /**
+     * Protobuf JSON representation for StatusCount
+     */
+    interface AsProtobufJSON {
+        status: string;
+        count: number;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.Count
+ */
+export declare class Count implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Count;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Count): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Count, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Count, _writer: BinaryWriter): void;
+    private _values?;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Count to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Count.AsObject>);
+    get values(): StatusCount[] | undefined;
+    set values(value: StatusCount[] | undefined);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Count.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Count.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Count.AsProtobufJSON;
+}
+export declare module Count {
+    /**
+     * Standard JavaScript object representation for Count
+     */
+    interface AsObject {
+        values?: StatusCount.AsObject[];
+    }
+    /**
+     * Protobuf JSON representation for Count
+     */
+    interface AsProtobufJSON {
+        values: StatusCount.AsProtobufJSON[] | null;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.ResultRequest
+ */
+export declare class ResultRequest implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): ResultRequest;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: ResultRequest): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: ResultRequest, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: ResultRequest, _writer: BinaryWriter): void;
+    private _session;
+    private _resultId;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ResultRequest to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<ResultRequest.AsObject>);
+    get session(): string;
+    set session(value: string);
+    get resultId(): string;
+    set resultId(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): ResultRequest.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): ResultRequest.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): ResultRequest.AsProtobufJSON;
+}
+export declare module ResultRequest {
+    /**
+     * Standard JavaScript object representation for ResultRequest
+     */
+    interface AsObject {
+        session: string;
+        resultId: string;
+    }
+    /**
+     * Protobuf JSON representation for ResultRequest
+     */
+    interface AsProtobufJSON {
+        session: string;
+        resultId: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskOutputRequest
+ */
+export declare class TaskOutputRequest implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskOutputRequest;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskOutputRequest): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskOutputRequest, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskOutputRequest, _writer: BinaryWriter): void;
+    private _session;
+    private _taskId;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOutputRequest to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskOutputRequest.AsObject>);
+    get session(): string;
+    set session(value: string);
+    get taskId(): string;
+    set taskId(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskOutputRequest.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskOutputRequest.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskOutputRequest.AsProtobufJSON;
+}
+export declare module TaskOutputRequest {
+    /**
+     * Standard JavaScript object representation for TaskOutputRequest
+     */
+    interface AsObject {
+        session: string;
+        taskId: string;
+    }
+    /**
+     * Protobuf JSON representation for TaskOutputRequest
+     */
+    interface AsProtobufJSON {
+        session: string;
+        taskId: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.Error
+ */
+export declare class Error implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): Error;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: Error): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: Error, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: Error, _writer: BinaryWriter): void;
+    private _taskStatus;
+    private _detail;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Error to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<Error.AsObject>);
+    get taskStatus(): armonikApiGrpcV1Task_status001.TaskStatus;
+    set taskStatus(value: armonikApiGrpcV1Task_status001.TaskStatus);
+    get detail(): string;
+    set detail(value: string);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): Error.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): Error.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): Error.AsProtobufJSON;
+}
+export declare module Error {
+    /**
+     * Standard JavaScript object representation for Error
+     */
+    interface AsObject {
+        taskStatus: armonikApiGrpcV1Task_status001.TaskStatus;
+        detail: string;
+    }
+    /**
+     * Protobuf JSON representation for Error
+     */
+    interface AsProtobufJSON {
+        taskStatus: string;
+        detail: string;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskError
+ */
+export declare class TaskError implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskError;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskError): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskError, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskError, _writer: BinaryWriter): void;
+    private _taskId;
+    private _errors?;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskError to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskError.AsObject>);
+    get taskId(): string;
+    set taskId(value: string);
+    get errors(): Error[] | undefined;
+    set errors(value: Error[] | undefined);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskError.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskError.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskError.AsProtobufJSON;
+}
+export declare module TaskError {
+    /**
+     * Standard JavaScript object representation for TaskError
+     */
+    interface AsObject {
+        taskId: string;
+        errors?: Error.AsObject[];
+    }
+    /**
+     * Protobuf JSON representation for TaskError
+     */
+    interface AsProtobufJSON {
+        taskId: string;
+        errors: Error.AsProtobufJSON[] | null;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskList
+ */
+export declare class TaskList implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskList;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskList): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskList, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskList, _writer: BinaryWriter): void;
+    private _taskIds?;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskList to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskList.AsObject>);
+    get taskIds(): TaskId[] | undefined;
+    set taskIds(value: TaskId[] | undefined);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskList.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskList.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskList.AsProtobufJSON;
+}
+export declare module TaskList {
+    /**
+     * Standard JavaScript object representation for TaskList
+     */
+    interface AsObject {
+        taskIds?: TaskId.AsObject[];
+    }
+    /**
+     * Protobuf JSON representation for TaskList
+     */
+    interface AsProtobufJSON {
+        taskIds: TaskId.AsProtobufJSON[] | null;
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskIdWithStatus
+ */
+export declare class TaskIdWithStatus implements GrpcMessage {
+    static id: string;
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes: ByteSource): TaskIdWithStatus;
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance: TaskIdWithStatus): void;
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance: TaskIdWithStatus, _reader: BinaryReader): void;
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance: TaskIdWithStatus, _writer: BinaryWriter): void;
+    private _taskId?;
+    private _status;
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskIdWithStatus to deeply clone from
+     */
+    constructor(_value?: RecursivePartial<TaskIdWithStatus.AsObject>);
+    get taskId(): TaskId | undefined;
+    set taskId(value: TaskId | undefined);
+    get status(): armonikApiGrpcV1Task_status001.TaskStatus;
+    set status(value: armonikApiGrpcV1Task_status001.TaskStatus);
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary(): Uint8Array;
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject(): TaskIdWithStatus.AsObject;
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON(): TaskIdWithStatus.AsObject;
+    /**
+     * 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(options?: ToProtobufJSONOptions): TaskIdWithStatus.AsProtobufJSON;
+}
+export declare module TaskIdWithStatus {
+    /**
+     * Standard JavaScript object representation for TaskIdWithStatus
+     */
+    interface AsObject {
+        taskId?: TaskId.AsObject;
+        status: armonikApiGrpcV1Task_status001.TaskStatus;
+    }
+    /**
+     * Protobuf JSON representation for TaskIdWithStatus
+     */
+    interface AsProtobufJSON {
+        taskId: TaskId.AsProtobufJSON | null;
+        status: string;
+    }
+}