@aneoconsultingfr/armonik.api.angular/lib/generated/results-common.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 armonikApiGrpcV1Result_status001 from './result-status.pb';
import * as armonikApiGrpcV1Results002 from './results-fields.pb';
import * as googleProtobuf003 from '@ngx-grpc/well-known-types';
import * as armonikApiGrpcV1Results004 from './results-filters.pb';
import * as armonikApiGrpcV1Sort_direction005 from './sort-direction.pb';
/**
 * Message implementation for armonik.api.grpc.v1.results.ResultRaw
 */
export declare class ResultRaw implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ResultRaw;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ResultRaw): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ResultRaw, _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: ResultRaw, _writer: BinaryWriter): void;
    private _sessionId;
    private _name;
    private _ownerTaskId;
    private _status;
    private _createdAt?;
    private _completedAt?;
    private _resultId;
    private _size;
    private _createdBy;
    private _opaqueId;
    private _manualDeletion;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ResultRaw to deeply clone from
     */
    constructor(_value?: RecursivePartial<ResultRaw.AsObject>);
    get sessionId(): string;
    set sessionId(value: string);
    get name(): string;
    set name(value: string);
    get ownerTaskId(): string;
    set ownerTaskId(value: string);
    get status(): armonikApiGrpcV1Result_status001.ResultStatus;
    set status(value: armonikApiGrpcV1Result_status001.ResultStatus);
    get createdAt(): googleProtobuf003.Timestamp | undefined;
    set createdAt(value: googleProtobuf003.Timestamp | undefined);
    get completedAt(): googleProtobuf003.Timestamp | undefined;
    set completedAt(value: googleProtobuf003.Timestamp | undefined);
    get resultId(): string;
    set resultId(value: string);
    get size(): string;
    set size(value: string);
    get createdBy(): string;
    set createdBy(value: string);
    get opaqueId(): Uint8Array;
    set opaqueId(value: Uint8Array);
    get manualDeletion(): boolean;
    set manualDeletion(value: boolean);
    /**
     * 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(): ResultRaw.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ResultRaw.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): ResultRaw.AsProtobufJSON;
}
export declare namespace ResultRaw {
    /**
     * Standard JavaScript object representation for ResultRaw
     */
    interface AsObject {
        sessionId: string;
        name: string;
        ownerTaskId: string;
        status: armonikApiGrpcV1Result_status001.ResultStatus;
        createdAt?: googleProtobuf003.Timestamp.AsObject;
        completedAt?: googleProtobuf003.Timestamp.AsObject;
        resultId: string;
        size: string;
        createdBy: string;
        opaqueId: Uint8Array;
        manualDeletion: boolean;
    }
    /**
     * Protobuf JSON representation for ResultRaw
     */
    interface AsProtobufJSON {
        sessionId: string;
        name: string;
        ownerTaskId: string;
        status: string;
        createdAt: googleProtobuf003.Timestamp.AsProtobufJSON | null;
        completedAt: googleProtobuf003.Timestamp.AsProtobufJSON | null;
        resultId: string;
        size: string;
        createdBy: string;
        opaqueId: string;
        manualDeletion: boolean;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest
 */
export declare class ListResultsRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListResultsRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListResultsRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListResultsRequest, _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: ListResultsRequest, _writer: BinaryWriter): void;
    private _page;
    private _pageSize;
    private _filters?;
    private _sort?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ListResultsRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListResultsRequest.AsObject>);
    get page(): number;
    set page(value: number);
    get pageSize(): number;
    set pageSize(value: number);
    get filters(): armonikApiGrpcV1Results004.Filters | undefined;
    set filters(value: armonikApiGrpcV1Results004.Filters | undefined);
    get sort(): ListResultsRequest.Sort | undefined;
    set sort(value: ListResultsRequest.Sort | 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(): ListResultsRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListResultsRequest.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): ListResultsRequest.AsProtobufJSON;
}
export declare namespace ListResultsRequest {
    /**
     * Standard JavaScript object representation for ListResultsRequest
     */
    interface AsObject {
        page: number;
        pageSize: number;
        filters?: armonikApiGrpcV1Results004.Filters.AsObject;
        sort?: ListResultsRequest.Sort.AsObject;
    }
    /**
     * Protobuf JSON representation for ListResultsRequest
     */
    interface AsProtobufJSON {
        page: number;
        pageSize: number;
        filters: armonikApiGrpcV1Results004.Filters.AsProtobufJSON | null;
        sort: ListResultsRequest.Sort.AsProtobufJSON | null;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest.Sort
     */
    class Sort implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): Sort;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: Sort): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: Sort, _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: Sort, _writer: BinaryWriter): void;
        private _field?;
        private _direction;
        /**
         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
         * @param _value initial values object or instance of Sort to deeply clone from
         */
        constructor(_value?: RecursivePartial<Sort.AsObject>);
        get field(): armonikApiGrpcV1Results002.ResultField | undefined;
        set field(value: armonikApiGrpcV1Results002.ResultField | undefined);
        get direction(): armonikApiGrpcV1Sort_direction005.SortDirection;
        set direction(value: armonikApiGrpcV1Sort_direction005.SortDirection);
        /**
         * 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(): Sort.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): Sort.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): Sort.AsProtobufJSON;
    }
    namespace Sort {
        /**
         * Standard JavaScript object representation for Sort
         */
        interface AsObject {
            field?: armonikApiGrpcV1Results002.ResultField.AsObject;
            direction: armonikApiGrpcV1Sort_direction005.SortDirection;
        }
        /**
         * Protobuf JSON representation for Sort
         */
        interface AsProtobufJSON {
            field: armonikApiGrpcV1Results002.ResultField.AsProtobufJSON | null;
            direction: string;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.ListResultsResponse
 */
export declare class ListResultsResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListResultsResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListResultsResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListResultsResponse, _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: ListResultsResponse, _writer: BinaryWriter): void;
    private _results?;
    private _page;
    private _pageSize;
    private _total;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ListResultsResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListResultsResponse.AsObject>);
    get results(): ResultRaw[] | undefined;
    set results(value: ResultRaw[] | undefined);
    get page(): number;
    set page(value: number);
    get pageSize(): number;
    set pageSize(value: number);
    get total(): number;
    set total(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(): ListResultsResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListResultsResponse.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): ListResultsResponse.AsProtobufJSON;
}
export declare namespace ListResultsResponse {
    /**
     * Standard JavaScript object representation for ListResultsResponse
     */
    interface AsObject {
        results?: ResultRaw.AsObject[];
        page: number;
        pageSize: number;
        total: number;
    }
    /**
     * Protobuf JSON representation for ListResultsResponse
     */
    interface AsProtobufJSON {
        results: ResultRaw.AsProtobufJSON[] | null;
        page: number;
        pageSize: number;
        total: number;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.GetResultRequest
 */
export declare class GetResultRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetResultRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetResultRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetResultRequest, _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: GetResultRequest, _writer: BinaryWriter): void;
    private _resultId;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetResultRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetResultRequest.AsObject>);
    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(): GetResultRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GetResultRequest.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): GetResultRequest.AsProtobufJSON;
}
export declare namespace GetResultRequest {
    /**
     * Standard JavaScript object representation for GetResultRequest
     */
    interface AsObject {
        resultId: string;
    }
    /**
     * Protobuf JSON representation for GetResultRequest
     */
    interface AsProtobufJSON {
        resultId: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.GetResultResponse
 */
export declare class GetResultResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetResultResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetResultResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetResultResponse, _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: GetResultResponse, _writer: BinaryWriter): void;
    private _result?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetResultResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetResultResponse.AsObject>);
    get result(): ResultRaw | undefined;
    set result(value: ResultRaw | 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(): GetResultResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GetResultResponse.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): GetResultResponse.AsProtobufJSON;
}
export declare namespace GetResultResponse {
    /**
     * Standard JavaScript object representation for GetResultResponse
     */
    interface AsObject {
        result?: ResultRaw.AsObject;
    }
    /**
     * Protobuf JSON representation for GetResultResponse
     */
    interface AsProtobufJSON {
        result: ResultRaw.AsProtobufJSON | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdRequest
 */
export declare class GetOwnerTaskIdRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetOwnerTaskIdRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetOwnerTaskIdRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetOwnerTaskIdRequest, _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: GetOwnerTaskIdRequest, _writer: BinaryWriter): void;
    private _sessionId;
    private _resultId;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetOwnerTaskIdRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetOwnerTaskIdRequest.AsObject>);
    get sessionId(): string;
    set sessionId(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(): GetOwnerTaskIdRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GetOwnerTaskIdRequest.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): GetOwnerTaskIdRequest.AsProtobufJSON;
}
export declare namespace GetOwnerTaskIdRequest {
    /**
     * Standard JavaScript object representation for GetOwnerTaskIdRequest
     */
    interface AsObject {
        sessionId: string;
        resultId: string[];
    }
    /**
     * Protobuf JSON representation for GetOwnerTaskIdRequest
     */
    interface AsProtobufJSON {
        sessionId: string;
        resultId: string[];
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse
 */
export declare class GetOwnerTaskIdResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetOwnerTaskIdResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetOwnerTaskIdResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetOwnerTaskIdResponse, _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: GetOwnerTaskIdResponse, _writer: BinaryWriter): void;
    private _resultTask?;
    private _sessionId;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetOwnerTaskIdResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetOwnerTaskIdResponse.AsObject>);
    get resultTask(): GetOwnerTaskIdResponse.MapResultTask[] | undefined;
    set resultTask(value: GetOwnerTaskIdResponse.MapResultTask[] | undefined);
    get sessionId(): string;
    set sessionId(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(): GetOwnerTaskIdResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GetOwnerTaskIdResponse.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): GetOwnerTaskIdResponse.AsProtobufJSON;
}
export declare namespace GetOwnerTaskIdResponse {
    /**
     * Standard JavaScript object representation for GetOwnerTaskIdResponse
     */
    interface AsObject {
        resultTask?: GetOwnerTaskIdResponse.MapResultTask.AsObject[];
        sessionId: string;
    }
    /**
     * Protobuf JSON representation for GetOwnerTaskIdResponse
     */
    interface AsProtobufJSON {
        resultTask: GetOwnerTaskIdResponse.MapResultTask.AsProtobufJSON[] | null;
        sessionId: string;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse.MapResultTask
     */
    class MapResultTask implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): MapResultTask;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: MapResultTask): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: MapResultTask, _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: MapResultTask, _writer: BinaryWriter): void;
        private _resultId;
        private _taskId;
        /**
         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
         * @param _value initial values object or instance of MapResultTask to deeply clone from
         */
        constructor(_value?: RecursivePartial<MapResultTask.AsObject>);
        get resultId(): string;
        set resultId(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(): MapResultTask.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): MapResultTask.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): MapResultTask.AsProtobufJSON;
    }
    namespace MapResultTask {
        /**
         * Standard JavaScript object representation for MapResultTask
         */
        interface AsObject {
            resultId: string;
            taskId: string;
        }
        /**
         * Protobuf JSON representation for MapResultTask
         */
        interface AsProtobufJSON {
            resultId: string;
            taskId: string;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.CreateResultsMetaDataRequest
 */
export declare class CreateResultsMetaDataRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): CreateResultsMetaDataRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: CreateResultsMetaDataRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: CreateResultsMetaDataRequest, _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: CreateResultsMetaDataRequest, _writer: BinaryWriter): void;
    private _results?;
    private _sessionId;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of CreateResultsMetaDataRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<CreateResultsMetaDataRequest.AsObject>);
    get results(): CreateResultsMetaDataRequest.ResultCreate[] | undefined;
    set results(value: CreateResultsMetaDataRequest.ResultCreate[] | undefined);
    get sessionId(): string;
    set sessionId(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(): CreateResultsMetaDataRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): CreateResultsMetaDataRequest.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): CreateResultsMetaDataRequest.AsProtobufJSON;
}
export declare namespace CreateResultsMetaDataRequest {
    /**
     * Standard JavaScript object representation for CreateResultsMetaDataRequest
     */
    interface AsObject {
        results?: CreateResultsMetaDataRequest.ResultCreate.AsObject[];
        sessionId: string;
    }
    /**
     * Protobuf JSON representation for CreateResultsMetaDataRequest
     */
    interface AsProtobufJSON {
        results: CreateResultsMetaDataRequest.ResultCreate.AsProtobufJSON[] | null;
        sessionId: string;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.CreateResultsMetaDataRequest.ResultCreate
     */
    class ResultCreate implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): ResultCreate;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: ResultCreate): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: ResultCreate, _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: ResultCreate, _writer: BinaryWriter): void;
        private _name;
        private _manualDeletion;
        /**
         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
         * @param _value initial values object or instance of ResultCreate to deeply clone from
         */
        constructor(_value?: RecursivePartial<ResultCreate.AsObject>);
        get name(): string;
        set name(value: string);
        get manualDeletion(): boolean;
        set manualDeletion(value: boolean);
        /**
         * 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(): ResultCreate.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): ResultCreate.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): ResultCreate.AsProtobufJSON;
    }
    namespace ResultCreate {
        /**
         * Standard JavaScript object representation for ResultCreate
         */
        interface AsObject {
            name: string;
            manualDeletion: boolean;
        }
        /**
         * Protobuf JSON representation for ResultCreate
         */
        interface AsProtobufJSON {
            name: string;
            manualDeletion: boolean;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.CreateResultsMetaDataResponse
 */
export declare class CreateResultsMetaDataResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): CreateResultsMetaDataResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: CreateResultsMetaDataResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: CreateResultsMetaDataResponse, _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: CreateResultsMetaDataResponse, _writer: BinaryWriter): void;
    private _results?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of CreateResultsMetaDataResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<CreateResultsMetaDataResponse.AsObject>);
    get results(): ResultRaw[] | undefined;
    set results(value: ResultRaw[] | 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(): CreateResultsMetaDataResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): CreateResultsMetaDataResponse.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): CreateResultsMetaDataResponse.AsProtobufJSON;
}
export declare namespace CreateResultsMetaDataResponse {
    /**
     * Standard JavaScript object representation for CreateResultsMetaDataResponse
     */
    interface AsObject {
        results?: ResultRaw.AsObject[];
    }
    /**
     * Protobuf JSON representation for CreateResultsMetaDataResponse
     */
    interface AsProtobufJSON {
        results: ResultRaw.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.CreateResultsRequest
 */
export declare class CreateResultsRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): CreateResultsRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: CreateResultsRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: CreateResultsRequest, _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: CreateResultsRequest, _writer: BinaryWriter): void;
    private _results?;
    private _sessionId;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of CreateResultsRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<CreateResultsRequest.AsObject>);
    get results(): CreateResultsRequest.ResultCreate[] | undefined;
    set results(value: CreateResultsRequest.ResultCreate[] | undefined);
    get sessionId(): string;
    set sessionId(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(): CreateResultsRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): CreateResultsRequest.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): CreateResultsRequest.AsProtobufJSON;
}
export declare namespace CreateResultsRequest {
    /**
     * Standard JavaScript object representation for CreateResultsRequest
     */
    interface AsObject {
        results?: CreateResultsRequest.ResultCreate.AsObject[];
        sessionId: string;
    }
    /**
     * Protobuf JSON representation for CreateResultsRequest
     */
    interface AsProtobufJSON {
        results: CreateResultsRequest.ResultCreate.AsProtobufJSON[] | null;
        sessionId: string;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.CreateResultsRequest.ResultCreate
     */
    class ResultCreate implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): ResultCreate;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: ResultCreate): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: ResultCreate, _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: ResultCreate, _writer: BinaryWriter): void;
        private _name;
        private _data;
        private _manualDeletion;
        /**
         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
         * @param _value initial values object or instance of ResultCreate to deeply clone from
         */
        constructor(_value?: RecursivePartial<ResultCreate.AsObject>);
        get name(): string;
        set name(value: string);
        get data(): Uint8Array;
        set data(value: Uint8Array);
        get manualDeletion(): boolean;
        set manualDeletion(value: boolean);
        /**
         * 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(): ResultCreate.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): ResultCreate.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): ResultCreate.AsProtobufJSON;
    }
    namespace ResultCreate {
        /**
         * Standard JavaScript object representation for ResultCreate
         */
        interface AsObject {
            name: string;
            data: Uint8Array;
            manualDeletion: boolean;
        }
        /**
         * Protobuf JSON representation for ResultCreate
         */
        interface AsProtobufJSON {
            name: string;
            data: string;
            manualDeletion: boolean;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.CreateResultsResponse
 */
export declare class CreateResultsResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): CreateResultsResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: CreateResultsResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: CreateResultsResponse, _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: CreateResultsResponse, _writer: BinaryWriter): void;
    private _results?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of CreateResultsResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<CreateResultsResponse.AsObject>);
    get results(): ResultRaw[] | undefined;
    set results(value: ResultRaw[] | 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(): CreateResultsResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): CreateResultsResponse.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): CreateResultsResponse.AsProtobufJSON;
}
export declare namespace CreateResultsResponse {
    /**
     * Standard JavaScript object representation for CreateResultsResponse
     */
    interface AsObject {
        results?: ResultRaw.AsObject[];
    }
    /**
     * Protobuf JSON representation for CreateResultsResponse
     */
    interface AsProtobufJSON {
        results: ResultRaw.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.UploadResultDataRequest
 */
export declare class UploadResultDataRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): UploadResultDataRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: UploadResultDataRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: UploadResultDataRequest, _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: UploadResultDataRequest, _writer: BinaryWriter): void;
    private _id?;
    private _dataChunk;
    pri