/**
 * Generated by the protoc-gen-ts.  DO NOT EDIT!
 * compiler version: 3.19.1
 * source: google/firestore/v1/query.proto
 * git: https://github.com/thesayyn/protoc-gen-ts */
import * as dependency_1 from "./../../api/field_behavior";
import * as dependency_2 from "./document";
import * as dependency_3 from "./../../protobuf/wrappers";
import * as pb_1 from "google-protobuf";
export class StructuredQuery extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        select?: StructuredQueryProjection;
        from?: StructuredQueryCollectionSelector[];
        where?: StructuredQueryFilter;
        order_by?: StructuredQueryOrder[];
        start_at?: Cursor;
        end_at?: Cursor;
        offset?: number;
        limit?: dependency_3.Int32Value;
        find_nearest?: StructuredQueryFindNearest;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 4], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("select" in data && data.select != undefined) {
                this.select = data.select;
            }
            if ("from" in data && data.from != undefined) {
                this.from = data.from;
            }
            if ("where" in data && data.where != undefined) {
                this.where = data.where;
            }
            if ("order_by" in data && data.order_by != undefined) {
                this.order_by = data.order_by;
            }
            if ("start_at" in data && data.start_at != undefined) {
                this.start_at = data.start_at;
            }
            if ("end_at" in data && data.end_at != undefined) {
                this.end_at = data.end_at;
            }
            if ("offset" in data && data.offset != undefined) {
                this.offset = data.offset;
            }
            if ("limit" in data && data.limit != undefined) {
                this.limit = data.limit;
            }
            if ("find_nearest" in data && data.find_nearest != undefined) {
                this.find_nearest = data.find_nearest;
            }
        }
    }
    get select() {
        return pb_1.Message.getWrapperField(this, StructuredQueryProjection, 1) as StructuredQueryProjection;
    }
    set select(value: StructuredQueryProjection) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_select() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get from() {
        return pb_1.Message.getRepeatedWrapperField(this, StructuredQueryCollectionSelector, 2) as StructuredQueryCollectionSelector[];
    }
    set from(value: StructuredQueryCollectionSelector[]) {
        pb_1.Message.setRepeatedWrapperField(this, 2, value);
    }
    get where() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFilter, 3) as StructuredQueryFilter;
    }
    set where(value: StructuredQueryFilter) {
        pb_1.Message.setWrapperField(this, 3, value);
    }
    get has_where() {
        return pb_1.Message.getField(this, 3) != null;
    }
    get order_by() {
        return pb_1.Message.getRepeatedWrapperField(this, StructuredQueryOrder, 4) as StructuredQueryOrder[];
    }
    set order_by(value: StructuredQueryOrder[]) {
        pb_1.Message.setRepeatedWrapperField(this, 4, value);
    }
    get start_at() {
        return pb_1.Message.getWrapperField(this, Cursor, 7) as Cursor;
    }
    set start_at(value: Cursor) {
        pb_1.Message.setWrapperField(this, 7, value);
    }
    get has_start_at() {
        return pb_1.Message.getField(this, 7) != null;
    }
    get end_at() {
        return pb_1.Message.getWrapperField(this, Cursor, 8) as Cursor;
    }
    set end_at(value: Cursor) {
        pb_1.Message.setWrapperField(this, 8, value);
    }
    get has_end_at() {
        return pb_1.Message.getField(this, 8) != null;
    }
    get offset() {
        return pb_1.Message.getFieldWithDefault(this, 6, 0) as number;
    }
    set offset(value: number) {
        pb_1.Message.setField(this, 6, value);
    }
    get limit() {
        return pb_1.Message.getWrapperField(this, dependency_3.Int32Value, 5) as dependency_3.Int32Value;
    }
    set limit(value: dependency_3.Int32Value) {
        pb_1.Message.setWrapperField(this, 5, value);
    }
    get has_limit() {
        return pb_1.Message.getField(this, 5) != null;
    }
    get find_nearest() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFindNearest, 9) as StructuredQueryFindNearest;
    }
    set find_nearest(value: StructuredQueryFindNearest) {
        pb_1.Message.setWrapperField(this, 9, value);
    }
    get has_find_nearest() {
        return pb_1.Message.getField(this, 9) != null;
    }
    static fromObject(data: {
        select?: ReturnType<typeof StructuredQueryProjection.prototype.toObject>;
        from?: ReturnType<typeof StructuredQueryCollectionSelector.prototype.toObject>[];
        where?: ReturnType<typeof StructuredQueryFilter.prototype.toObject>;
        order_by?: ReturnType<typeof StructuredQueryOrder.prototype.toObject>[];
        start_at?: ReturnType<typeof Cursor.prototype.toObject>;
        end_at?: ReturnType<typeof Cursor.prototype.toObject>;
        offset?: number;
        limit?: ReturnType<typeof dependency_3.Int32Value.prototype.toObject>;
        find_nearest?: ReturnType<typeof StructuredQueryFindNearest.prototype.toObject>;
    }): StructuredQuery {
        const message = new StructuredQuery({});
        if (data.select != null) {
            message.select = StructuredQueryProjection.fromObject(data.select);
        }
        if (data.from != null) {
            message.from = data.from.map(item => StructuredQueryCollectionSelector.fromObject(item));
        }
        if (data.where != null) {
            message.where = StructuredQueryFilter.fromObject(data.where);
        }
        if (data.order_by != null) {
            message.order_by = data.order_by.map(item => StructuredQueryOrder.fromObject(item));
        }
        if (data.start_at != null) {
            message.start_at = Cursor.fromObject(data.start_at);
        }
        if (data.end_at != null) {
            message.end_at = Cursor.fromObject(data.end_at);
        }
        if (data.offset != null) {
            message.offset = data.offset;
        }
        if (data.limit != null) {
            message.limit = dependency_3.Int32Value.fromObject(data.limit);
        }
        if (data.find_nearest != null) {
            message.find_nearest = StructuredQueryFindNearest.fromObject(data.find_nearest);
        }
        return message;
    }
    toObject() {
        const data: {
            select?: ReturnType<typeof StructuredQueryProjection.prototype.toObject>;
            from?: ReturnType<typeof StructuredQueryCollectionSelector.prototype.toObject>[];
            where?: ReturnType<typeof StructuredQueryFilter.prototype.toObject>;
            order_by?: ReturnType<typeof StructuredQueryOrder.prototype.toObject>[];
            start_at?: ReturnType<typeof Cursor.prototype.toObject>;
            end_at?: ReturnType<typeof Cursor.prototype.toObject>;
            offset?: number;
            limit?: ReturnType<typeof dependency_3.Int32Value.prototype.toObject>;
            find_nearest?: ReturnType<typeof StructuredQueryFindNearest.prototype.toObject>;
        } = {};
        if (this.select != null) {
            data.select = this.select.toObject();
        }
        if (this.from != null) {
            data.from = this.from.map((item: StructuredQueryCollectionSelector) => item.toObject());
        }
        if (this.where != null) {
            data.where = this.where.toObject();
        }
        if (this.order_by != null) {
            data.order_by = this.order_by.map((item: StructuredQueryOrder) => item.toObject());
        }
        if (this.start_at != null) {
            data.start_at = this.start_at.toObject();
        }
        if (this.end_at != null) {
            data.end_at = this.end_at.toObject();
        }
        if (this.offset != null) {
            data.offset = this.offset;
        }
        if (this.limit != null) {
            data.limit = this.limit.toObject();
        }
        if (this.find_nearest != null) {
            data.find_nearest = this.find_nearest.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_select)
            writer.writeMessage(1, this.select, () => this.select.serialize(writer));
        if (this.from.length)
            writer.writeRepeatedMessage(2, this.from, (item: StructuredQueryCollectionSelector) => item.serialize(writer));
        if (this.has_where)
            writer.writeMessage(3, this.where, () => this.where.serialize(writer));
        if (this.order_by.length)
            writer.writeRepeatedMessage(4, this.order_by, (item: StructuredQueryOrder) => item.serialize(writer));
        if (this.has_start_at)
            writer.writeMessage(7, this.start_at, () => this.start_at.serialize(writer));
        if (this.has_end_at)
            writer.writeMessage(8, this.end_at, () => this.end_at.serialize(writer));
        if (this.offset != 0)
            writer.writeInt32(6, this.offset);
        if (this.has_limit)
            writer.writeMessage(5, this.limit, () => this.limit.serialize(writer));
        if (this.has_find_nearest)
            writer.writeMessage(9, this.find_nearest, () => this.find_nearest.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQuery {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQuery();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.select, () => message.select = StructuredQueryProjection.deserialize(reader));
                    break;
                case 2:
                    reader.readMessage(message.from, () => pb_1.Message.addToRepeatedWrapperField(message, 2, StructuredQueryCollectionSelector.deserialize(reader), StructuredQueryCollectionSelector));
                    break;
                case 3:
                    reader.readMessage(message.where, () => message.where = StructuredQueryFilter.deserialize(reader));
                    break;
                case 4:
                    reader.readMessage(message.order_by, () => pb_1.Message.addToRepeatedWrapperField(message, 4, StructuredQueryOrder.deserialize(reader), StructuredQueryOrder));
                    break;
                case 7:
                    reader.readMessage(message.start_at, () => message.start_at = Cursor.deserialize(reader));
                    break;
                case 8:
                    reader.readMessage(message.end_at, () => message.end_at = Cursor.deserialize(reader));
                    break;
                case 6:
                    message.offset = reader.readInt32();
                    break;
                case 5:
                    reader.readMessage(message.limit, () => message.limit = dependency_3.Int32Value.deserialize(reader));
                    break;
                case 9:
                    reader.readMessage(message.find_nearest, () => message.find_nearest = StructuredQueryFindNearest.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQuery {
        return StructuredQuery.deserialize(bytes);
    }
}
export enum StructuredQueryDirection {
    DIRECTION_UNSPECIFIED = 0,
    ASCENDING = 1,
    DESCENDING = 2
}
export class StructuredQueryCollectionSelector extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        collection_id?: string;
        all_descendants?: boolean;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("collection_id" in data && data.collection_id != undefined) {
                this.collection_id = data.collection_id;
            }
            if ("all_descendants" in data && data.all_descendants != undefined) {
                this.all_descendants = data.all_descendants;
            }
        }
    }
    get collection_id() {
        return pb_1.Message.getFieldWithDefault(this, 2, "") as string;
    }
    set collection_id(value: string) {
        pb_1.Message.setField(this, 2, value);
    }
    get all_descendants() {
        return pb_1.Message.getFieldWithDefault(this, 3, false) as boolean;
    }
    set all_descendants(value: boolean) {
        pb_1.Message.setField(this, 3, value);
    }
    static fromObject(data: {
        collection_id?: string;
        all_descendants?: boolean;
    }): StructuredQueryCollectionSelector {
        const message = new StructuredQueryCollectionSelector({});
        if (data.collection_id != null) {
            message.collection_id = data.collection_id;
        }
        if (data.all_descendants != null) {
            message.all_descendants = data.all_descendants;
        }
        return message;
    }
    toObject() {
        const data: {
            collection_id?: string;
            all_descendants?: boolean;
        } = {};
        if (this.collection_id != null) {
            data.collection_id = this.collection_id;
        }
        if (this.all_descendants != null) {
            data.all_descendants = this.all_descendants;
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.collection_id.length)
            writer.writeString(2, this.collection_id);
        if (this.all_descendants != false)
            writer.writeBool(3, this.all_descendants);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryCollectionSelector {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryCollectionSelector();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 2:
                    message.collection_id = reader.readString();
                    break;
                case 3:
                    message.all_descendants = reader.readBool();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryCollectionSelector {
        return StructuredQueryCollectionSelector.deserialize(bytes);
    }
}
export class StructuredQueryFilter extends pb_1.Message {
    #one_of_decls: number[][] = [[1, 2, 3]];
    constructor(data?: any[] | ({} & (({
        composite_filter?: StructuredQueryCompositeFilter;
        field_filter?: never;
        unary_filter?: never;
    } | {
        composite_filter?: never;
        field_filter?: StructuredQueryFieldFilter;
        unary_filter?: never;
    } | {
        composite_filter?: never;
        field_filter?: never;
        unary_filter?: StructuredQueryUnaryFilter;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("composite_filter" in data && data.composite_filter != undefined) {
                this.composite_filter = data.composite_filter;
            }
            if ("field_filter" in data && data.field_filter != undefined) {
                this.field_filter = data.field_filter;
            }
            if ("unary_filter" in data && data.unary_filter != undefined) {
                this.unary_filter = data.unary_filter;
            }
        }
    }
    get composite_filter() {
        return pb_1.Message.getWrapperField(this, StructuredQueryCompositeFilter, 1) as StructuredQueryCompositeFilter;
    }
    set composite_filter(value: StructuredQueryCompositeFilter) {
        pb_1.Message.setOneofWrapperField(this, 1, this.#one_of_decls[0], value);
    }
    get has_composite_filter() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get field_filter() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldFilter, 2) as StructuredQueryFieldFilter;
    }
    set field_filter(value: StructuredQueryFieldFilter) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_field_filter() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get unary_filter() {
        return pb_1.Message.getWrapperField(this, StructuredQueryUnaryFilter, 3) as StructuredQueryUnaryFilter;
    }
    set unary_filter(value: StructuredQueryUnaryFilter) {
        pb_1.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
    }
    get has_unary_filter() {
        return pb_1.Message.getField(this, 3) != null;
    }
    get filter_type() {
        const cases: {
            [index: number]: "none" | "composite_filter" | "field_filter" | "unary_filter";
        } = {
            0: "none",
            1: "composite_filter",
            2: "field_filter",
            3: "unary_filter"
        };
        return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3])];
    }
    static fromObject(data: {
        composite_filter?: ReturnType<typeof StructuredQueryCompositeFilter.prototype.toObject>;
        field_filter?: ReturnType<typeof StructuredQueryFieldFilter.prototype.toObject>;
        unary_filter?: ReturnType<typeof StructuredQueryUnaryFilter.prototype.toObject>;
    }): StructuredQueryFilter {
        const message = new StructuredQueryFilter({});
        if (data.composite_filter != null) {
            message.composite_filter = StructuredQueryCompositeFilter.fromObject(data.composite_filter);
        }
        if (data.field_filter != null) {
            message.field_filter = StructuredQueryFieldFilter.fromObject(data.field_filter);
        }
        if (data.unary_filter != null) {
            message.unary_filter = StructuredQueryUnaryFilter.fromObject(data.unary_filter);
        }
        return message;
    }
    toObject() {
        const data: {
            composite_filter?: ReturnType<typeof StructuredQueryCompositeFilter.prototype.toObject>;
            field_filter?: ReturnType<typeof StructuredQueryFieldFilter.prototype.toObject>;
            unary_filter?: ReturnType<typeof StructuredQueryUnaryFilter.prototype.toObject>;
        } = {};
        if (this.composite_filter != null) {
            data.composite_filter = this.composite_filter.toObject();
        }
        if (this.field_filter != null) {
            data.field_filter = this.field_filter.toObject();
        }
        if (this.unary_filter != null) {
            data.unary_filter = this.unary_filter.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_composite_filter)
            writer.writeMessage(1, this.composite_filter, () => this.composite_filter.serialize(writer));
        if (this.has_field_filter)
            writer.writeMessage(2, this.field_filter, () => this.field_filter.serialize(writer));
        if (this.has_unary_filter)
            writer.writeMessage(3, this.unary_filter, () => this.unary_filter.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryFilter {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryFilter();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.composite_filter, () => message.composite_filter = StructuredQueryCompositeFilter.deserialize(reader));
                    break;
                case 2:
                    reader.readMessage(message.field_filter, () => message.field_filter = StructuredQueryFieldFilter.deserialize(reader));
                    break;
                case 3:
                    reader.readMessage(message.unary_filter, () => message.unary_filter = StructuredQueryUnaryFilter.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryFilter {
        return StructuredQueryFilter.deserialize(bytes);
    }
}
export class StructuredQueryCompositeFilter extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        op?: StructuredQueryCompositeFilterOperator;
        filters?: StructuredQueryFilter[];
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("op" in data && data.op != undefined) {
                this.op = data.op;
            }
            if ("filters" in data && data.filters != undefined) {
                this.filters = data.filters;
            }
        }
    }
    get op() {
        return pb_1.Message.getFieldWithDefault(this, 1, StructuredQueryCompositeFilterOperator.OPERATOR_UNSPECIFIED) as StructuredQueryCompositeFilterOperator;
    }
    set op(value: StructuredQueryCompositeFilterOperator) {
        pb_1.Message.setField(this, 1, value);
    }
    get filters() {
        return pb_1.Message.getRepeatedWrapperField(this, StructuredQueryFilter, 2) as StructuredQueryFilter[];
    }
    set filters(value: StructuredQueryFilter[]) {
        pb_1.Message.setRepeatedWrapperField(this, 2, value);
    }
    static fromObject(data: {
        op?: StructuredQueryCompositeFilterOperator;
        filters?: ReturnType<typeof StructuredQueryFilter.prototype.toObject>[];
    }): StructuredQueryCompositeFilter {
        const message = new StructuredQueryCompositeFilter({});
        if (data.op != null) {
            message.op = data.op;
        }
        if (data.filters != null) {
            message.filters = data.filters.map(item => StructuredQueryFilter.fromObject(item));
        }
        return message;
    }
    toObject() {
        const data: {
            op?: StructuredQueryCompositeFilterOperator;
            filters?: ReturnType<typeof StructuredQueryFilter.prototype.toObject>[];
        } = {};
        if (this.op != null) {
            data.op = this.op;
        }
        if (this.filters != null) {
            data.filters = this.filters.map((item: StructuredQueryFilter) => item.toObject());
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.op != StructuredQueryCompositeFilterOperator.OPERATOR_UNSPECIFIED)
            writer.writeEnum(1, this.op);
        if (this.filters.length)
            writer.writeRepeatedMessage(2, this.filters, (item: StructuredQueryFilter) => item.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryCompositeFilter {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryCompositeFilter();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    message.op = reader.readEnum();
                    break;
                case 2:
                    reader.readMessage(message.filters, () => pb_1.Message.addToRepeatedWrapperField(message, 2, StructuredQueryFilter.deserialize(reader), StructuredQueryFilter));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryCompositeFilter {
        return StructuredQueryCompositeFilter.deserialize(bytes);
    }
}
export enum StructuredQueryCompositeFilterOperator {
    OPERATOR_UNSPECIFIED = 0,
    AND = 1,
    OR = 2
}
export class StructuredQueryFieldFilter extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field?: StructuredQueryFieldReference;
        op?: StructuredQueryFieldFilterOperator;
        value?: dependency_2.Value;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("field" in data && data.field != undefined) {
                this.field = data.field;
            }
            if ("op" in data && data.op != undefined) {
                this.op = data.op;
            }
            if ("value" in data && data.value != undefined) {
                this.value = data.value;
            }
        }
    }
    get field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 1) as StructuredQueryFieldReference;
    }
    set field(value: StructuredQueryFieldReference) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_field() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get op() {
        return pb_1.Message.getFieldWithDefault(this, 2, StructuredQueryFieldFilterOperator.OPERATOR_UNSPECIFIED) as StructuredQueryFieldFilterOperator;
    }
    set op(value: StructuredQueryFieldFilterOperator) {
        pb_1.Message.setField(this, 2, value);
    }
    get value() {
        return pb_1.Message.getWrapperField(this, dependency_2.Value, 3) as dependency_2.Value;
    }
    set value(value: dependency_2.Value) {
        pb_1.Message.setWrapperField(this, 3, value);
    }
    get has_value() {
        return pb_1.Message.getField(this, 3) != null;
    }
    static fromObject(data: {
        field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        op?: StructuredQueryFieldFilterOperator;
        value?: ReturnType<typeof dependency_2.Value.prototype.toObject>;
    }): StructuredQueryFieldFilter {
        const message = new StructuredQueryFieldFilter({});
        if (data.field != null) {
            message.field = StructuredQueryFieldReference.fromObject(data.field);
        }
        if (data.op != null) {
            message.op = data.op;
        }
        if (data.value != null) {
            message.value = dependency_2.Value.fromObject(data.value);
        }
        return message;
    }
    toObject() {
        const data: {
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
            op?: StructuredQueryFieldFilterOperator;
            value?: ReturnType<typeof dependency_2.Value.prototype.toObject>;
        } = {};
        if (this.field != null) {
            data.field = this.field.toObject();
        }
        if (this.op != null) {
            data.op = this.op;
        }
        if (this.value != null) {
            data.value = this.value.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_field)
            writer.writeMessage(1, this.field, () => this.field.serialize(writer));
        if (this.op != StructuredQueryFieldFilterOperator.OPERATOR_UNSPECIFIED)
            writer.writeEnum(2, this.op);
        if (this.has_value)
            writer.writeMessage(3, this.value, () => this.value.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryFieldFilter {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryFieldFilter();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                case 2:
                    message.op = reader.readEnum();
                    break;
                case 3:
                    reader.readMessage(message.value, () => message.value = dependency_2.Value.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryFieldFilter {
        return StructuredQueryFieldFilter.deserialize(bytes);
    }
}
export enum StructuredQueryFieldFilterOperator {
    OPERATOR_UNSPECIFIED = 0,
    LESS_THAN = 1,
    LESS_THAN_OR_EQUAL = 2,
    GREATER_THAN = 3,
    GREATER_THAN_OR_EQUAL = 4,
    EQUAL = 5,
    NOT_EQUAL = 6,
    ARRAY_CONTAINS = 7,
    IN = 8,
    ARRAY_CONTAINS_ANY = 9,
    NOT_IN = 10
}
export class StructuredQueryUnaryFilter extends pb_1.Message {
    #one_of_decls: number[][] = [[2]];
    constructor(data?: any[] | ({
        op?: StructuredQueryUnaryFilterOperator;
    } & (({
        field?: StructuredQueryFieldReference;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("op" in data && data.op != undefined) {
                this.op = data.op;
            }
            if ("field" in data && data.field != undefined) {
                this.field = data.field;
            }
        }
    }
    get op() {
        return pb_1.Message.getFieldWithDefault(this, 1, StructuredQueryUnaryFilterOperator.OPERATOR_UNSPECIFIED) as StructuredQueryUnaryFilterOperator;
    }
    set op(value: StructuredQueryUnaryFilterOperator) {
        pb_1.Message.setField(this, 1, value);
    }
    get field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 2) as StructuredQueryFieldReference;
    }
    set field(value: StructuredQueryFieldReference) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_field() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get operand_type() {
        const cases: {
            [index: number]: "none" | "field";
        } = {
            0: "none",
            2: "field"
        };
        return cases[pb_1.Message.computeOneofCase(this, [2])];
    }
    static fromObject(data: {
        op?: StructuredQueryUnaryFilterOperator;
        field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
    }): StructuredQueryUnaryFilter {
        const message = new StructuredQueryUnaryFilter({});
        if (data.op != null) {
            message.op = data.op;
        }
        if (data.field != null) {
            message.field = StructuredQueryFieldReference.fromObject(data.field);
        }
        return message;
    }
    toObject() {
        const data: {
            op?: StructuredQueryUnaryFilterOperator;
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        } = {};
        if (this.op != null) {
            data.op = this.op;
        }
        if (this.field != null) {
            data.field = this.field.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.op != StructuredQueryUnaryFilterOperator.OPERATOR_UNSPECIFIED)
            writer.writeEnum(1, this.op);
        if (this.has_field)
            writer.writeMessage(2, this.field, () => this.field.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryUnaryFilter {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryUnaryFilter();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    message.op = reader.readEnum();
                    break;
                case 2:
                    reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryUnaryFilter {
        return StructuredQueryUnaryFilter.deserialize(bytes);
    }
}
export enum StructuredQueryUnaryFilterOperator {
    OPERATOR_UNSPECIFIED = 0,
    IS_NAN = 2,
    IS_NULL = 3,
    IS_NOT_NAN = 4,
    IS_NOT_NULL = 5
}
export class StructuredQueryOrder extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field?: StructuredQueryFieldReference;
        direction?: StructuredQueryDirection;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("field" in data && data.field != undefined) {
                this.field = data.field;
            }
            if ("direction" in data && data.direction != undefined) {
                this.direction = data.direction;
            }
        }
    }
    get field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 1) as StructuredQueryFieldReference;
    }
    set field(value: StructuredQueryFieldReference) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_field() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get direction() {
        return pb_1.Message.getFieldWithDefault(this, 2, StructuredQueryDirection.DIRECTION_UNSPECIFIED) as StructuredQueryDirection;
    }
    set direction(value: StructuredQueryDirection) {
        pb_1.Message.setField(this, 2, value);
    }
    static fromObject(data: {
        field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        direction?: StructuredQueryDirection;
    }): StructuredQueryOrder {
        const message = new StructuredQueryOrder({});
        if (data.field != null) {
            message.field = StructuredQueryFieldReference.fromObject(data.field);
        }
        if (data.direction != null) {
            message.direction = data.direction;
        }
        return message;
    }
    toObject() {
        const data: {
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
            direction?: StructuredQueryDirection;
        } = {};
        if (this.field != null) {
            data.field = this.field.toObject();
        }
        if (this.direction != null) {
            data.direction = this.direction;
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_field)
            writer.writeMessage(1, this.field, () => this.field.serialize(writer));
        if (this.direction != StructuredQueryDirection.DIRECTION_UNSPECIFIED)
            writer.writeEnum(2, this.direction);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryOrder {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryOrder();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                case 2:
                    message.direction = reader.readEnum();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryOrder {
        return StructuredQueryOrder.deserialize(bytes);
    }
}
export class StructuredQueryFieldReference extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field_path?: string;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("field_path" in data && data.field_path != undefined) {
                this.field_path = data.field_path;
            }
        }
    }
    get field_path() {
        return pb_1.Message.getFieldWithDefault(this, 2, "") as string;
    }
    set field_path(value: string) {
        pb_1.Message.setField(this, 2, value);
    }
    static fromObject(data: {
        field_path?: string;
    }): StructuredQueryFieldReference {
        const message = new StructuredQueryFieldReference({});
        if (data.field_path != null) {
            message.field_path = data.field_path;
        }
        return message;
    }
    toObject() {
        const data: {
            field_path?: string;
        } = {};
        if (this.field_path != null) {
            data.field_path = this.field_path;
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.field_path.length)
            writer.writeString(2, this.field_path);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryFieldReference {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryFieldReference();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 2:
                    message.field_path = reader.readString();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryFieldReference {
        return StructuredQueryFieldReference.deserialize(bytes);
    }
}
export class StructuredQueryProjection extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        fields?: StructuredQueryFieldReference[];
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("fields" in data && data.fields != undefined) {
                this.fields = data.fields;
            }
        }
    }
    get fields() {
        return pb_1.Message.getRepeatedWrapperField(this, StructuredQueryFieldReference, 2) as StructuredQueryFieldReference[];
    }
    set fields(value: StructuredQueryFieldReference[]) {
        pb_1.Message.setRepeatedWrapperField(this, 2, value);
    }
    static fromObject(data: {
        fields?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>[];
    }): StructuredQueryProjection {
        const message = new StructuredQueryProjection({});
        if (data.fields != null) {
            message.fields = data.fields.map(item => StructuredQueryFieldReference.fromObject(item));
        }
        return message;
    }
    toObject() {
        const data: {
            fields?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>[];
        } = {};
        if (this.fields != null) {
            data.fields = this.fields.map((item: StructuredQueryFieldReference) => item.toObject());
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.fields.length)
            writer.writeRepeatedMessage(2, this.fields, (item: StructuredQueryFieldReference) => item.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryProjection {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryProjection();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 2:
                    reader.readMessage(message.fields, () => pb_1.Message.addToRepeatedWrapperField(message, 2, StructuredQueryFieldReference.deserialize(reader), StructuredQueryFieldReference));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryProjection {
        return StructuredQueryProjection.deserialize(bytes);
    }
}
export class StructuredQueryFindNearest extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        vector_field?: StructuredQueryFieldReference;
        query_vector?: dependency_2.Value;
        distance_measure?: StructuredQueryFindNearestDistanceMeasure;
        limit?: dependency_3.Int32Value;
        distance_result_field?: string;
        distance_threshold?: dependency_3.DoubleValue;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("vector_field" in data && data.vector_field != undefined) {
                this.vector_field = data.vector_field;
            }
            if ("query_vector" in data && data.query_vector != undefined) {
                this.query_vector = data.query_vector;
            }
            if ("distance_measure" in data && data.distance_measure != undefined) {
                this.distance_measure = data.distance_measure;
            }
            if ("limit" in data && data.limit != undefined) {
                this.limit = data.limit;
            }
            if ("distance_result_field" in data && data.distance_result_field != undefined) {
                this.distance_result_field = data.distance_result_field;
            }
            if ("distance_threshold" in data && data.distance_threshold != undefined) {
                this.distance_threshold = data.distance_threshold;
            }
        }
    }
    get vector_field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 1) as StructuredQueryFieldReference;
    }
    set vector_field(value: StructuredQueryFieldReference) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_vector_field() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get query_vector() {
        return pb_1.Message.getWrapperField(this, dependency_2.Value, 2) as dependency_2.Value;
    }
    set query_vector(value: dependency_2.Value) {
        pb_1.Message.setWrapperField(this, 2, value);
    }
    get has_query_vector() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get distance_measure() {
        return pb_1.Message.getFieldWithDefault(this, 3, StructuredQueryFindNearestDistanceMeasure.DISTANCE_MEASURE_UNSPECIFIED) as StructuredQueryFindNearestDistanceMeasure;
    }
    set distance_measure(value: StructuredQueryFindNearestDistanceMeasure) {
        pb_1.Message.setField(this, 3, value);
    }
    get limit() {
        return pb_1.Message.getWrapperField(this, dependency_3.Int32Value, 4) as dependency_3.Int32Value;
    }
    set limit(value: dependency_3.Int32Value) {
        pb_1.Message.setWrapperField(this, 4, value);
    }
    get has_limit() {
        return pb_1.Message.getField(this, 4) != null;
    }
    get distance_result_field() {
        return pb_1.Message.getFieldWithDefault(this, 5, "") as string;
    }
    set distance_result_field(value: string) {
        pb_1.Message.setField(this, 5, value);
    }
    get distance_threshold() {
        return pb_1.Message.getWrapperField(this, dependency_3.DoubleValue, 6) as dependency_3.DoubleValue;
    }
    set distance_threshold(value: dependency_3.DoubleValue) {
        pb_1.Message.setWrapperField(this, 6, value);
    }
    get has_distance_threshold() {
        return pb_1.Message.getField(this, 6) != null;
    }
    static fromObject(data: {
        vector_field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        query_vector?: ReturnType<typeof dependency_2.Value.prototype.toObject>;
        distance_measure?: StructuredQueryFindNearestDistanceMeasure;
        limit?: ReturnType<typeof dependency_3.Int32Value.prototype.toObject>;
        distance_result_field?: string;
        distance_threshold?: ReturnType<typeof dependency_3.DoubleValue.prototype.toObject>;
    }): StructuredQueryFindNearest {
        const message = new StructuredQueryFindNearest({});
        if (data.vector_field != null) {
            message.vector_field = StructuredQueryFieldReference.fromObject(data.vector_field);
        }
        if (data.query_vector != null) {
            message.query_vector = dependency_2.Value.fromObject(data.query_vector);
        }
        if (data.distance_measure != null) {
            message.distance_measure = data.distance_measure;
        }
        if (data.limit != null) {
            message.limit = dependency_3.Int32Value.fromObject(data.limit);
        }
        if (data.distance_result_field != null) {
            message.distance_result_field = data.distance_result_field;
        }
        if (data.distance_threshold != null) {
            message.distance_threshold = dependency_3.DoubleValue.fromObject(data.distance_threshold);
        }
        return message;
    }
    toObject() {
        const data: {
            vector_field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
            query_vector?: ReturnType<typeof dependency_2.Value.prototype.toObject>;
            distance_measure?: StructuredQueryFindNearestDistanceMeasure;
            limit?: ReturnType<typeof dependency_3.Int32Value.prototype.toObject>;
            distance_result_field?: string;
            distance_threshold?: ReturnType<typeof dependency_3.DoubleValue.prototype.toObject>;
        } = {};
        if (this.vector_field != null) {
            data.vector_field = this.vector_field.toObject();
        }
        if (this.query_vector != null) {
            data.query_vector = this.query_vector.toObject();
        }
        if (this.distance_measure != null) {
            data.distance_measure = this.distance_measure;
        }
        if (this.limit != null) {
            data.limit = this.limit.toObject();
        }
        if (this.distance_result_field != null) {
            data.distance_result_field = this.distance_result_field;
        }
        if (this.distance_threshold != null) {
            data.distance_threshold = this.distance_threshold.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_vector_field)
            writer.writeMessage(1, this.vector_field, () => this.vector_field.serialize(writer));
        if (this.has_query_vector)
            writer.writeMessage(2, this.query_vector, () => this.query_vector.serialize(writer));
        if (this.distance_measure != StructuredQueryFindNearestDistanceMeasure.DISTANCE_MEASURE_UNSPECIFIED)
            writer.writeEnum(3, this.distance_measure);
        if (this.has_limit)
            writer.writeMessage(4, this.limit, () => this.limit.serialize(writer));
        if (this.distance_result_field.length)
            writer.writeString(5, this.distance_result_field);
        if (this.has_distance_threshold)
            writer.writeMessage(6, this.distance_threshold, () => this.distance_threshold.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredQueryFindNearest {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredQueryFindNearest();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.vector_field, () => message.vector_field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                case 2:
                    reader.readMessage(message.query_vector, () => message.query_vector = dependency_2.Value.deserialize(reader));
                    break;
                case 3:
                    message.distance_measure = reader.readEnum();
                    break;
                case 4:
                    reader.readMessage(message.limit, () => message.limit = dependency_3.Int32Value.deserialize(reader));
                    break;
                case 5:
                    message.distance_result_field = reader.readString();
                    break;
                case 6:
                    reader.readMessage(message.distance_threshold, () => message.distance_threshold = dependency_3.DoubleValue.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredQueryFindNearest {
        return StructuredQueryFindNearest.deserialize(bytes);
    }
}
export enum StructuredQueryFindNearestDistanceMeasure {
    DISTANCE_MEASURE_UNSPECIFIED = 0,
    EUCLIDEAN = 1,
    COSINE = 2,
    DOT_PRODUCT = 3
}
export class StructuredAggregationQuery extends pb_1.Message {
    #one_of_decls: number[][] = [[1]];
    constructor(data?: any[] | ({
        aggregations?: StructuredAggregationQueryAggregation[];
    } & (({
        structured_query?: StructuredQuery;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("structured_query" in data && data.structured_query != undefined) {
                this.structured_query = data.structured_query;
            }
            if ("aggregations" in data && data.aggregations != undefined) {
                this.aggregations = data.aggregations;
            }
        }
    }
    get structured_query() {
        return pb_1.Message.getWrapperField(this, StructuredQuery, 1) as StructuredQuery;
    }
    set structured_query(value: StructuredQuery) {
        pb_1.Message.setOneofWrapperField(this, 1, this.#one_of_decls[0], value);
    }
    get has_structured_query() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get aggregations() {
        return pb_1.Message.getRepeatedWrapperField(this, StructuredAggregationQueryAggregation, 3) as StructuredAggregationQueryAggregation[];
    }
    set aggregations(value: StructuredAggregationQueryAggregation[]) {
        pb_1.Message.setRepeatedWrapperField(this, 3, value);
    }
    get query_type() {
        const cases: {
            [index: number]: "none" | "structured_query";
        } = {
            0: "none",
            1: "structured_query"
        };
        return cases[pb_1.Message.computeOneofCase(this, [1])];
    }
    static fromObject(data: {
        structured_query?: ReturnType<typeof StructuredQuery.prototype.toObject>;
        aggregations?: ReturnType<typeof StructuredAggregationQueryAggregation.prototype.toObject>[];
    }): StructuredAggregationQuery {
        const message = new StructuredAggregationQuery({});
        if (data.structured_query != null) {
            message.structured_query = StructuredQuery.fromObject(data.structured_query);
        }
        if (data.aggregations != null) {
            message.aggregations = data.aggregations.map(item => StructuredAggregationQueryAggregation.fromObject(item));
        }
        return message;
    }
    toObject() {
        const data: {
            structured_query?: ReturnType<typeof StructuredQuery.prototype.toObject>;
            aggregations?: ReturnType<typeof StructuredAggregationQueryAggregation.prototype.toObject>[];
        } = {};
        if (this.structured_query != null) {
            data.structured_query = this.structured_query.toObject();
        }
        if (this.aggregations != null) {
            data.aggregations = this.aggregations.map((item: StructuredAggregationQueryAggregation) => item.toObject());
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_structured_query)
            writer.writeMessage(1, this.structured_query, () => this.structured_query.serialize(writer));
        if (this.aggregations.length)
            writer.writeRepeatedMessage(3, this.aggregations, (item: StructuredAggregationQueryAggregation) => item.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredAggregationQuery {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredAggregationQuery();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.structured_query, () => message.structured_query = StructuredQuery.deserialize(reader));
                    break;
                case 3:
                    reader.readMessage(message.aggregations, () => pb_1.Message.addToRepeatedWrapperField(message, 3, StructuredAggregationQueryAggregation.deserialize(reader), StructuredAggregationQueryAggregation));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredAggregationQuery {
        return StructuredAggregationQuery.deserialize(bytes);
    }
}
export class StructuredAggregationQueryAggregation extends pb_1.Message {
    #one_of_decls: number[][] = [[1, 2, 3]];
    constructor(data?: any[] | ({
        alias?: string;
    } & (({
        count?: StructuredAggregationQueryAggregationCount;
        sum?: never;
        avg?: never;
    } | {
        count?: never;
        sum?: StructuredAggregationQueryAggregationSum;
        avg?: never;
    } | {
        count?: never;
        sum?: never;
        avg?: StructuredAggregationQueryAggregationAvg;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("count" in data && data.count != undefined) {
                this.count = data.count;
            }
            if ("sum" in data && data.sum != undefined) {
                this.sum = data.sum;
            }
            if ("avg" in data && data.avg != undefined) {
                this.avg = data.avg;
            }
            if ("alias" in data && data.alias != undefined) {
                this.alias = data.alias;
            }
        }
    }
    get count() {
        return pb_1.Message.getWrapperField(this, StructuredAggregationQueryAggregationCount, 1) as StructuredAggregationQueryAggregationCount;
    }
    set count(value: StructuredAggregationQueryAggregationCount) {
        pb_1.Message.setOneofWrapperField(this, 1, this.#one_of_decls[0], value);
    }
    get has_count() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get sum() {
        return pb_1.Message.getWrapperField(this, StructuredAggregationQueryAggregationSum, 2) as StructuredAggregationQueryAggregationSum;
    }
    set sum(value: StructuredAggregationQueryAggregationSum) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_sum() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get avg() {
        return pb_1.Message.getWrapperField(this, StructuredAggregationQueryAggregationAvg, 3) as StructuredAggregationQueryAggregationAvg;
    }
    set avg(value: StructuredAggregationQueryAggregationAvg) {
        pb_1.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
    }
    get has_avg() {
        return pb_1.Message.getField(this, 3) != null;
    }
    get alias() {
        return pb_1.Message.getFieldWithDefault(this, 7, "") as string;
    }
    set alias(value: string) {
        pb_1.Message.setField(this, 7, value);
    }
    get operator() {
        const cases: {
            [index: number]: "none" | "count" | "sum" | "avg";
        } = {
            0: "none",
            1: "count",
            2: "sum",
            3: "avg"
        };
        return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3])];
    }
    static fromObject(data: {
        count?: ReturnType<typeof StructuredAggregationQueryAggregationCount.prototype.toObject>;
        sum?: ReturnType<typeof StructuredAggregationQueryAggregationSum.prototype.toObject>;
        avg?: ReturnType<typeof StructuredAggregationQueryAggregationAvg.prototype.toObject>;
        alias?: string;
    }): StructuredAggregationQueryAggregation {
        const message = new StructuredAggregationQueryAggregation({});
        if (data.count != null) {
            message.count = StructuredAggregationQueryAggregationCount.fromObject(data.count);
        }
        if (data.sum != null) {
            message.sum = StructuredAggregationQueryAggregationSum.fromObject(data.sum);
        }
        if (data.avg != null) {
            message.avg = StructuredAggregationQueryAggregationAvg.fromObject(data.avg);
        }
        if (data.alias != null) {
            message.alias = data.alias;
        }
        return message;
    }
    toObject() {
        const data: {
            count?: ReturnType<typeof StructuredAggregationQueryAggregationCount.prototype.toObject>;
            sum?: ReturnType<typeof StructuredAggregationQueryAggregationSum.prototype.toObject>;
            avg?: ReturnType<typeof StructuredAggregationQueryAggregationAvg.prototype.toObject>;
            alias?: string;
        } = {};
        if (this.count != null) {
            data.count = this.count.toObject();
        }
        if (this.sum != null) {
            data.sum = this.sum.toObject();
        }
        if (this.avg != null) {
            data.avg = this.avg.toObject();
        }
        if (this.alias != null) {
            data.alias = this.alias;
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_count)
            writer.writeMessage(1, this.count, () => this.count.serialize(writer));
        if (this.has_sum)
            writer.writeMessage(2, this.sum, () => this.sum.serialize(writer));
        if (this.has_avg)
            writer.writeMessage(3, this.avg, () => this.avg.serialize(writer));
        if (this.alias.length)
            writer.writeString(7, this.alias);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredAggregationQueryAggregation {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredAggregationQueryAggregation();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.count, () => message.count = StructuredAggregationQueryAggregationCount.deserialize(reader));
                    break;
                case 2:
                    reader.readMessage(message.sum, () => message.sum = StructuredAggregationQueryAggregationSum.deserialize(reader));
                    break;
                case 3:
                    reader.readMessage(message.avg, () => message.avg = StructuredAggregationQueryAggregationAvg.deserialize(reader));
                    break;
                case 7:
                    message.alias = reader.readString();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredAggregationQueryAggregation {
        return StructuredAggregationQueryAggregation.deserialize(bytes);
    }
}
export class StructuredAggregationQueryAggregationCount extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        up_to?: dependency_3.Int64Value;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("up_to" in data && data.up_to != undefined) {
                this.up_to = data.up_to;
            }
        }
    }
    get up_to() {
        return pb_1.Message.getWrapperField(this, dependency_3.Int64Value, 1) as dependency_3.Int64Value;
    }
    set up_to(value: dependency_3.Int64Value) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_up_to() {
        return pb_1.Message.getField(this, 1) != null;
    }
    static fromObject(data: {
        up_to?: ReturnType<typeof dependency_3.Int64Value.prototype.toObject>;
    }): StructuredAggregationQueryAggregationCount {
        const message = new StructuredAggregationQueryAggregationCount({});
        if (data.up_to != null) {
            message.up_to = dependency_3.Int64Value.fromObject(data.up_to);
        }
        return message;
    }
    toObject() {
        const data: {
            up_to?: ReturnType<typeof dependency_3.Int64Value.prototype.toObject>;
        } = {};
        if (this.up_to != null) {
            data.up_to = this.up_to.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_up_to)
            writer.writeMessage(1, this.up_to, () => this.up_to.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredAggregationQueryAggregationCount {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredAggregationQueryAggregationCount();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.up_to, () => message.up_to = dependency_3.Int64Value.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredAggregationQueryAggregationCount {
        return StructuredAggregationQueryAggregationCount.deserialize(bytes);
    }
}
export class StructuredAggregationQueryAggregationSum extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field?: StructuredQueryFieldReference;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("field" in data && data.field != undefined) {
                this.field = data.field;
            }
        }
    }
    get field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 1) as StructuredQueryFieldReference;
    }
    set field(value: StructuredQueryFieldReference) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_field() {
        return pb_1.Message.getField(this, 1) != null;
    }
    static fromObject(data: {
        field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
    }): StructuredAggregationQueryAggregationSum {
        const message = new StructuredAggregationQueryAggregationSum({});
        if (data.field != null) {
            message.field = StructuredQueryFieldReference.fromObject(data.field);
        }
        return message;
    }
    toObject() {
        const data: {
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        } = {};
        if (this.field != null) {
            data.field = this.field.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_field)
            writer.writeMessage(1, this.field, () => this.field.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredAggregationQueryAggregationSum {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredAggregationQueryAggregationSum();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredAggregationQueryAggregationSum {
        return StructuredAggregationQueryAggregationSum.deserialize(bytes);
    }
}
export class StructuredAggregationQueryAggregationAvg extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field?: StructuredQueryFieldReference;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("field" in data && data.field != undefined) {
                this.field = data.field;
            }
        }
    }
    get field() {
        return pb_1.Message.getWrapperField(this, StructuredQueryFieldReference, 1) as StructuredQueryFieldReference;
    }
    set field(value: StructuredQueryFieldReference) {
        pb_1.Message.setWrapperField(this, 1, value);
    }
    get has_field() {
        return pb_1.Message.getField(this, 1) != null;
    }
    static fromObject(data: {
        field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
    }): StructuredAggregationQueryAggregationAvg {
        const message = new StructuredAggregationQueryAggregationAvg({});
        if (data.field != null) {
            message.field = StructuredQueryFieldReference.fromObject(data.field);
        }
        return message;
    }
    toObject() {
        const data: {
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
        } = {};
        if (this.field != null) {
            data.field = this.field.toObject();
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.has_field)
            writer.writeMessage(1, this.field, () => this.field.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StructuredAggregationQueryAggregationAvg {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StructuredAggregationQueryAggregationAvg();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): StructuredAggregationQueryAggregationAvg {
        return StructuredAggregationQueryAggregationAvg.deserialize(bytes);
    }
}
export class Cursor extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        values?: dependency_2.Value[];
        before?: boolean;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("values" in data && data.values != undefined) {
                this.values = data.values;
            }
            if ("before" in data && data.before != undefined) {
                this.before = data.before;
            }
        }
    }
    get values() {
        return pb_1.Message.getRepeatedWrapperField(this, dependency_2.Value, 1) as dependency_2.Value[];
    }
    set values(value: dependency_2.Value[]) {
        pb_1.Message.setRepeatedWrapperField(this, 1, value);
    }
    get before() {
        return pb_1.Message.getFieldWithDefault(this, 2, false) as boolean;
    }
    set before(value: boolean) {
        pb_1.Message.setField(this, 2, value);
    }
    static fromObject(data: {
        values?: ReturnType<typeof dependency_2.Value.prototype.toObject>[];
        before?: boolean;
    }): Cursor {
        const message = new Cursor({});
        if (data.values != null) {
            message.values = data.values.map(item => dependency_2.Value.fromObject(item));
        }
        if (data.before != null) {
            message.before = data.before;
        }
        return message;
    }
    toObject() {
        const data: {
            values?: ReturnType<typeof dependency_2.Value.prototype.toObject>[];
            before?: boolean;
        } = {};
        if (this.values != null) {
            data.values = this.values.map((item: dependency_2.Value) => item.toObject());
        }
        if (this.before != null) {
            data.before = this.before;
        }
        return data;
    }
    serialize(): Uint8Array;
    serialize(w: pb_1.BinaryWriter): void;
    serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
        const writer = w || new pb_1.BinaryWriter();
        if (this.values.length)
            writer.writeRepeatedMessage(1, this.values, (item: dependency_2.Value) => item.serialize(writer));
        if (this.before != false)
            writer.writeBool(2, this.before);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Cursor {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Cursor();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    reader.readMessage(message.values, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_2.Value.deserialize(reader), dependency_2.Value));
                    break;
                case 2:
                    message.before = reader.readBool();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): Cursor {
        return Cursor.deserialize(bytes);
    }
}