@firestore-emulator/proto/generated/google/firestore/v1beta1/common.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/common.proto
 * git: https://github.com/thesayyn/protoc-gen-ts */
import * as dependency_1 from "./../../protobuf/timestamp";
import * as pb_1 from "google-protobuf";
export class DocumentMask extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        field_paths?: string[];
    }) {
        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 ("field_paths" in data && data.field_paths != undefined) {
                this.field_paths = data.field_paths;
            }
        }
    }
    get field_paths() {
        return pb_1.Message.getFieldWithDefault(this, 1, []) as string[];
    }
    set field_paths(value: string[]) {
        pb_1.Message.setField(this, 1, value);
    }
    static fromObject(data: {
        field_paths?: string[];
    }): DocumentMask {
        const message = new DocumentMask({});
        if (data.field_paths != null) {
            message.field_paths = data.field_paths;
        }
        return message;
    }
    toObject() {
        const data: {
            field_paths?: string[];
        } = {};
        if (this.field_paths != null) {
            data.field_paths = this.field_paths;
        }
        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_paths.length)
            writer.writeRepeatedString(1, this.field_paths);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DocumentMask {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new DocumentMask();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    pb_1.Message.addToRepeatedField(message, 1, reader.readString());
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): DocumentMask {
        return DocumentMask.deserialize(bytes);
    }
}
export class Precondition extends pb_1.Message {
    #one_of_decls: number[][] = [[1, 2]];
    constructor(data?: any[] | ({} & (({
        exists?: boolean;
        update_time?: never;
    } | {
        exists?: never;
        update_time?: dependency_1.Timestamp;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("exists" in data && data.exists != undefined) {
                this.exists = data.exists;
            }
            if ("update_time" in data && data.update_time != undefined) {
                this.update_time = data.update_time;
            }
        }
    }
    get exists() {
        return pb_1.Message.getFieldWithDefault(this, 1, false) as boolean;
    }
    set exists(value: boolean) {
        pb_1.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
    }
    get has_exists() {
        return pb_1.Message.getField(this, 1) != null;
    }
    get update_time() {
        return pb_1.Message.getWrapperField(this, dependency_1.Timestamp, 2) as dependency_1.Timestamp;
    }
    set update_time(value: dependency_1.Timestamp) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_update_time() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get condition_type() {
        const cases: {
            [index: number]: "none" | "exists" | "update_time";
        } = {
            0: "none",
            1: "exists",
            2: "update_time"
        };
        return cases[pb_1.Message.computeOneofCase(this, [1, 2])];
    }
    static fromObject(data: {
        exists?: boolean;
        update_time?: ReturnType<typeof dependency_1.Timestamp.prototype.toObject>;
    }): Precondition {
        const message = new Precondition({});
        if (data.exists != null) {
            message.exists = data.exists;
        }
        if (data.update_time != null) {
            message.update_time = dependency_1.Timestamp.fromObject(data.update_time);
        }
        return message;
    }
    toObject() {
        const data: {
            exists?: boolean;
            update_time?: ReturnType<typeof dependency_1.Timestamp.prototype.toObject>;
        } = {};
        if (this.exists != null) {
            data.exists = this.exists;
        }
        if (this.update_time != null) {
            data.update_time = this.update_time.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_exists)
            writer.writeBool(1, this.exists);
        if (this.has_update_time)
            writer.writeMessage(2, this.update_time, () => this.update_time.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Precondition {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Precondition();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    message.exists = reader.readBool();
                    break;
                case 2:
                    reader.readMessage(message.update_time, () => message.update_time = dependency_1.Timestamp.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): Precondition {
        return Precondition.deserialize(bytes);
    }
}
export class TransactionOptions extends pb_1.Message {
    #one_of_decls: number[][] = [[2, 3]];
    constructor(data?: any[] | ({} & (({
        read_only?: TransactionOptionsReadOnly;
        read_write?: never;
    } | {
        read_only?: never;
        read_write?: TransactionOptionsReadWrite;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("read_only" in data && data.read_only != undefined) {
                this.read_only = data.read_only;
            }
            if ("read_write" in data && data.read_write != undefined) {
                this.read_write = data.read_write;
            }
        }
    }
    get read_only() {
        return pb_1.Message.getWrapperField(this, TransactionOptionsReadOnly, 2) as TransactionOptionsReadOnly;
    }
    set read_only(value: TransactionOptionsReadOnly) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_read_only() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get read_write() {
        return pb_1.Message.getWrapperField(this, TransactionOptionsReadWrite, 3) as TransactionOptionsReadWrite;
    }
    set read_write(value: TransactionOptionsReadWrite) {
        pb_1.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
    }
    get has_read_write() {
        return pb_1.Message.getField(this, 3) != null;
    }
    get mode() {
        const cases: {
            [index: number]: "none" | "read_only" | "read_write";
        } = {
            0: "none",
            2: "read_only",
            3: "read_write"
        };
        return cases[pb_1.Message.computeOneofCase(this, [2, 3])];
    }
    static fromObject(data: {
        read_only?: ReturnType<typeof TransactionOptionsReadOnly.prototype.toObject>;
        read_write?: ReturnType<typeof TransactionOptionsReadWrite.prototype.toObject>;
    }): TransactionOptions {
        const message = new TransactionOptions({});
        if (data.read_only != null) {
            message.read_only = TransactionOptionsReadOnly.fromObject(data.read_only);
        }
        if (data.read_write != null) {
            message.read_write = TransactionOptionsReadWrite.fromObject(data.read_write);
        }
        return message;
    }
    toObject() {
        const data: {
            read_only?: ReturnType<typeof TransactionOptionsReadOnly.prototype.toObject>;
            read_write?: ReturnType<typeof TransactionOptionsReadWrite.prototype.toObject>;
        } = {};
        if (this.read_only != null) {
            data.read_only = this.read_only.toObject();
        }
        if (this.read_write != null) {
            data.read_write = this.read_write.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_read_only)
            writer.writeMessage(2, this.read_only, () => this.read_only.serialize(writer));
        if (this.has_read_write)
            writer.writeMessage(3, this.read_write, () => this.read_write.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TransactionOptions {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new TransactionOptions();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 2:
                    reader.readMessage(message.read_only, () => message.read_only = TransactionOptionsReadOnly.deserialize(reader));
                    break;
                case 3:
                    reader.readMessage(message.read_write, () => message.read_write = TransactionOptionsReadWrite.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): TransactionOptions {
        return TransactionOptions.deserialize(bytes);
    }
}
export class TransactionOptionsReadWrite extends pb_1.Message {
    #one_of_decls: number[][] = [];
    constructor(data?: any[] | {
        retry_transaction?: Uint8Array;
    }) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("retry_transaction" in data && data.retry_transaction != undefined) {
                this.retry_transaction = data.retry_transaction;
            }
        }
    }
    get retry_transaction() {
        return pb_1.Message.getFieldWithDefault(this, 1, new Uint8Array(0)) as Uint8Array;
    }
    set retry_transaction(value: Uint8Array) {
        pb_1.Message.setField(this, 1, value);
    }
    static fromObject(data: {
        retry_transaction?: Uint8Array;
    }): TransactionOptionsReadWrite {
        const message = new TransactionOptionsReadWrite({});
        if (data.retry_transaction != null) {
            message.retry_transaction = data.retry_transaction;
        }
        return message;
    }
    toObject() {
        const data: {
            retry_transaction?: Uint8Array;
        } = {};
        if (this.retry_transaction != null) {
            data.retry_transaction = this.retry_transaction;
        }
        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.retry_transaction.length)
            writer.writeBytes(1, this.retry_transaction);
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TransactionOptionsReadWrite {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new TransactionOptionsReadWrite();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 1:
                    message.retry_transaction = reader.readBytes();
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): TransactionOptionsReadWrite {
        return TransactionOptionsReadWrite.deserialize(bytes);
    }
}
export class TransactionOptionsReadOnly extends pb_1.Message {
    #one_of_decls: number[][] = [[2]];
    constructor(data?: any[] | ({} & (({
        read_time?: dependency_1.Timestamp;
    })))) {
        super();
        pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
        if (!Array.isArray(data) && typeof data == "object") {
            if ("read_time" in data && data.read_time != undefined) {
                this.read_time = data.read_time;
            }
        }
    }
    get read_time() {
        return pb_1.Message.getWrapperField(this, dependency_1.Timestamp, 2) as dependency_1.Timestamp;
    }
    set read_time(value: dependency_1.Timestamp) {
        pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
    }
    get has_read_time() {
        return pb_1.Message.getField(this, 2) != null;
    }
    get consistency_selector() {
        const cases: {
            [index: number]: "none" | "read_time";
        } = {
            0: "none",
            2: "read_time"
        };
        return cases[pb_1.Message.computeOneofCase(this, [2])];
    }
    static fromObject(data: {
        read_time?: ReturnType<typeof dependency_1.Timestamp.prototype.toObject>;
    }): TransactionOptionsReadOnly {
        const message = new TransactionOptionsReadOnly({});
        if (data.read_time != null) {
            message.read_time = dependency_1.Timestamp.fromObject(data.read_time);
        }
        return message;
    }
    toObject() {
        const data: {
            read_time?: ReturnType<typeof dependency_1.Timestamp.prototype.toObject>;
        } = {};
        if (this.read_time != null) {
            data.read_time = this.read_time.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_read_time)
            writer.writeMessage(2, this.read_time, () => this.read_time.serialize(writer));
        if (!w)
            return writer.getResultBuffer();
    }
    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TransactionOptionsReadOnly {
        const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new TransactionOptionsReadOnly();
        while (reader.nextField()) {
            if (reader.isEndGroup())
                break;
            switch (reader.getFieldNumber()) {
                case 2:
                    reader.readMessage(message.read_time, () => message.read_time = dependency_1.Timestamp.deserialize(reader));
                    break;
                default: reader.skipField();
            }
        }
        return message;
    }
    serializeBinary(): Uint8Array {
        return this.serialize();
    }
    static override deserializeBinary(bytes: Uint8Array): TransactionOptionsReadOnly {
        return TransactionOptionsReadOnly.deserialize(bytes);
    }
}