package o;

import o.C17555xkr;
import o.KUw;
import o.MTP;
import o.PeW;

/* loaded from: classes2.dex */
public final class CoM extends KUw<CoM, IeS> implements InterfaceC15760iPT {
    private static final CoM DEFAULT_INSTANCE;
    public static final int END_AT_FIELD_NUMBER = 8;
    public static final int FROM_FIELD_NUMBER = 2;
    public static final int LIMIT_FIELD_NUMBER = 5;
    public static final int OFFSET_FIELD_NUMBER = 6;
    public static final int ORDER_BY_FIELD_NUMBER = 4;
    private static volatile XgX<CoM> PARSER = null;
    public static final int SELECT_FIELD_NUMBER = 1;
    public static final int START_AT_FIELD_NUMBER = 7;
    public static final int WHERE_FIELD_NUMBER = 3;
    public PeW endAt_;
    public C17555xkr limit_;
    private int offset_;
    private saX select_;
    public PeW startAt_;
    public tOB where_;
    public MTP.RVV<RVV> from_ = emptyProtobufList();
    public MTP.RVV<ZqN> orderBy_ = emptyProtobufList();

    private CoM() {
    }

    /* loaded from: classes2.dex */
    public enum HBt implements MTP.IeS {
        DIRECTION_UNSPECIFIED(0),
        ASCENDING(1),
        DESCENDING(2),
        UNRECOGNIZED(-1);

        public static final int ASCENDING_VALUE = 1;
        public static final int DESCENDING_VALUE = 2;
        public static final int DIRECTION_UNSPECIFIED_VALUE = 0;
        private static final MTP.HBt<HBt> internalValueMap = new MTP.HBt<HBt>() { // from class: o.CoM.HBt.2
        };
        final int value;

        @Override // o.MTP.IeS
        public final int d() {
            if (this != UNRECOGNIZED) {
                return this.value;
            }
            throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
        }

        HBt(int i) {
            this.value = i;
        }

        public static HBt d(int i) {
            if (i == 0) {
                return DIRECTION_UNSPECIFIED;
            }
            if (i == 1) {
                return ASCENDING;
            }
            if (i != 2) {
                return null;
            }
            return DESCENDING;
        }
    }

    /* loaded from: classes2.dex */
    public static final class RVV extends KUw<RVV, C0081RVV> implements kuh {
        public static final int ALL_DESCENDANTS_FIELD_NUMBER = 3;
        public static final int COLLECTION_ID_FIELD_NUMBER = 2;
        private static final RVV DEFAULT_INSTANCE;
        private static volatile XgX<RVV> PARSER;
        public boolean allDescendants_;
        public String collectionId_ = "";

        private RVV() {
        }

        public static C0081RVV e() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* renamed from: o.CoM$RVV$RVV, reason: collision with other inner class name */
        /* loaded from: classes2.dex */
        public static final class C0081RVV extends KUw.LWm<RVV, C0081RVV> implements kuh {
            /* synthetic */ C0081RVV(byte b) {
                this();
            }

            private C0081RVV() {
                super(RVV.DEFAULT_INSTANCE);
            }

            public final C0081RVV a(String str) {
                copyOnWrite();
                ((RVV) this.instance).collectionId_ = str;
                return this;
            }

            public final C0081RVV d() {
                copyOnWrite();
                ((RVV) this.instance).allDescendants_ = true;
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new RVV();
                case 2:
                    return new C0081RVV((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0002\u0000\u0000\u0002\u0003\u0002\u0000\u0000\u0000\u0002Ȉ\u0003\u0007", new Object[]{"collectionId_", "allDescendants_"});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<RVV> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (RVV.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            RVV rvv = new RVV();
            DEFAULT_INSTANCE = rvv;
            KUw.registerDefaultInstance(RVV.class, rvv);
        }
    }

    /* renamed from: o.CoM$5, reason: invalid class name */
    /* loaded from: classes2.dex */
    static /* synthetic */ class AnonymousClass5 {
        static final int[] c;

        static {
            int[] iArr = new int[KUw.ojQ.values().length];
            c = iArr;
            try {
                iArr[KUw.ojQ.NEW_MUTABLE_INSTANCE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                c[KUw.ojQ.NEW_BUILDER.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                c[KUw.ojQ.BUILD_MESSAGE_INFO.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                c[KUw.ojQ.GET_DEFAULT_INSTANCE.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                c[KUw.ojQ.GET_PARSER.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                c[KUw.ojQ.GET_MEMOIZED_IS_INITIALIZED.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                c[KUw.ojQ.SET_MEMOIZED_IS_INITIALIZED.ordinal()] = 7;
            } catch (NoSuchFieldError unused7) {
            }
        }
    }

    /* loaded from: classes2.dex */
    public static final class tOB extends KUw<tOB, Sts> implements InterfaceC5205boe {
        public static final int COMPOSITE_FILTER_FIELD_NUMBER = 1;
        private static final tOB DEFAULT_INSTANCE;
        public static final int FIELD_FILTER_FIELD_NUMBER = 2;
        private static volatile XgX<tOB> PARSER = null;
        public static final int UNARY_FILTER_FIELD_NUMBER = 3;
        public int filterTypeCase_ = 0;
        public Object filterType_;

        private tOB() {
        }

        /* loaded from: classes2.dex */
        public enum IeS {
            COMPOSITE_FILTER(1),
            FIELD_FILTER(2),
            UNARY_FILTER(3),
            FILTERTYPE_NOT_SET(0);

            private final int value;

            IeS(int i) {
                this.value = i;
            }

            public static IeS d(int i) {
                if (i == 0) {
                    return FILTERTYPE_NOT_SET;
                }
                if (i == 1) {
                    return COMPOSITE_FILTER;
                }
                if (i == 2) {
                    return FIELD_FILTER;
                }
                if (i != 3) {
                    return null;
                }
                return UNARY_FILTER;
            }
        }

        public static Sts c() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class Sts extends KUw.LWm<tOB, Sts> implements InterfaceC5205boe {
            /* synthetic */ Sts(byte b) {
                this();
            }

            private Sts() {
                super(tOB.DEFAULT_INSTANCE);
            }

            public final Sts e(LWm.HBt hBt) {
                copyOnWrite();
                tOB.c((tOB) this.instance, hBt.build());
                return this;
            }

            public final Sts b(Sts.LWm lWm) {
                copyOnWrite();
                tOB.a((tOB) this.instance, lWm.build());
                return this;
            }

            public final Sts b(jbe.LWm lWm) {
                copyOnWrite();
                tOB.e((tOB) this.instance, lWm.build());
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new tOB();
                case 2:
                    return new Sts((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0003\u0001\u0000\u0001\u0003\u0003\u0000\u0000\u0000\u0001<\u0000\u0002<\u0000\u0003<\u0000", new Object[]{"filterType_", "filterTypeCase_", LWm.class, Sts.class, jbe.class});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<tOB> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (tOB.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            tOB tob = new tOB();
            DEFAULT_INSTANCE = tob;
            KUw.registerDefaultInstance(tOB.class, tob);
        }

        static /* synthetic */ void a(tOB tob, Sts sts) {
            tob.filterType_ = sts;
            tob.filterTypeCase_ = 2;
        }

        static /* synthetic */ void e(tOB tob, jbe jbeVar) {
            tob.filterType_ = jbeVar;
            tob.filterTypeCase_ = 3;
        }

        static /* synthetic */ void c(tOB tob, LWm lWm) {
            tob.filterType_ = lWm;
            tob.filterTypeCase_ = 1;
        }

        public static tOB d() {
            return DEFAULT_INSTANCE;
        }
    }

    /* loaded from: classes2.dex */
    public static final class LWm extends KUw<LWm, HBt> implements InterfaceC0246Cfp {
        private static final LWm DEFAULT_INSTANCE;
        public static final int FILTERS_FIELD_NUMBER = 2;
        public static final int OP_FIELD_NUMBER = 1;
        private static volatile XgX<LWm> PARSER;
        public MTP.RVV<tOB> filters_ = emptyProtobufList();
        public int op_;

        private LWm() {
        }

        /* loaded from: classes2.dex */
        public enum Sts implements MTP.IeS {
            OPERATOR_UNSPECIFIED(0),
            AND(1),
            OR(2),
            UNRECOGNIZED(-1);

            public static final int AND_VALUE = 1;
            public static final int OPERATOR_UNSPECIFIED_VALUE = 0;
            public static final int OR_VALUE = 2;
            private static final MTP.HBt<Sts> internalValueMap = new MTP.HBt<Sts>() { // from class: o.CoM.LWm.Sts.3
            };
            final int value;

            @Override // o.MTP.IeS
            public final int d() {
                if (this != UNRECOGNIZED) {
                    return this.value;
                }
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }

            Sts(int i) {
                this.value = i;
            }

            public static Sts d(int i) {
                if (i == 0) {
                    return OPERATOR_UNSPECIFIED;
                }
                if (i == 1) {
                    return AND;
                }
                if (i != 2) {
                    return null;
                }
                return OR;
            }
        }

        public static HBt e() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class HBt extends KUw.LWm<LWm, HBt> implements InterfaceC0246Cfp {
            /* synthetic */ HBt(byte b) {
                this();
            }

            private HBt() {
                super(LWm.DEFAULT_INSTANCE);
            }

            public final HBt a(Sts sts) {
                copyOnWrite();
                LWm.d((LWm) this.instance, sts);
                return this;
            }

            public final HBt d(Iterable<? extends tOB> iterable) {
                copyOnWrite();
                LWm.e((LWm) this.instance, iterable);
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new LWm();
                case 2:
                    return new HBt((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0002\u0000\u0000\u0001\u0002\u0002\u0000\u0001\u0000\u0001\f\u0002\u001b", new Object[]{"op_", "filters_", tOB.class});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<LWm> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (LWm.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            LWm lWm = new LWm();
            DEFAULT_INSTANCE = lWm;
            KUw.registerDefaultInstance(LWm.class, lWm);
        }

        static /* synthetic */ void d(LWm lWm, Sts sts) {
            if (sts == Sts.UNRECOGNIZED) {
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }
            lWm.op_ = sts.value;
        }

        static /* synthetic */ void e(LWm lWm, Iterable iterable) {
            MTP.RVV<tOB> rvv = lWm.filters_;
            if (!rvv.e()) {
                lWm.filters_ = KUw.mutableCopy(rvv);
            }
            AbstractC5573bvc.addAll(iterable, lWm.filters_);
        }

        public static LWm b() {
            return DEFAULT_INSTANCE;
        }
    }

    /* loaded from: classes2.dex */
    public static final class Sts extends KUw<Sts, LWm> implements GhW {
        private static final Sts DEFAULT_INSTANCE;
        public static final int FIELD_FIELD_NUMBER = 1;
        public static final int OP_FIELD_NUMBER = 2;
        private static volatile XgX<Sts> PARSER = null;
        public static final int VALUE_FIELD_NUMBER = 3;
        public ojQ field_;
        public int op_;
        public sbb value_;

        private Sts() {
        }

        /* loaded from: classes2.dex */
        public enum RVV implements MTP.IeS {
            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),
            UNRECOGNIZED(-1);

            public static final int ARRAY_CONTAINS_ANY_VALUE = 9;
            public static final int ARRAY_CONTAINS_VALUE = 7;
            public static final int EQUAL_VALUE = 5;
            public static final int GREATER_THAN_OR_EQUAL_VALUE = 4;
            public static final int GREATER_THAN_VALUE = 3;
            public static final int IN_VALUE = 8;
            public static final int LESS_THAN_OR_EQUAL_VALUE = 2;
            public static final int LESS_THAN_VALUE = 1;
            public static final int NOT_EQUAL_VALUE = 6;
            public static final int NOT_IN_VALUE = 10;
            public static final int OPERATOR_UNSPECIFIED_VALUE = 0;
            private static final MTP.HBt<RVV> internalValueMap = new MTP.HBt<RVV>() { // from class: o.CoM.Sts.RVV.5
            };
            final int value;

            @Override // o.MTP.IeS
            public final int d() {
                if (this != UNRECOGNIZED) {
                    return this.value;
                }
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }

            RVV(int i) {
                this.value = i;
            }

            public static RVV c(int i) {
                switch (i) {
                    case 0:
                        return OPERATOR_UNSPECIFIED;
                    case 1:
                        return LESS_THAN;
                    case 2:
                        return LESS_THAN_OR_EQUAL;
                    case 3:
                        return GREATER_THAN;
                    case 4:
                        return GREATER_THAN_OR_EQUAL;
                    case 5:
                        return EQUAL;
                    case 6:
                        return NOT_EQUAL;
                    case 7:
                        return ARRAY_CONTAINS;
                    case 8:
                        return IN;
                    case 9:
                        return ARRAY_CONTAINS_ANY;
                    case 10:
                        return NOT_IN;
                    default:
                        return null;
                }
            }
        }

        public static LWm b() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class LWm extends KUw.LWm<Sts, LWm> implements GhW {
            /* synthetic */ LWm(byte b) {
                this();
            }

            private LWm() {
                super(Sts.DEFAULT_INSTANCE);
            }

            public final LWm c(ojQ ojq) {
                copyOnWrite();
                ((Sts) this.instance).field_ = ojq;
                return this;
            }

            public final LWm b(RVV rvv) {
                copyOnWrite();
                Sts.b((Sts) this.instance, rvv);
                return this;
            }

            public final LWm d(sbb sbbVar) {
                copyOnWrite();
                ((Sts) this.instance).value_ = sbbVar;
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new Sts();
                case 2:
                    return new LWm((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0003\u0000\u0000\u0001\u0003\u0003\u0000\u0000\u0000\u0001\t\u0002\f\u0003\t", new Object[]{"field_", "op_", "value_"});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<Sts> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (Sts.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            Sts sts = new Sts();
            DEFAULT_INSTANCE = sts;
            KUw.registerDefaultInstance(Sts.class, sts);
        }

        static /* synthetic */ void b(Sts sts, RVV rvv) {
            if (rvv == RVV.UNRECOGNIZED) {
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }
            sts.op_ = rvv.value;
        }

        public static Sts d() {
            return DEFAULT_INSTANCE;
        }
    }

    /* loaded from: classes2.dex */
    public static final class jbe extends KUw<jbe, LWm> implements VQg {
        private static final jbe DEFAULT_INSTANCE;
        public static final int FIELD_FIELD_NUMBER = 2;
        public static final int OP_FIELD_NUMBER = 1;
        private static volatile XgX<jbe> PARSER;
        public int op_;
        public int operandTypeCase_ = 0;
        public Object operandType_;

        private jbe() {
        }

        /* loaded from: classes2.dex */
        public enum HBt implements MTP.IeS {
            OPERATOR_UNSPECIFIED(0),
            IS_NAN(2),
            IS_NULL(3),
            IS_NOT_NAN(4),
            IS_NOT_NULL(5),
            UNRECOGNIZED(-1);

            public static final int IS_NAN_VALUE = 2;
            public static final int IS_NOT_NAN_VALUE = 4;
            public static final int IS_NOT_NULL_VALUE = 5;
            public static final int IS_NULL_VALUE = 3;
            public static final int OPERATOR_UNSPECIFIED_VALUE = 0;
            private static final MTP.HBt<HBt> internalValueMap = new MTP.HBt<HBt>() { // from class: o.CoM.jbe.HBt.5
            };
            final int value;

            @Override // o.MTP.IeS
            public final int d() {
                if (this != UNRECOGNIZED) {
                    return this.value;
                }
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }

            HBt(int i) {
                this.value = i;
            }

            public static HBt c(int i) {
                if (i == 0) {
                    return OPERATOR_UNSPECIFIED;
                }
                if (i == 2) {
                    return IS_NAN;
                }
                if (i == 3) {
                    return IS_NULL;
                }
                if (i == 4) {
                    return IS_NOT_NAN;
                }
                if (i != 5) {
                    return null;
                }
                return IS_NOT_NULL;
            }
        }

        public static LWm d() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class LWm extends KUw.LWm<jbe, LWm> implements VQg {
            /* synthetic */ LWm(byte b) {
                this();
            }

            private LWm() {
                super(jbe.DEFAULT_INSTANCE);
            }

            public final LWm b(HBt hBt) {
                copyOnWrite();
                jbe.e((jbe) this.instance, hBt);
                return this;
            }

            public final LWm a(ojQ ojq) {
                copyOnWrite();
                jbe.c((jbe) this.instance, ojq);
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new jbe();
                case 2:
                    return new LWm((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0002\u0001\u0000\u0001\u0002\u0002\u0000\u0000\u0000\u0001\f\u0002<\u0000", new Object[]{"operandType_", "operandTypeCase_", "op_", ojQ.class});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<jbe> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (jbe.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            jbe jbeVar = new jbe();
            DEFAULT_INSTANCE = jbeVar;
            KUw.registerDefaultInstance(jbe.class, jbeVar);
        }

        static /* synthetic */ void e(jbe jbeVar, HBt hBt) {
            if (hBt == HBt.UNRECOGNIZED) {
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }
            jbeVar.op_ = hBt.value;
        }

        static /* synthetic */ void c(jbe jbeVar, ojQ ojq) {
            jbeVar.operandType_ = ojq;
            jbeVar.operandTypeCase_ = 2;
        }

        public static jbe c() {
            return DEFAULT_INSTANCE;
        }
    }

    /* loaded from: classes2.dex */
    public static final class ZqN extends KUw<ZqN, IeS> implements GKB {
        private static final ZqN DEFAULT_INSTANCE;
        public static final int DIRECTION_FIELD_NUMBER = 2;
        public static final int FIELD_FIELD_NUMBER = 1;
        private static volatile XgX<ZqN> PARSER;
        public int direction_;
        public ojQ field_;

        private ZqN() {
        }

        public static IeS b() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class IeS extends KUw.LWm<ZqN, IeS> implements GKB {
            /* synthetic */ IeS(byte b) {
                this();
            }

            private IeS() {
                super(ZqN.DEFAULT_INSTANCE);
            }

            public final IeS c(ojQ ojq) {
                copyOnWrite();
                ((ZqN) this.instance).field_ = ojq;
                return this;
            }

            public final IeS e(HBt hBt) {
                copyOnWrite();
                ZqN.e((ZqN) this.instance, hBt);
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new ZqN();
                case 2:
                    return new IeS((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0002\u0000\u0000\u0001\u0002\u0002\u0000\u0000\u0000\u0001\t\u0002\f", new Object[]{"field_", "direction_"});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<ZqN> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (ZqN.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            ZqN zqN = new ZqN();
            DEFAULT_INSTANCE = zqN;
            KUw.registerDefaultInstance(ZqN.class, zqN);
        }

        static /* synthetic */ void e(ZqN zqN, HBt hBt) {
            if (hBt == HBt.UNRECOGNIZED) {
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }
            zqN.direction_ = hBt.value;
        }
    }

    /* loaded from: classes2.dex */
    public static final class ojQ extends KUw<ojQ, LWm> implements uUy {
        private static final ojQ DEFAULT_INSTANCE;
        public static final int FIELD_PATH_FIELD_NUMBER = 2;
        private static volatile XgX<ojQ> PARSER;
        public String fieldPath_ = "";

        private ojQ() {
        }

        public static LWm d() {
            return DEFAULT_INSTANCE.createBuilder();
        }

        /* loaded from: classes2.dex */
        public static final class LWm extends KUw.LWm<ojQ, LWm> implements uUy {
            /* synthetic */ LWm(byte b) {
                this();
            }

            private LWm() {
                super(ojQ.DEFAULT_INSTANCE);
            }

            public final LWm e(String str) {
                copyOnWrite();
                ((ojQ) this.instance).fieldPath_ = str;
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new ojQ();
                case 2:
                    return new LWm((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0001\u0000\u0000\u0002\u0002\u0001\u0000\u0000\u0000\u0002Ȉ", new Object[]{"fieldPath_"});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<ojQ> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (ojQ.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            ojQ ojq = new ojQ();
            DEFAULT_INSTANCE = ojq;
            KUw.registerDefaultInstance(ojQ.class, ojq);
        }

        public static ojQ b() {
            return DEFAULT_INSTANCE;
        }
    }

    /* loaded from: classes2.dex */
    public static final class saX extends KUw<saX, LWm> implements SxX {
        private static final saX DEFAULT_INSTANCE;
        public static final int FIELDS_FIELD_NUMBER = 2;
        private static volatile XgX<saX> PARSER;
        private MTP.RVV<ojQ> fields_ = emptyProtobufList();

        private saX() {
        }

        /* loaded from: classes2.dex */
        public static final class LWm extends KUw.LWm<saX, LWm> implements SxX {
            /* synthetic */ LWm(byte b) {
                this();
            }

            private LWm() {
                super(saX.DEFAULT_INSTANCE);
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass5.c[ojq.ordinal()]) {
                case 1:
                    return new saX();
                case 2:
                    return new LWm((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0001\u0000\u0000\u0002\u0002\u0001\u0000\u0001\u0000\u0002\u001b", new Object[]{"fields_", ojQ.class});
                case 4:
                    return DEFAULT_INSTANCE;
                case 5:
                    XgX<saX> xgX2 = PARSER;
                    if (xgX2 != null) {
                        return xgX2;
                    }
                    synchronized (saX.class) {
                        xgX = PARSER;
                        if (xgX == null) {
                            xgX = new KUw.HBt(DEFAULT_INSTANCE);
                            PARSER = xgX;
                        }
                    }
                    return xgX;
                case 6:
                    return (byte) 1;
                case 7:
                    return null;
                default:
                    throw new UnsupportedOperationException();
            }
        }

        static {
            saX sax = new saX();
            DEFAULT_INSTANCE = sax;
            KUw.registerDefaultInstance(saX.class, sax);
        }
    }

    public static IeS b() {
        return DEFAULT_INSTANCE.createBuilder();
    }

    /* loaded from: classes2.dex */
    public static final class IeS extends KUw.LWm<CoM, IeS> implements InterfaceC15760iPT {
        /* synthetic */ IeS(byte b) {
            this();
        }

        private IeS() {
            super(CoM.DEFAULT_INSTANCE);
        }

        public final IeS b(RVV.C0081RVV c0081rvv) {
            copyOnWrite();
            CoM.b((CoM) this.instance, c0081rvv.build());
            return this;
        }

        public final IeS e(tOB tob) {
            copyOnWrite();
            ((CoM) this.instance).where_ = tob;
            return this;
        }

        public final IeS d(ZqN zqN) {
            copyOnWrite();
            CoM.e((CoM) this.instance, zqN);
            return this;
        }

        public final IeS b(PeW.HBt hBt) {
            copyOnWrite();
            ((CoM) this.instance).startAt_ = hBt.build();
            return this;
        }

        public final IeS c(PeW.HBt hBt) {
            copyOnWrite();
            ((CoM) this.instance).endAt_ = hBt.build();
            return this;
        }

        public final IeS e(C17555xkr.RVV rvv) {
            copyOnWrite();
            ((CoM) this.instance).limit_ = rvv.build();
            return this;
        }
    }

    @Override // o.KUw
    public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
        XgX xgX;
        switch (AnonymousClass5.c[ojq.ordinal()]) {
            case 1:
                return new CoM();
            case 2:
                return new IeS((byte) 0);
            case 3:
                return newMessageInfo(DEFAULT_INSTANCE, "\u0000\b\u0000\u0000\u0001\b\b\u0000\u0002\u0000\u0001\t\u0002\u001b\u0003\t\u0004\u001b\u0005\t\u0006\u0004\u0007\t\b\t", new Object[]{"select_", "from_", RVV.class, "where_", "orderBy_", ZqN.class, "limit_", "offset_", "startAt_", "endAt_"});
            case 4:
                return DEFAULT_INSTANCE;
            case 5:
                XgX<CoM> xgX2 = PARSER;
                if (xgX2 != null) {
                    return xgX2;
                }
                synchronized (CoM.class) {
                    xgX = PARSER;
                    if (xgX == null) {
                        xgX = new KUw.HBt(DEFAULT_INSTANCE);
                        PARSER = xgX;
                    }
                }
                return xgX;
            case 6:
                return (byte) 1;
            case 7:
                return null;
            default:
                throw new UnsupportedOperationException();
        }
    }

    static {
        CoM coM = new CoM();
        DEFAULT_INSTANCE = coM;
        KUw.registerDefaultInstance(CoM.class, coM);
    }

    static /* synthetic */ void b(CoM coM, RVV rvv) {
        MTP.RVV<RVV> rvv2 = coM.from_;
        if (!rvv2.e()) {
            coM.from_ = KUw.mutableCopy(rvv2);
        }
        coM.from_.add(rvv);
    }

    static /* synthetic */ void e(CoM coM, ZqN zqN) {
        MTP.RVV<ZqN> rvv = coM.orderBy_;
        if (!rvv.e()) {
            coM.orderBy_ = KUw.mutableCopy(rvv);
        }
        coM.orderBy_.add(zqN);
    }

    public static CoM e() {
        return DEFAULT_INSTANCE;
    }
}