@firestore-emulator/proto/generated/google/firestore/v1beta1/query.ts

Generated Firestore Protobufs For Firestore Emulator

/**
 * Generated by the protoc-gen-ts.  DO NOT EDIT!
 * compiler version: 3.19.1
 * source: google/firestore/v1beta1/query.proto
 * git: https://github.com/thesayyn/protoc-gen-ts */
import * as dependency_1 from "./document";
import * as dependency_2 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_2.Int32Value;
    }) {
        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;
            }
        }
    }
    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_2.Int32Value, 5) as dependency_2.Int32Value;
    }
    set limit(value: dependency_2.Int32Value) {
        pb_1.Message.setWrapperField(this, 5, value);
    }
    get has_limit() {
        return pb_1.Message.getField(this, 5) != 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_2.Int32Value.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_2.Int32Value.fromObject(data.limit);
        }
        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_2.Int32Value.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();
        }
        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 (!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_2.Int32Value.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
}
export class StructuredQueryFieldFilter extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field?: StructuredQueryFieldReference;
        op?: StructuredQueryFieldFilterOperator;
        value?: dependency_1.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_1.Value, 3) as dependency_1.Value;
    }
    set value(value: dependency_1.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_1.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_1.Value.fromObject(data.value);
        }
        return message;
    }
    toObject() {
        const data: {
            field?: ReturnType<typeof StructuredQueryFieldReference.prototype.toObject>;
            op?: StructuredQueryFieldFilterOperator;
            value?: ReturnType<typeof dependency_1.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_1.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 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 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 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 Cursor extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        values?: dependency_1.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_1.Value, 1) as dependency_1.Value[];
    }
    set values(value: dependency_1.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_1.Value.prototype.toObject>[];
        before?: boolean;
    }): Cursor {
        const message = new Cursor({});
        if (data.values != null) {
            message.values = data.values.map(item => dependency_1.Value.fromObject(item));
        }
        if (data.before != null) {
            message.before = data.before;
        }
        return message;
    }
    toObject() {
        const data: {
            values?: ReturnType<typeof dependency_1.Value.prototype.toObject>[];
            before?: boolean;
        } = {};
        if (this.values != null) {
            data.values = this.values.map((item: dependency_1.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_1.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_1.Value.deserialize(reader), dependency_1.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);
    }
}