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;
    private _type;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of UploadResultDataRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<UploadResultDataRequest.AsObject>);
    get id(): UploadResultDataRequest.ResultIdentifier | undefined;
    set id(value: UploadResultDataRequest.ResultIdentifier | undefined);
    get dataChunk(): Uint8Array;
    set dataChunk(value: Uint8Array);
    get type(): UploadResultDataRequest.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(): UploadResultDataRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): UploadResultDataRequest.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): UploadResultDataRequest.AsProtobufJSON;
}
export declare namespace UploadResultDataRequest {
    /**
     * Standard JavaScript object representation for UploadResultDataRequest
     */
    interface AsObject {
        id?: UploadResultDataRequest.ResultIdentifier.AsObject;
        dataChunk: Uint8Array;
    }
    /**
     * Protobuf JSON representation for UploadResultDataRequest
     */
    interface AsProtobufJSON {
        id: UploadResultDataRequest.ResultIdentifier.AsProtobufJSON | null;
        dataChunk: string;
    }
    enum TypeCase {
        none = 0,
        id = 1,
        dataChunk = 2
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.UploadResultDataRequest.ResultIdentifier
     */
    class ResultIdentifier implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): ResultIdentifier;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: ResultIdentifier): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: ResultIdentifier, _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: ResultIdentifier, _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 ResultIdentifier to deeply clone from
         */
        constructor(_value?: RecursivePartial<ResultIdentifier.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(): ResultIdentifier.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): ResultIdentifier.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): ResultIdentifier.AsProtobufJSON;
    }
    namespace ResultIdentifier {
        /**
         * Standard JavaScript object representation for ResultIdentifier
         */
        interface AsObject {
            sessionId: string;
            resultId: string;
        }
        /**
         * Protobuf JSON representation for ResultIdentifier
         */
        interface AsProtobufJSON {
            sessionId: string;
            resultId: string;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.UploadResultDataResponse
 */
export declare class UploadResultDataResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): UploadResultDataResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: UploadResultDataResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: UploadResultDataResponse, _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: UploadResultDataResponse, _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 UploadResultDataResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<UploadResultDataResponse.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(): UploadResultDataResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): UploadResultDataResponse.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): UploadResultDataResponse.AsProtobufJSON;
}
export declare namespace UploadResultDataResponse {
    /**
     * Standard JavaScript object representation for UploadResultDataResponse
     */
    interface AsObject {
        result?: ResultRaw.AsObject;
    }
    /**
     * Protobuf JSON representation for UploadResultDataResponse
     */
    interface AsProtobufJSON {
        result: ResultRaw.AsProtobufJSON | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.ResultsServiceConfigurationResponse
 */
export declare class ResultsServiceConfigurationResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ResultsServiceConfigurationResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ResultsServiceConfigurationResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ResultsServiceConfigurationResponse, _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: ResultsServiceConfigurationResponse, _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 ResultsServiceConfigurationResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ResultsServiceConfigurationResponse.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(): ResultsServiceConfigurationResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ResultsServiceConfigurationResponse.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): ResultsServiceConfigurationResponse.AsProtobufJSON;
}
export declare namespace ResultsServiceConfigurationResponse {
    /**
     * Standard JavaScript object representation for ResultsServiceConfigurationResponse
     */
    interface AsObject {
        dataChunkMaxSize: number;
    }
    /**
     * Protobuf JSON representation for ResultsServiceConfigurationResponse
     */
    interface AsProtobufJSON {
        dataChunkMaxSize: number;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.DownloadResultDataRequest
 */
export declare class DownloadResultDataRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): DownloadResultDataRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: DownloadResultDataRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: DownloadResultDataRequest, _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: DownloadResultDataRequest, _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 DownloadResultDataRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<DownloadResultDataRequest.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(): DownloadResultDataRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): DownloadResultDataRequest.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): DownloadResultDataRequest.AsProtobufJSON;
}
export declare namespace DownloadResultDataRequest {
    /**
     * Standard JavaScript object representation for DownloadResultDataRequest
     */
    interface AsObject {
        sessionId: string;
        resultId: string;
    }
    /**
     * Protobuf JSON representation for DownloadResultDataRequest
     */
    interface AsProtobufJSON {
        sessionId: string;
        resultId: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.DownloadResultDataResponse
 */
export declare class DownloadResultDataResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): DownloadResultDataResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: DownloadResultDataResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: DownloadResultDataResponse, _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: DownloadResultDataResponse, _writer: BinaryWriter): void;
    private _dataChunk;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of DownloadResultDataResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<DownloadResultDataResponse.AsObject>);
    get dataChunk(): Uint8Array;
    set dataChunk(value: Uint8Array);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): DownloadResultDataResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): DownloadResultDataResponse.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): DownloadResultDataResponse.AsProtobufJSON;
}
export declare namespace DownloadResultDataResponse {
    /**
     * Standard JavaScript object representation for DownloadResultDataResponse
     */
    interface AsObject {
        dataChunk: Uint8Array;
    }
    /**
     * Protobuf JSON representation for DownloadResultDataResponse
     */
    interface AsProtobufJSON {
        dataChunk: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.DeleteResultsDataRequest
 */
export declare class DeleteResultsDataRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): DeleteResultsDataRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: DeleteResultsDataRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: DeleteResultsDataRequest, _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: DeleteResultsDataRequest, _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 DeleteResultsDataRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<DeleteResultsDataRequest.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(): DeleteResultsDataRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): DeleteResultsDataRequest.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): DeleteResultsDataRequest.AsProtobufJSON;
}
export declare namespace DeleteResultsDataRequest {
    /**
     * Standard JavaScript object representation for DeleteResultsDataRequest
     */
    interface AsObject {
        sessionId: string;
        resultId: string[];
    }
    /**
     * Protobuf JSON representation for DeleteResultsDataRequest
     */
    interface AsProtobufJSON {
        sessionId: string;
        resultId: string[];
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.DeleteResultsDataResponse
 */
export declare class DeleteResultsDataResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): DeleteResultsDataResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: DeleteResultsDataResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: DeleteResultsDataResponse, _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: DeleteResultsDataResponse, _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 DeleteResultsDataResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<DeleteResultsDataResponse.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(): DeleteResultsDataResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): DeleteResultsDataResponse.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): DeleteResultsDataResponse.AsProtobufJSON;
}
export declare namespace DeleteResultsDataResponse {
    /**
     * Standard JavaScript object representation for DeleteResultsDataResponse
     */
    interface AsObject {
        sessionId: string;
        resultId: string[];
    }
    /**
     * Protobuf JSON representation for DeleteResultsDataResponse
     */
    interface AsProtobufJSON {
        sessionId: string;
        resultId: string[];
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.ImportResultsDataRequest
 */
export declare class ImportResultsDataRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ImportResultsDataRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ImportResultsDataRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ImportResultsDataRequest, _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: ImportResultsDataRequest, _writer: BinaryWriter): void;
    private _sessionId;
    private _results?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ImportResultsDataRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ImportResultsDataRequest.AsObject>);
    get sessionId(): string;
    set sessionId(value: string);
    get results(): ImportResultsDataRequest.ResultOpaqueId[] | undefined;
    set results(value: ImportResultsDataRequest.ResultOpaqueId[] | 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(): ImportResultsDataRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ImportResultsDataRequest.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): ImportResultsDataRequest.AsProtobufJSON;
}
export declare namespace ImportResultsDataRequest {
    /**
     * Standard JavaScript object representation for ImportResultsDataRequest
     */
    interface AsObject {
        sessionId: string;
        results?: ImportResultsDataRequest.ResultOpaqueId.AsObject[];
    }
    /**
     * Protobuf JSON representation for ImportResultsDataRequest
     */
    interface AsProtobufJSON {
        sessionId: string;
        results: ImportResultsDataRequest.ResultOpaqueId.AsProtobufJSON[] | null;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.results.ImportResultsDataRequest.ResultOpaqueId
     */
    class ResultOpaqueId implements GrpcMessage {
        static id: string;
        /**
         * Deserialize binary data to message
         * @param instance message instance
         */
        static deserializeBinary(bytes: ByteSource): ResultOpaqueId;
        /**
         * Check all the properties and set default protobuf values if necessary
         * @param _instance message instance
         */
        static refineValues(_instance: ResultOpaqueId): void;
        /**
         * Deserializes / reads binary message into message instance using provided binary reader
         * @param _instance message instance
         * @param _reader binary reader instance
         */
        static deserializeBinaryFromReader(_instance: ResultOpaqueId, _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: ResultOpaqueId, _writer: BinaryWriter): void;
        private _resultId;
        private _opaqueId;
        /**
         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
         * @param _value initial values object or instance of ResultOpaqueId to deeply clone from
         */
        constructor(_value?: RecursivePartial<ResultOpaqueId.AsObject>);
        get resultId(): string;
        set resultId(value: string);
        get opaqueId(): Uint8Array;
        set opaqueId(value: Uint8Array);
        /**
         * Serialize message to binary data
         * @param instance message instance
         */
        serializeBinary(): Uint8Array;
        /**
         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
         */
        toObject(): ResultOpaqueId.AsObject;
        /**
         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
         */
        toJSON(): ResultOpaqueId.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): ResultOpaqueId.AsProtobufJSON;
    }
    namespace ResultOpaqueId {
        /**
         * Standard JavaScript object representation for ResultOpaqueId
         */
        interface AsObject {
            resultId: string;
            opaqueId: Uint8Array;
        }
        /**
         * Protobuf JSON representation for ResultOpaqueId
         */
        interface AsProtobufJSON {
            resultId: string;
            opaqueId: string;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.ImportResultsDataResponse
 */
export declare class ImportResultsDataResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ImportResultsDataResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ImportResultsDataResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ImportResultsDataResponse, _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: ImportResultsDataResponse, _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 ImportResultsDataResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ImportResultsDataResponse.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(): ImportResultsDataResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ImportResultsDataResponse.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): ImportResultsDataResponse.AsProtobufJSON;
}
export declare namespace ImportResultsDataResponse {
    /**
     * Standard JavaScript object representation for ImportResultsDataResponse
     */
    interface AsObject {
        results?: ResultRaw.AsObject[];
    }
    /**
     * Protobuf JSON representation for ImportResultsDataResponse
     */
    interface AsProtobufJSON {
        results: ResultRaw.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.WatchResultRequest
 */
export declare class WatchResultRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): WatchResultRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: WatchResultRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: WatchResultRequest, _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: WatchResultRequest, _writer: BinaryWriter): void;
    private _fetchStatuses;
    private _watchStatuses;
    private _resultIds;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of WatchResultRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<WatchResultRequest.AsObject>);
    get fetchStatuses(): armonikApiGrpcV1Result_status001.ResultStatus[];
    set fetchStatuses(value: armonikApiGrpcV1Result_status001.ResultStatus[]);
    get watchStatuses(): armonikApiGrpcV1Result_status001.ResultStatus[];
    set watchStatuses(value: armonikApiGrpcV1Result_status001.ResultStatus[]);
    get resultIds(): string[];
    set resultIds(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(): WatchResultRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): WatchResultRequest.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): WatchResultRequest.AsProtobufJSON;
}
export declare namespace WatchResultRequest {
    /**
     * Standard JavaScript object representation for WatchResultRequest
     */
    interface AsObject {
        fetchStatuses: armonikApiGrpcV1Result_status001.ResultStatus[];
        watchStatuses: armonikApiGrpcV1Result_status001.ResultStatus[];
        resultIds: string[];
    }
    /**
     * Protobuf JSON representation for WatchResultRequest
     */
    interface AsProtobufJSON {
        fetchStatuses: string[];
        watchStatuses: string[];
        resultIds: string[];
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.results.WatchResultResponse
 */
export declare class WatchResultResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): WatchResultResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: WatchResultResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: WatchResultResponse, _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: WatchResultResponse, _writer: BinaryWriter): void;
    private _status;
    private _resultIds;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of WatchResultResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<WatchResultResponse.AsObject>);
    get status(): armonikApiGrpcV1Result_status001.ResultStatus;
    set status(value: armonikApiGrpcV1Result_status001.ResultStatus);
    get resultIds(): string[];
    set resultIds(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(): WatchResultResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): WatchResultResponse.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): WatchResultResponse.AsProtobufJSON;
}
export declare namespace WatchResultResponse {
    /**
     * Standard JavaScript object representation for WatchResultResponse
     */
    interface AsObject {
        status: armonikApiGrpcV1Result_status001.ResultStatus;
        resultIds: string[];
    }
    /**
     * Protobuf JSON representation for WatchResultResponse
     */
    interface AsProtobufJSON {
        status: string;
        resultIds: string[];
    }
}