@aneoconsultingfr/armonik.api.angular/index.d.ts

gRPC API to interact with ArmoniK built for Angular

import { GrpcMessage, RecursivePartial, ToProtobufJSONOptions, GrpcMetadata, GrpcEvent, GrpcClientFactory } from '@ngx-grpc/common';
import { ByteSource, BinaryReader, BinaryWriter } from 'google-protobuf';
import * as googleProtobuf004 from '@ngx-grpc/well-known-types';
import { GrpcHandler } from '@ngx-grpc/core';
import { Observable } from 'rxjs';
import * as i0 from '@angular/core';

declare enum ApplicationRawEnumField {
    APPLICATION_RAW_ENUM_FIELD_UNSPECIFIED = 0,
    APPLICATION_RAW_ENUM_FIELD_NAME = 1,
    APPLICATION_RAW_ENUM_FIELD_VERSION = 2,
    APPLICATION_RAW_ENUM_FIELD_NAMESPACE = 3,
    APPLICATION_RAW_ENUM_FIELD_SERVICE = 4
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.ApplicationRawField
 */
declare class ApplicationRawField implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ApplicationRawField;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ApplicationRawField): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ApplicationRawField, _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: ApplicationRawField, _writer: BinaryWriter): void;
    private _field;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ApplicationRawField to deeply clone from
     */
    constructor(_value?: RecursivePartial<ApplicationRawField.AsObject>);
    get field(): ApplicationRawEnumField;
    set field(value: ApplicationRawEnumField);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ApplicationRawField.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ApplicationRawField.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): ApplicationRawField.AsProtobufJSON;
}
declare namespace ApplicationRawField {
    /**
     * Standard JavaScript object representation for ApplicationRawField
     */
    interface AsObject {
        field: ApplicationRawEnumField;
    }
    /**
     * Protobuf JSON representation for ApplicationRawField
     */
    interface AsProtobufJSON {
        field: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.ApplicationField
 */
declare class ApplicationField implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ApplicationField;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ApplicationField): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ApplicationField, _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: ApplicationField, _writer: BinaryWriter): void;
    private _applicationField?;
    private _field;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ApplicationField to deeply clone from
     */
    constructor(_value?: RecursivePartial<ApplicationField.AsObject>);
    get applicationField(): ApplicationRawField | undefined;
    set applicationField(value: ApplicationRawField | undefined);
    get field(): ApplicationField.FieldCase;
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ApplicationField.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ApplicationField.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): ApplicationField.AsProtobufJSON;
}
declare namespace ApplicationField {
    /**
     * Standard JavaScript object representation for ApplicationField
     */
    interface AsObject {
        applicationField?: ApplicationRawField.AsObject;
    }
    /**
     * Protobuf JSON representation for ApplicationField
     */
    interface AsProtobufJSON {
        applicationField: ApplicationRawField.AsProtobufJSON | null;
    }
    enum FieldCase {
        none = 0,
        applicationField = 1
    }
}

declare enum FilterStringOperator {
    FILTER_STRING_OPERATOR_EQUAL = 0,
    FILTER_STRING_OPERATOR_NOT_EQUAL = 1,
    FILTER_STRING_OPERATOR_CONTAINS = 2,
    FILTER_STRING_OPERATOR_NOT_CONTAINS = 3,
    FILTER_STRING_OPERATOR_STARTS_WITH = 4,
    FILTER_STRING_OPERATOR_ENDS_WITH = 5
}
declare enum FilterNumberOperator {
    FILTER_NUMBER_OPERATOR_EQUAL = 0,
    FILTER_NUMBER_OPERATOR_NOT_EQUAL = 1,
    FILTER_NUMBER_OPERATOR_LESS_THAN = 2,
    FILTER_NUMBER_OPERATOR_LESS_THAN_OR_EQUAL = 3,
    FILTER_NUMBER_OPERATOR_GREATER_THAN_OR_EQUAL = 4,
    FILTER_NUMBER_OPERATOR_GREATER_THAN = 5
}
declare enum FilterDateOperator {
    FILTER_DATE_OPERATOR_EQUAL = 0,
    FILTER_DATE_OPERATOR_NOT_EQUAL = 1,
    FILTER_DATE_OPERATOR_BEFORE = 2,
    FILTER_DATE_OPERATOR_BEFORE_OR_EQUAL = 3,
    FILTER_DATE_OPERATOR_AFTER_OR_EQUAL = 4,
    FILTER_DATE_OPERATOR_AFTER = 5
}
declare enum FilterArrayOperator {
    FILTER_ARRAY_OPERATOR_CONTAINS = 0,
    FILTER_ARRAY_OPERATOR_NOT_CONTAINS = 1
}
declare enum FilterStatusOperator {
    FILTER_STATUS_OPERATOR_EQUAL = 0,
    FILTER_STATUS_OPERATOR_NOT_EQUAL = 1
}
declare enum FilterBooleanOperator {
    FILTER_BOOLEAN_OPERATOR_IS = 0
}
declare enum FilterDurationOperator {
    FILTER_DURATION_OPERATOR_EQUAL = 0,
    FILTER_DURATION_OPERATOR_NOT_EQUAL = 1,
    FILTER_DURATION_OPERATOR_SHORTER_THAN = 2,
    FILTER_DURATION_OPERATOR_SHORTER_THAN_OR_EQUAL = 3,
    FILTER_DURATION_OPERATOR_LONGER_THAN_OR_EQUAL = 4,
    FILTER_DURATION_OPERATOR_LONGER_THAN = 5
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterString
 */
declare class FilterString implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterString;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterString): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterString, _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: FilterString, _writer: BinaryWriter): void;
    private _value;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterString to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterString.AsObject>);
    get value(): string;
    set value(value: string);
    get operator(): FilterStringOperator;
    set operator(value: FilterStringOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterString.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterString.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): FilterString.AsProtobufJSON;
}
declare namespace FilterString {
    /**
     * Standard JavaScript object representation for FilterString
     */
    interface AsObject {
        value: string;
        operator: FilterStringOperator;
    }
    /**
     * Protobuf JSON representation for FilterString
     */
    interface AsProtobufJSON {
        value: string;
        operator: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterNumber
 */
declare class FilterNumber implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterNumber;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterNumber): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterNumber, _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: FilterNumber, _writer: BinaryWriter): void;
    private _value;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterNumber to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterNumber.AsObject>);
    get value(): string;
    set value(value: string);
    get operator(): FilterNumberOperator;
    set operator(value: FilterNumberOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterNumber.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterNumber.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): FilterNumber.AsProtobufJSON;
}
declare namespace FilterNumber {
    /**
     * Standard JavaScript object representation for FilterNumber
     */
    interface AsObject {
        value: string;
        operator: FilterNumberOperator;
    }
    /**
     * Protobuf JSON representation for FilterNumber
     */
    interface AsProtobufJSON {
        value: string;
        operator: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterDate
 */
declare class FilterDate implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterDate;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterDate): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterDate, _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: FilterDate, _writer: BinaryWriter): void;
    private _value?;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterDate to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterDate.AsObject>);
    get value(): googleProtobuf004.Timestamp | undefined;
    set value(value: googleProtobuf004.Timestamp | undefined);
    get operator(): FilterDateOperator;
    set operator(value: FilterDateOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterDate.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterDate.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): FilterDate.AsProtobufJSON;
}
declare namespace FilterDate {
    /**
     * Standard JavaScript object representation for FilterDate
     */
    interface AsObject {
        value?: googleProtobuf004.Timestamp.AsObject;
        operator: FilterDateOperator;
    }
    /**
     * Protobuf JSON representation for FilterDate
     */
    interface AsProtobufJSON {
        value: googleProtobuf004.Timestamp.AsProtobufJSON | null;
        operator: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterArray
 */
declare class FilterArray implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterArray;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterArray): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterArray, _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: FilterArray, _writer: BinaryWriter): void;
    private _value;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterArray to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterArray.AsObject>);
    get value(): string;
    set value(value: string);
    get operator(): FilterArrayOperator;
    set operator(value: FilterArrayOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterArray.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterArray.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): FilterArray.AsProtobufJSON;
}
declare namespace FilterArray {
    /**
     * Standard JavaScript object representation for FilterArray
     */
    interface AsObject {
        value: string;
        operator: FilterArrayOperator;
    }
    /**
     * Protobuf JSON representation for FilterArray
     */
    interface AsProtobufJSON {
        value: string;
        operator: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterBoolean
 */
declare class FilterBoolean implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterBoolean;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterBoolean): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterBoolean, _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: FilterBoolean, _writer: BinaryWriter): void;
    private _value;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterBoolean to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterBoolean.AsObject>);
    get value(): boolean;
    set value(value: boolean);
    get operator(): FilterBooleanOperator;
    set operator(value: FilterBooleanOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterBoolean.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterBoolean.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): FilterBoolean.AsProtobufJSON;
}
declare namespace FilterBoolean {
    /**
     * Standard JavaScript object representation for FilterBoolean
     */
    interface AsObject {
        value: boolean;
        operator: FilterBooleanOperator;
    }
    /**
     * Protobuf JSON representation for FilterBoolean
     */
    interface AsProtobufJSON {
        value: boolean;
        operator: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.FilterDuration
 */
declare class FilterDuration implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterDuration;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterDuration): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterDuration, _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: FilterDuration, _writer: BinaryWriter): void;
    private _value?;
    private _operator;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterDuration to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterDuration.AsObject>);
    get value(): googleProtobuf004.Duration | undefined;
    set value(value: googleProtobuf004.Duration | undefined);
    get operator(): FilterDurationOperator;
    set operator(value: FilterDurationOperator);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterDuration.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterDuration.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): FilterDuration.AsProtobufJSON;
}
declare namespace FilterDuration {
    /**
     * Standard JavaScript object representation for FilterDuration
     */
    interface AsObject {
        value?: googleProtobuf004.Duration.AsObject;
        operator: FilterDurationOperator;
    }
    /**
     * Protobuf JSON representation for FilterDuration
     */
    interface AsProtobufJSON {
        value: googleProtobuf004.Duration.AsProtobufJSON | null;
        operator: string;
    }
}

/**
 * Message implementation for armonik.api.grpc.v1.applications.FilterField
 */
declare class FilterField$4 implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FilterField$4;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FilterField$4): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FilterField$4, _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: FilterField$4, _writer: BinaryWriter): void;
    private _field?;
    private _filterString?;
    private _valueCondition;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FilterField to deeply clone from
     */
    constructor(_value?: RecursivePartial<FilterField$4.AsObject>);
    get field(): ApplicationField | undefined;
    set field(value: ApplicationField | undefined);
    get filterString(): FilterString | undefined;
    set filterString(value: FilterString | undefined);
    get valueCondition(): FilterField$4.ValueConditionCase;
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FilterField$4.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FilterField$4.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): FilterField$4.AsProtobufJSON;
}
declare namespace FilterField$4 {
    /**
     * Standard JavaScript object representation for FilterField
     */
    interface AsObject {
        field?: ApplicationField.AsObject;
        filterString?: FilterString.AsObject;
    }
    /**
     * Protobuf JSON representation for FilterField
     */
    interface AsProtobufJSON {
        field: ApplicationField.AsProtobufJSON | null;
        filterString: FilterString.AsProtobufJSON | null;
    }
    enum ValueConditionCase {
        none = 0,
        filterString = 1
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.FiltersAnd
 */
declare class FiltersAnd$4 implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): FiltersAnd$4;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: FiltersAnd$4): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: FiltersAnd$4, _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: FiltersAnd$4, _writer: BinaryWriter): void;
    private _and?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of FiltersAnd to deeply clone from
     */
    constructor(_value?: RecursivePartial<FiltersAnd$4.AsObject>);
    get and(): FilterField$4[] | undefined;
    set and(value: FilterField$4[] | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): FiltersAnd$4.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): FiltersAnd$4.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): FiltersAnd$4.AsProtobufJSON;
}
declare namespace FiltersAnd$4 {
    /**
     * Standard JavaScript object representation for FiltersAnd
     */
    interface AsObject {
        and?: FilterField$4.AsObject[];
    }
    /**
     * Protobuf JSON representation for FiltersAnd
     */
    interface AsProtobufJSON {
        and: FilterField$4.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.Filters
 */
declare class Filters$4 implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): Filters$4;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: Filters$4): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: Filters$4, _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: Filters$4, _writer: BinaryWriter): void;
    private _or?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of Filters to deeply clone from
     */
    constructor(_value?: RecursivePartial<Filters$4.AsObject>);
    get or(): FiltersAnd$4[] | undefined;
    set or(value: FiltersAnd$4[] | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): Filters$4.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): Filters$4.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): Filters$4.AsProtobufJSON;
}
declare namespace Filters$4 {
    /**
     * Standard JavaScript object representation for Filters
     */
    interface AsObject {
        or?: FiltersAnd$4.AsObject[];
    }
    /**
     * Protobuf JSON representation for Filters
     */
    interface AsProtobufJSON {
        or: FiltersAnd$4.AsProtobufJSON[] | null;
    }
}

declare enum SortDirection {
    SORT_DIRECTION_UNSPECIFIED = 0,
    SORT_DIRECTION_ASC = 1,
    SORT_DIRECTION_DESC = 2
}

/**
 * Message implementation for armonik.api.grpc.v1.applications.ApplicationRaw
 */
declare class ApplicationRaw implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ApplicationRaw;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ApplicationRaw): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ApplicationRaw, _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: ApplicationRaw, _writer: BinaryWriter): void;
    private _name;
    private _version;
    private _namespace;
    private _service;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ApplicationRaw to deeply clone from
     */
    constructor(_value?: RecursivePartial<ApplicationRaw.AsObject>);
    get name(): string;
    set name(value: string);
    get version(): string;
    set version(value: string);
    get namespace(): string;
    set namespace(value: string);
    get service(): string;
    set service(value: string);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ApplicationRaw.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ApplicationRaw.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): ApplicationRaw.AsProtobufJSON;
}
declare namespace ApplicationRaw {
    /**
     * Standard JavaScript object representation for ApplicationRaw
     */
    interface AsObject {
        name: string;
        version: string;
        namespace: string;
        service: string;
    }
    /**
     * Protobuf JSON representation for ApplicationRaw
     */
    interface AsProtobufJSON {
        name: string;
        version: string;
        namespace: string;
        service: string;
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.ListApplicationsRequest
 */
declare class ListApplicationsRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListApplicationsRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListApplicationsRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListApplicationsRequest, _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: ListApplicationsRequest, _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 ListApplicationsRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListApplicationsRequest.AsObject>);
    get page(): number;
    set page(value: number);
    get pageSize(): number;
    set pageSize(value: number);
    get filters(): Filters$4 | undefined;
    set filters(value: Filters$4 | undefined);
    get sort(): ListApplicationsRequest.Sort | undefined;
    set sort(value: ListApplicationsRequest.Sort | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): Uint8Array<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ListApplicationsRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListApplicationsRequest.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): ListApplicationsRequest.AsProtobufJSON;
}
declare namespace ListApplicationsRequest {
    /**
     * Standard JavaScript object representation for ListApplicationsRequest
     */
    interface AsObject {
        page: number;
        pageSize: number;
        filters?: Filters$4.AsObject;
        sort?: ListApplicationsRequest.Sort.AsObject;
    }
    /**
     * Protobuf JSON representation for ListApplicationsRequest
     */
    interface AsProtobufJSON {
        page: number;
        pageSize: number;
        filters: Filters$4.AsProtobufJSON | null;
        sort: ListApplicationsRequest.Sort.AsProtobufJSON | null;
    }
    /**
     * Message implementation for armonik.api.grpc.v1.applications.ListApplicationsRequest.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 _fields?;
        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 fields(): ApplicationField[] | undefined;
        set fields(value: ApplicationField[] | undefined);
        get direction(): SortDirection;
        set direction(value: SortDirection);
        /**
         * Serialize message to binary data
         * @param instance message instance
         */
        serializeBinary(): Uint8Array<ArrayBufferLike>;
        /**
         * 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 {
            fields?: ApplicationField.AsObject[];
            direction: SortDirection;
        }
        /**
         * Protobuf JSON representation for Sort
         */
        interface AsProtobufJSON {
            fields: ApplicationField.AsProtobufJSON[] | null;
            direction: string;
        }
    }
}
/**
 * Message implementation for armonik.api.grpc.v1.applications.ListApplicationsResponse
 */
declare class ListApplicationsResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListApplicationsResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListApplicationsResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListApplicationsResponse, _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: ListApplicationsResponse, _writer: BinaryWriter): void;
    private _applications?;
    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 ListApplicationsResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListApplicationsResponse.AsObject>);
    get applications(): ApplicationRaw[] | undefined;
    set applications(value: ApplicationRaw[] | 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<ArrayBufferLike>;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ListApplicationsResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListApplicationsResponse.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): ListApplicationsResponse.AsProtobufJSON;
}
declare namespace ListApplicationsResponse {
    /**
     * Standard JavaScript object representation for ListApplicationsResponse
     */
    interface AsObject {
        applications?: ApplicationRaw.AsObject[];
        page: number;
        pageSize: number;
        total: number;
    }
    /**
     * Protobuf JSON representation for ListApplicationsResponse
     */
    interface AsProtobufJSON {
        applications: ApplicationRaw.AsProtobufJSON[] | null;
        page: number;
        pageSize: number;
        total: number;
    }
}

/**
 * Service client implementation for armonik.api.grpc.v1.applications.Applications
 */
declare class ApplicationsClient {
    private handler;
    private client;
    /**
     * Raw RPC implementation for each service client method.
     * The raw methods provide more control on the incoming data and events. E.g. they can be useful to read status `OK` metadata.
     * Attention: these methods do not throw errors when non-zero status codes are received.
     */
    $raw: {
        /**
         * Unary call: /armonik.api.grpc.v1.applications.Applications/ListApplications
         *
         * @param requestMessage Request message
         * @param requestMetadata Request metadata
         * @returns Observable<GrpcEvent<armonikApiGrpcV1Applications003.ListApplicationsResponse>>
         */
        listApplications: (requestData: ListApplicationsRequest, requestMetadata?: GrpcMetadata) => Observable<GrpcEvent<ListApplicationsResponse>>;
    };
    constructor(settings: any, clientFactory: GrpcClientFactory<any>, handler: GrpcHandler);
    /**
     * Unary call @/armonik.api.grpc.v1.applications.Applications/ListApplications
     *
     * @param requestMessage Request message
     * @param requestMetadata Request metadata
     * @returns Observable<armonikApiGrpcV1Applications003.ListApplicationsResponse>
     */
    listApplications(requestData: ListApplicationsRequest, requestMetadata?: GrpcMetadata): Observable<ListApplicationsResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationsClient, [{ optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationsClient>;
}

/**
 * Message implementation for armonik.api.grpc.v1.auth.User
 */
declare class User implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): User;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: User): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: