import _m0 from 'protobufjs/minimal';
import { Duration } from '../../../../google/protobuf/duration';
export declare const protobufPackage = "yandex.cloud.speechsense.v1";
export declare enum SortOrder {
    SORT_ORDER_UNSPECIFIED = 0,
    SORT_ORDER_ASC = 1,
    SORT_ORDER_DESC = 2,
    UNRECOGNIZED = -1
}
export declare function sortOrderFromJSON(object: any): SortOrder;
export declare function sortOrderToJSON(object: SortOrder): string;
export interface Filter {
    /** metadata key (user.some_key / system.created_at / analysis.speechkit.duration) */
    key: string;
    /** find talk matched by any text filters */
    anyMatch?: AnyMatchFilter | undefined;
    /** find talks with value from int range */
    intRange?: IntRangeFilter | undefined;
    /** find talks with value from double range */
    doubleRange?: DoubleRangeFilter | undefined;
    /** find talks with value from date range */
    dateRange?: DateRangeFilter | undefined;
    /** find talks with value from duration range */
    durationRange?: DurationRangeFilter | undefined;
    /** find talks with value equals boolean */
    booleanMatch?: BooleanFilter | undefined;
    inverse: boolean;
    /** channel number to apply filter for, starting with 0. applies to all channels if not specified */
    channelNumber?: number;
}
export interface Query {
    text: string;
    /** should or should NOT match */
    inverse: boolean;
    /** id of channel to search ("1", "2", ..., any channel if not set) */
    channelNumber?: number;
}
export interface AnyMatchFilter {
    /** values list to match with "OR" operator */
    values: string[];
}
/** indicates whether to include range boundaries */
export interface BoundsInclusive {
    /** include from bound */
    fromInclusive: boolean;
    /** include to bound */
    toInclusive: boolean;
}
export interface IntRangeFilter {
    fromValue?: number;
    toValue?: number;
    boundsInclusive?: BoundsInclusive;
}
export interface DoubleRangeFilter {
    fromValue?: number;
    toValue?: number;
    boundsInclusive?: BoundsInclusive;
}
export interface DateRangeFilter {
    fromValue?: Date;
    toValue?: Date;
    boundsInclusive?: BoundsInclusive;
}
export interface DurationRangeFilter {
    fromValue?: Duration;
    toValue?: Duration;
    boundsInclusive?: BoundsInclusive;
}
export interface BooleanFilter {
    value: boolean;
}
export interface SortData {
    fields: SortField[];
}
export interface SortField {
    /** sorting key */
    field: string;
    /** sorting order by current `field` */
    order: SortOrder;
    /** number of field in comparing order (sort by key1 (position = 0), then key2 (position = 1), then key3...) */
    position: number;
}
export declare const Filter: {
    encode(message: Filter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Filter;
    fromJSON(object: any): Filter;
    toJSON(message: Filter): unknown;
    fromPartial<I extends {
        key?: string | undefined;
        anyMatch?: {
            values?: string[] | undefined;
        } | undefined;
        intRange?: {
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } | undefined;
        doubleRange?: {
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } | undefined;
        dateRange?: {
            fromValue?: Date | undefined;
            toValue?: Date | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } | undefined;
        durationRange?: {
            fromValue?: {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } | undefined;
            toValue?: {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } | undefined;
        booleanMatch?: {
            value?: boolean | undefined;
        } | undefined;
        inverse?: boolean | undefined;
        channelNumber?: number | undefined;
    } & {
        key?: string | undefined;
        anyMatch?: ({
            values?: string[] | undefined;
        } & {
            values?: (string[] & string[] & Record<Exclude<keyof I["anyMatch"]["values"], keyof string[]>, never>) | undefined;
        } & Record<Exclude<keyof I["anyMatch"], "values">, never>) | undefined;
        intRange?: ({
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } & {
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: ({
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & Record<Exclude<keyof I["intRange"]["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
        } & Record<Exclude<keyof I["intRange"], keyof IntRangeFilter>, never>) | undefined;
        doubleRange?: ({
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } & {
            fromValue?: number | undefined;
            toValue?: number | undefined;
            boundsInclusive?: ({
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & Record<Exclude<keyof I["doubleRange"]["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
        } & Record<Exclude<keyof I["doubleRange"], keyof DoubleRangeFilter>, never>) | undefined;
        dateRange?: ({
            fromValue?: Date | undefined;
            toValue?: Date | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } & {
            fromValue?: Date | undefined;
            toValue?: Date | undefined;
            boundsInclusive?: ({
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & Record<Exclude<keyof I["dateRange"]["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
        } & Record<Exclude<keyof I["dateRange"], keyof DateRangeFilter>, never>) | undefined;
        durationRange?: ({
            fromValue?: {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } | undefined;
            toValue?: {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } | undefined;
            boundsInclusive?: {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } | undefined;
        } & {
            fromValue?: ({
                seconds?: number | undefined;
                nanos?: number | undefined;
            } & {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } & Record<Exclude<keyof I["durationRange"]["fromValue"], keyof Duration>, never>) | undefined;
            toValue?: ({
                seconds?: number | undefined;
                nanos?: number | undefined;
            } & {
                seconds?: number | undefined;
                nanos?: number | undefined;
            } & Record<Exclude<keyof I["durationRange"]["toValue"], keyof Duration>, never>) | undefined;
            boundsInclusive?: ({
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & {
                fromInclusive?: boolean | undefined;
                toInclusive?: boolean | undefined;
            } & Record<Exclude<keyof I["durationRange"]["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
        } & Record<Exclude<keyof I["durationRange"], keyof DurationRangeFilter>, never>) | undefined;
        booleanMatch?: ({
            value?: boolean | undefined;
        } & {
            value?: boolean | undefined;
        } & Record<Exclude<keyof I["booleanMatch"], "value">, never>) | undefined;
        inverse?: boolean | undefined;
        channelNumber?: number | undefined;
    } & Record<Exclude<keyof I, keyof Filter>, never>>(object: I): Filter;
};
export declare const Query: {
    encode(message: Query, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Query;
    fromJSON(object: any): Query;
    toJSON(message: Query): unknown;
    fromPartial<I extends {
        text?: string | undefined;
        inverse?: boolean | undefined;
        channelNumber?: number | undefined;
    } & {
        text?: string | undefined;
        inverse?: boolean | undefined;
        channelNumber?: number | undefined;
    } & Record<Exclude<keyof I, keyof Query>, never>>(object: I): Query;
};
export declare const AnyMatchFilter: {
    encode(message: AnyMatchFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): AnyMatchFilter;
    fromJSON(object: any): AnyMatchFilter;
    toJSON(message: AnyMatchFilter): unknown;
    fromPartial<I extends {
        values?: string[] | undefined;
    } & {
        values?: (string[] & string[] & Record<Exclude<keyof I["values"], keyof string[]>, never>) | undefined;
    } & Record<Exclude<keyof I, "values">, never>>(object: I): AnyMatchFilter;
};
export declare const BoundsInclusive: {
    encode(message: BoundsInclusive, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): BoundsInclusive;
    fromJSON(object: any): BoundsInclusive;
    toJSON(message: BoundsInclusive): unknown;
    fromPartial<I extends {
        fromInclusive?: boolean | undefined;
        toInclusive?: boolean | undefined;
    } & {
        fromInclusive?: boolean | undefined;
        toInclusive?: boolean | undefined;
    } & Record<Exclude<keyof I, keyof BoundsInclusive>, never>>(object: I): BoundsInclusive;
};
export declare const IntRangeFilter: {
    encode(message: IntRangeFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): IntRangeFilter;
    fromJSON(object: any): IntRangeFilter;
    toJSON(message: IntRangeFilter): unknown;
    fromPartial<I extends {
        fromValue?: number | undefined;
        toValue?: number | undefined;
        boundsInclusive?: {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } | undefined;
    } & {
        fromValue?: number | undefined;
        toValue?: number | undefined;
        boundsInclusive?: ({
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & Record<Exclude<keyof I["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
    } & Record<Exclude<keyof I, keyof IntRangeFilter>, never>>(object: I): IntRangeFilter;
};
export declare const DoubleRangeFilter: {
    encode(message: DoubleRangeFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DoubleRangeFilter;
    fromJSON(object: any): DoubleRangeFilter;
    toJSON(message: DoubleRangeFilter): unknown;
    fromPartial<I extends {
        fromValue?: number | undefined;
        toValue?: number | undefined;
        boundsInclusive?: {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } | undefined;
    } & {
        fromValue?: number | undefined;
        toValue?: number | undefined;
        boundsInclusive?: ({
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & Record<Exclude<keyof I["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
    } & Record<Exclude<keyof I, keyof DoubleRangeFilter>, never>>(object: I): DoubleRangeFilter;
};
export declare const DateRangeFilter: {
    encode(message: DateRangeFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DateRangeFilter;
    fromJSON(object: any): DateRangeFilter;
    toJSON(message: DateRangeFilter): unknown;
    fromPartial<I extends {
        fromValue?: Date | undefined;
        toValue?: Date | undefined;
        boundsInclusive?: {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } | undefined;
    } & {
        fromValue?: Date | undefined;
        toValue?: Date | undefined;
        boundsInclusive?: ({
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & Record<Exclude<keyof I["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
    } & Record<Exclude<keyof I, keyof DateRangeFilter>, never>>(object: I): DateRangeFilter;
};
export declare const DurationRangeFilter: {
    encode(message: DurationRangeFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DurationRangeFilter;
    fromJSON(object: any): DurationRangeFilter;
    toJSON(message: DurationRangeFilter): unknown;
    fromPartial<I extends {
        fromValue?: {
            seconds?: number | undefined;
            nanos?: number | undefined;
        } | undefined;
        toValue?: {
            seconds?: number | undefined;
            nanos?: number | undefined;
        } | undefined;
        boundsInclusive?: {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } | undefined;
    } & {
        fromValue?: ({
            seconds?: number | undefined;
            nanos?: number | undefined;
        } & {
            seconds?: number | undefined;
            nanos?: number | undefined;
        } & Record<Exclude<keyof I["fromValue"], keyof Duration>, never>) | undefined;
        toValue?: ({
            seconds?: number | undefined;
            nanos?: number | undefined;
        } & {
            seconds?: number | undefined;
            nanos?: number | undefined;
        } & Record<Exclude<keyof I["toValue"], keyof Duration>, never>) | undefined;
        boundsInclusive?: ({
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & {
            fromInclusive?: boolean | undefined;
            toInclusive?: boolean | undefined;
        } & Record<Exclude<keyof I["boundsInclusive"], keyof BoundsInclusive>, never>) | undefined;
    } & Record<Exclude<keyof I, keyof DurationRangeFilter>, never>>(object: I): DurationRangeFilter;
};
export declare const BooleanFilter: {
    encode(message: BooleanFilter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): BooleanFilter;
    fromJSON(object: any): BooleanFilter;
    toJSON(message: BooleanFilter): unknown;
    fromPartial<I extends {
        value?: boolean | undefined;
    } & {
        value?: boolean | undefined;
    } & Record<Exclude<keyof I, "value">, never>>(object: I): BooleanFilter;
};
export declare const SortData: {
    encode(message: SortData, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): SortData;
    fromJSON(object: any): SortData;
    toJSON(message: SortData): unknown;
    fromPartial<I extends {
        fields?: {
            field?: string | undefined;
            order?: SortOrder | undefined;
            position?: number | undefined;
        }[] | undefined;
    } & {
        fields?: ({
            field?: string | undefined;
            order?: SortOrder | undefined;
            position?: number | undefined;
        }[] & ({
            field?: string | undefined;
            order?: SortOrder | undefined;
            position?: number | undefined;
        } & {
            field?: string | undefined;
            order?: SortOrder | undefined;
            position?: number | undefined;
        } & Record<Exclude<keyof I["fields"][number], keyof SortField>, never>)[] & Record<Exclude<keyof I["fields"], keyof {
            field?: string | undefined;
            order?: SortOrder | undefined;
            position?: number | undefined;
        }[]>, never>) | undefined;
    } & Record<Exclude<keyof I, "fields">, never>>(object: I): SortData;
};
export declare const SortField: {
    encode(message: SortField, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): SortField;
    fromJSON(object: any): SortField;
    toJSON(message: SortField): unknown;
    fromPartial<I extends {
        field?: string | undefined;
        order?: SortOrder | undefined;
        position?: number | undefined;
    } & {
        field?: string | undefined;
        order?: SortOrder | undefined;
        position?: number | undefined;
    } & Record<Exclude<keyof I, keyof SortField>, never>>(object: I): SortField;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
export {};
