package o;

import o.KUw;
import o.MTP;
import o.uOO;

/* loaded from: classes2.dex */
public final class veo extends KUw<veo, IeS> implements riE {
    private static final veo DEFAULT_INSTANCE;
    public static final int DOCUMENT_FIELD_NUMBER = 1;
    public static final int FIELD_TRANSFORMS_FIELD_NUMBER = 2;
    private static volatile XgX<veo> PARSER;
    private String document_ = "";
    public MTP.RVV<Sts> fieldTransforms_ = emptyProtobufList();

    private veo() {
    }

    /* loaded from: classes2.dex */
    public static final class Sts extends KUw<Sts, IeS> implements HGX {
        public static final int APPEND_MISSING_ELEMENTS_FIELD_NUMBER = 6;
        private static final Sts DEFAULT_INSTANCE;
        public static final int FIELD_PATH_FIELD_NUMBER = 1;
        public static final int INCREMENT_FIELD_NUMBER = 3;
        public static final int MAXIMUM_FIELD_NUMBER = 4;
        public static final int MINIMUM_FIELD_NUMBER = 5;
        private static volatile XgX<Sts> PARSER = null;
        public static final int REMOVE_ALL_FROM_ARRAY_FIELD_NUMBER = 7;
        public static final int SET_TO_SERVER_VALUE_FIELD_NUMBER = 2;
        public Object transformType_;
        public int transformTypeCase_ = 0;
        public String fieldPath_ = "";

        private Sts() {
        }

        /* renamed from: o.veo$Sts$Sts, reason: collision with other inner class name */
        /* loaded from: classes2.dex */
        public enum EnumC0125Sts implements MTP.IeS {
            SERVER_VALUE_UNSPECIFIED(0),
            REQUEST_TIME(1),
            UNRECOGNIZED(-1);

            public static final int REQUEST_TIME_VALUE = 1;
            public static final int SERVER_VALUE_UNSPECIFIED_VALUE = 0;
            private static final MTP.HBt<EnumC0125Sts> internalValueMap = new MTP.HBt<EnumC0125Sts>() { // from class: o.veo.Sts.Sts.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.");
            }

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

            public static EnumC0125Sts a(int i) {
                if (i == 0) {
                    return SERVER_VALUE_UNSPECIFIED;
                }
                if (i != 1) {
                    return null;
                }
                return REQUEST_TIME;
            }
        }

        /* loaded from: classes2.dex */
        public enum HBt {
            SET_TO_SERVER_VALUE(2),
            INCREMENT(3),
            MAXIMUM(4),
            MINIMUM(5),
            APPEND_MISSING_ELEMENTS(6),
            REMOVE_ALL_FROM_ARRAY(7),
            TRANSFORMTYPE_NOT_SET(0);

            private final int value;

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

            public static HBt c(int i) {
                if (i == 0) {
                    return TRANSFORMTYPE_NOT_SET;
                }
                switch (i) {
                    case 2:
                        return SET_TO_SERVER_VALUE;
                    case 3:
                        return INCREMENT;
                    case 4:
                        return MAXIMUM;
                    case 5:
                        return MINIMUM;
                    case 6:
                        return APPEND_MISSING_ELEMENTS;
                    case 7:
                        return REMOVE_ALL_FROM_ARRAY;
                    default:
                        return null;
                }
            }
        }

        public final EnumC0125Sts d() {
            if (this.transformTypeCase_ == 2) {
                EnumC0125Sts a = EnumC0125Sts.a(((Integer) this.transformType_).intValue());
                return a == null ? EnumC0125Sts.UNRECOGNIZED : a;
            }
            return EnumC0125Sts.SERVER_VALUE_UNSPECIFIED;
        }

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

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

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

            public final IeS d(String str) {
                copyOnWrite();
                ((Sts) this.instance).fieldPath_ = str;
                return this;
            }

            public final IeS d(EnumC0125Sts enumC0125Sts) {
                copyOnWrite();
                Sts.c((Sts) this.instance, enumC0125Sts);
                return this;
            }

            public final IeS c(sbb sbbVar) {
                copyOnWrite();
                Sts.e((Sts) this.instance, sbbVar);
                return this;
            }

            public final IeS d(uOO.IeS ieS) {
                copyOnWrite();
                Sts.c((Sts) this.instance, ieS.build());
                return this;
            }

            public final IeS c(uOO.IeS ieS) {
                copyOnWrite();
                Sts.a((Sts) this.instance, ieS.build());
                return this;
            }
        }

        @Override // o.KUw
        public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
            XgX xgX;
            switch (AnonymousClass1.d[ojq.ordinal()]) {
                case 1:
                    return new Sts();
                case 2:
                    return new IeS((byte) 0);
                case 3:
                    return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0007\u0001\u0000\u0001\u0007\u0007\u0000\u0000\u0000\u0001Ȉ\u0002?\u0000\u0003<\u0000\u0004<\u0000\u0005<\u0000\u0006<\u0000\u0007<\u0000", new Object[]{"transformType_", "transformTypeCase_", "fieldPath_", sbb.class, sbb.class, sbb.class, uOO.class, uOO.class});
                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 c(Sts sts, uOO uoo) {
            sts.transformType_ = uoo;
            sts.transformTypeCase_ = 6;
        }

        static /* synthetic */ void a(Sts sts, uOO uoo) {
            sts.transformType_ = uoo;
            sts.transformTypeCase_ = 7;
        }

        static /* synthetic */ void c(Sts sts, EnumC0125Sts enumC0125Sts) {
            if (enumC0125Sts == EnumC0125Sts.UNRECOGNIZED) {
                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
            }
            sts.transformType_ = Integer.valueOf(enumC0125Sts.value);
            sts.transformTypeCase_ = 2;
        }

        static /* synthetic */ void e(Sts sts, sbb sbbVar) {
            sts.transformType_ = sbbVar;
            sts.transformTypeCase_ = 3;
        }
    }

    /* renamed from: o.veo$1, reason: invalid class name */
    /* loaded from: classes2.dex */
    static /* synthetic */ class AnonymousClass1 {
        static final int[] d;

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

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

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

    @Override // o.KUw
    public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
        XgX xgX;
        switch (AnonymousClass1.d[ojq.ordinal()]) {
            case 1:
                return new veo();
            case 2:
                return new IeS((byte) 0);
            case 3:
                return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0002\u0000\u0000\u0001\u0002\u0002\u0000\u0001\u0000\u0001Ȉ\u0002\u001b", new Object[]{"document_", "fieldTransforms_", Sts.class});
            case 4:
                return DEFAULT_INSTANCE;
            case 5:
                XgX<veo> xgX2 = PARSER;
                if (xgX2 != null) {
                    return xgX2;
                }
                synchronized (veo.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 {
        veo veoVar = new veo();
        DEFAULT_INSTANCE = veoVar;
        KUw.registerDefaultInstance(veo.class, veoVar);
    }

    public static veo a() {
        return DEFAULT_INSTANCE;
    }
}