@aneoconsultingfr/armonik.api.angular/lib/generated/objects.pb.d.ts

gRPC API to interact with ArmoniK built for Angular

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 namespace 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 namespace 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;
    }
    namespace 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 namespace 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 namespace 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 namespace 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;
    }
    namespace 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;
    private _payloadName;
    /**
     * 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);
    get payloadName(): string;
    set payloadName(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(): 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 namespace TaskRequest {
    /**
     * Standard JavaScript object representation for TaskRequest
     */
    interface AsObject {
        expectedOutputKeys: string[];
        dataDependencies: string[];
        payload: Uint8Array;
        payloadName: string;
    }
    /**
     * Protobuf JSON representation for TaskRequest
     */
    interface AsProtobufJSON {
        expectedOutputKeys: string[];
        dataDependencies: string[];
        payload: string;
        payloadName: 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 namespace 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 namespace 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 namespace 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 namespace 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 namespace 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 namespace 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 namespace 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 namespace 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://develo