// Copyright 2023-2025 Buf Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        (unknown)
// source: buf/validate/conformance/cases/wkt_timestamp.proto

//go:build !protoopaque

package cases

import (
	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type TimestampNone struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampNone) Reset() {
	*x = TimestampNone{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampNone) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampNone) ProtoMessage() {}

func (x *TimestampNone) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampNone) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampNone) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampNone) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampNone) ClearVal() {
	x.Val = nil
}

type TimestampNone_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampNone_builder) Build() *TimestampNone {
	m0 := &TimestampNone{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampRequired struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampRequired) Reset() {
	*x = TimestampRequired{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampRequired) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampRequired) ProtoMessage() {}

func (x *TimestampRequired) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampRequired) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampRequired) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampRequired) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampRequired) ClearVal() {
	x.Val = nil
}

type TimestampRequired_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampRequired_builder) Build() *TimestampRequired {
	m0 := &TimestampRequired{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampConst struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampConst) Reset() {
	*x = TimestampConst{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampConst) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampConst) ProtoMessage() {}

func (x *TimestampConst) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampConst) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampConst) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampConst) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampConst) ClearVal() {
	x.Val = nil
}

type TimestampConst_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampConst_builder) Build() *TimestampConst {
	m0 := &TimestampConst{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampLT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampLT) Reset() {
	*x = TimestampLT{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampLT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampLT) ProtoMessage() {}

func (x *TimestampLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampLT) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampLT) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampLT) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampLT) ClearVal() {
	x.Val = nil
}

type TimestampLT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampLT_builder) Build() *TimestampLT {
	m0 := &TimestampLT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampLTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampLTE) Reset() {
	*x = TimestampLTE{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampLTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampLTE) ProtoMessage() {}

func (x *TimestampLTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampLTE) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampLTE) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampLTE) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampLTE) ClearVal() {
	x.Val = nil
}

type TimestampLTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampLTE_builder) Build() *TimestampLTE {
	m0 := &TimestampLTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGT) Reset() {
	*x = TimestampGT{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGT) ProtoMessage() {}

func (x *TimestampGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGT) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGT) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGT) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGT) ClearVal() {
	x.Val = nil
}

type TimestampGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGT_builder) Build() *TimestampGT {
	m0 := &TimestampGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGTE) Reset() {
	*x = TimestampGTE{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGTE) ProtoMessage() {}

func (x *TimestampGTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGTE) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGTE) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGTE) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGTE) ClearVal() {
	x.Val = nil
}

type TimestampGTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGTE_builder) Build() *TimestampGTE {
	m0 := &TimestampGTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGTLT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGTLT) Reset() {
	*x = TimestampGTLT{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGTLT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGTLT) ProtoMessage() {}

func (x *TimestampGTLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGTLT) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGTLT) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGTLT) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGTLT) ClearVal() {
	x.Val = nil
}

type TimestampGTLT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGTLT_builder) Build() *TimestampGTLT {
	m0 := &TimestampGTLT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampExLTGT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampExLTGT) Reset() {
	*x = TimestampExLTGT{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampExLTGT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampExLTGT) ProtoMessage() {}

func (x *TimestampExLTGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampExLTGT) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampExLTGT) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampExLTGT) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampExLTGT) ClearVal() {
	x.Val = nil
}

type TimestampExLTGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampExLTGT_builder) Build() *TimestampExLTGT {
	m0 := &TimestampExLTGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGTELTE) Reset() {
	*x = TimestampGTELTE{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGTELTE) ProtoMessage() {}

func (x *TimestampGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGTELTE) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGTELTE) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGTELTE) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGTELTE) ClearVal() {
	x.Val = nil
}

type TimestampGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGTELTE_builder) Build() *TimestampGTELTE {
	m0 := &TimestampGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampExGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampExGTELTE) Reset() {
	*x = TimestampExGTELTE{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampExGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampExGTELTE) ProtoMessage() {}

func (x *TimestampExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampExGTELTE) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampExGTELTE) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampExGTELTE) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampExGTELTE) ClearVal() {
	x.Val = nil
}

type TimestampExGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampExGTELTE_builder) Build() *TimestampExGTELTE {
	m0 := &TimestampExGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampLTNow struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampLTNow) Reset() {
	*x = TimestampLTNow{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampLTNow) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampLTNow) ProtoMessage() {}

func (x *TimestampLTNow) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampLTNow) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampLTNow) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampLTNow) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampLTNow) ClearVal() {
	x.Val = nil
}

type TimestampLTNow_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampLTNow_builder) Build() *TimestampLTNow {
	m0 := &TimestampLTNow{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampNotLTNow struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampNotLTNow) Reset() {
	*x = TimestampNotLTNow{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampNotLTNow) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampNotLTNow) ProtoMessage() {}

func (x *TimestampNotLTNow) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampNotLTNow) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampNotLTNow) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampNotLTNow) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampNotLTNow) ClearVal() {
	x.Val = nil
}

type TimestampNotLTNow_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampNotLTNow_builder) Build() *TimestampNotLTNow {
	m0 := &TimestampNotLTNow{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGTNow struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGTNow) Reset() {
	*x = TimestampGTNow{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGTNow) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGTNow) ProtoMessage() {}

func (x *TimestampGTNow) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGTNow) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGTNow) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGTNow) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGTNow) ClearVal() {
	x.Val = nil
}

type TimestampGTNow_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGTNow_builder) Build() *TimestampGTNow {
	m0 := &TimestampGTNow{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampNotGTNow struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampNotGTNow) Reset() {
	*x = TimestampNotGTNow{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampNotGTNow) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampNotGTNow) ProtoMessage() {}

func (x *TimestampNotGTNow) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampNotGTNow) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampNotGTNow) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampNotGTNow) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampNotGTNow) ClearVal() {
	x.Val = nil
}

type TimestampNotGTNow_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampNotGTNow_builder) Build() *TimestampNotGTNow {
	m0 := &TimestampNotGTNow{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampWithin struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWithin) Reset() {
	*x = TimestampWithin{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWithin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWithin) ProtoMessage() {}

func (x *TimestampWithin) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWithin) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampWithin) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampWithin) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampWithin) ClearVal() {
	x.Val = nil
}

type TimestampWithin_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampWithin_builder) Build() *TimestampWithin {
	m0 := &TimestampWithin{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampLTNowWithin struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampLTNowWithin) Reset() {
	*x = TimestampLTNowWithin{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampLTNowWithin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampLTNowWithin) ProtoMessage() {}

func (x *TimestampLTNowWithin) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampLTNowWithin) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampLTNowWithin) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampLTNowWithin) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampLTNowWithin) ClearVal() {
	x.Val = nil
}

type TimestampLTNowWithin_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampLTNowWithin_builder) Build() *TimestampLTNowWithin {
	m0 := &TimestampLTNowWithin{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampGTNowWithin struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampGTNowWithin) Reset() {
	*x = TimestampGTNowWithin{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampGTNowWithin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampGTNowWithin) ProtoMessage() {}

func (x *TimestampGTNowWithin) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampGTNowWithin) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampGTNowWithin) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampGTNowWithin) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampGTNowWithin) ClearVal() {
	x.Val = nil
}

type TimestampGTNowWithin_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampGTNowWithin_builder) Build() *TimestampGTNowWithin {
	m0 := &TimestampGTNowWithin{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampExample struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampExample) Reset() {
	*x = TimestampExample{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampExample) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampExample) ProtoMessage() {}

func (x *TimestampExample) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampExample) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampExample) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *TimestampExample) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampExample) ClearVal() {
	x.Val = nil
}

type TimestampExample_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 TimestampExample_builder) Build() *TimestampExample {
	m0 := &TimestampExample{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

// The below messages should throw compilation errors due to rules being applied toincorrect types.
type TimestampWrongTypeScalar struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWrongTypeScalar) Reset() {
	*x = TimestampWrongTypeScalar{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWrongTypeScalar) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWrongTypeScalar) ProtoMessage() {}

func (x *TimestampWrongTypeScalar) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWrongTypeScalar) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *TimestampWrongTypeScalar) SetVal(v int32) {
	x.Val = v
}

type TimestampWrongTypeScalar_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 TimestampWrongTypeScalar_builder) Build() *TimestampWrongTypeScalar {
	m0 := &TimestampWrongTypeScalar{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampWrongTypeMessage struct {
	state         protoimpl.MessageState               `protogen:"hybrid.v1"`
	Val           *TimestampWrongTypeMessage_WrongType `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWrongTypeMessage) Reset() {
	*x = TimestampWrongTypeMessage{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWrongTypeMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWrongTypeMessage) ProtoMessage() {}

func (x *TimestampWrongTypeMessage) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWrongTypeMessage) GetVal() *TimestampWrongTypeMessage_WrongType {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampWrongTypeMessage) SetVal(v *TimestampWrongTypeMessage_WrongType) {
	x.Val = v
}

func (x *TimestampWrongTypeMessage) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampWrongTypeMessage) ClearVal() {
	x.Val = nil
}

type TimestampWrongTypeMessage_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *TimestampWrongTypeMessage_WrongType
}

func (b0 TimestampWrongTypeMessage_builder) Build() *TimestampWrongTypeMessage {
	m0 := &TimestampWrongTypeMessage{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampWrongTypeWrapper struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWrongTypeWrapper) Reset() {
	*x = TimestampWrongTypeWrapper{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWrongTypeWrapper) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWrongTypeWrapper) ProtoMessage() {}

func (x *TimestampWrongTypeWrapper) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWrongTypeWrapper) GetVal() *wrapperspb.Int32Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampWrongTypeWrapper) SetVal(v *wrapperspb.Int32Value) {
	x.Val = v
}

func (x *TimestampWrongTypeWrapper) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampWrongTypeWrapper) ClearVal() {
	x.Val = nil
}

type TimestampWrongTypeWrapper_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.Int32Value
}

func (b0 TimestampWrongTypeWrapper_builder) Build() *TimestampWrongTypeWrapper {
	m0 := &TimestampWrongTypeWrapper{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampWrongTypeWKT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *durationpb.Duration   `protobuf:"bytes,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWrongTypeWKT) Reset() {
	*x = TimestampWrongTypeWKT{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWrongTypeWKT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWrongTypeWKT) ProtoMessage() {}

func (x *TimestampWrongTypeWKT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWrongTypeWKT) GetVal() *durationpb.Duration {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *TimestampWrongTypeWKT) SetVal(v *durationpb.Duration) {
	x.Val = v
}

func (x *TimestampWrongTypeWKT) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *TimestampWrongTypeWKT) ClearVal() {
	x.Val = nil
}

type TimestampWrongTypeWKT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *durationpb.Duration
}

func (b0 TimestampWrongTypeWKT_builder) Build() *TimestampWrongTypeWKT {
	m0 := &TimestampWrongTypeWKT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type TimestampWrongTypeMessage_WrongType struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimestampWrongTypeMessage_WrongType) Reset() {
	*x = TimestampWrongTypeMessage_WrongType{}
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TimestampWrongTypeMessage_WrongType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TimestampWrongTypeMessage_WrongType) ProtoMessage() {}

func (x *TimestampWrongTypeMessage_WrongType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TimestampWrongTypeMessage_WrongType) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *TimestampWrongTypeMessage_WrongType) SetVal(v int32) {
	x.Val = v
}

type TimestampWrongTypeMessage_WrongType_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 TimestampWrongTypeMessage_WrongType_builder) Build() *TimestampWrongTypeMessage_WrongType {
	m0 := &TimestampWrongTypeMessage_WrongType{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

var File_buf_validate_conformance_cases_wkt_timestamp_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_wkt_timestamp_proto_rawDesc = "" +
	"\n" +
	"2buf/validate/conformance/cases/wkt_timestamp.proto\x12\x1ebuf.validate.conformance.cases\x1a\x1bbuf/validate/validate.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\"=\n" +
	"\rTimestampNone\x12,\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x03val\"I\n" +
	"\x11TimestampRequired\x124\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\x03val\"J\n" +
	"\x0eTimestampConst\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\n" +
	"\xbaH\a\xb2\x01\x04\x12\x02\b\x03R\x03val\"E\n" +
	"\vTimestampLT\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x02\x1a\x00R\x03val\"H\n" +
	"\fTimestampLTE\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\n" +
	"\xbaH\a\xb2\x01\x04\"\x02\b\x01R\x03val\"H\n" +
	"\vTimestampGT\x129\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\v\xbaH\b\xb2\x01\x05*\x03\x10\xe8\aR\x03val\"J\n" +
	"\fTimestampGTE\x12:\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\f\xbaH\t\xb2\x01\x062\x04\x10\xc0\x84=R\x03val\"K\n" +
	"\rTimestampGTLT\x12:\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\f\xbaH\t\xb2\x01\x06\x1a\x02\b\x01*\x00R\x03val\"M\n" +
	"\x0fTimestampExLTGT\x12:\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\f\xbaH\t\xb2\x01\x06\x1a\x00*\x02\b\x01R\x03val\"P\n" +
	"\x0fTimestampGTELTE\x12=\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\x0f\xbaH\f\xb2\x01\t\"\x03\b\x90\x1c2\x02\b<R\x03val\"R\n" +
	"\x11TimestampExGTELTE\x12=\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\x0f\xbaH\f\xb2\x01\t\"\x02\b<2\x03\b\x90\x1cR\x03val\"H\n" +
	"\x0eTimestampLTNow\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x028\x01R\x03val\"K\n" +
	"\x11TimestampNotLTNow\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x028\x00R\x03val\"H\n" +
	"\x0eTimestampGTNow\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x02@\x01R\x03val\"K\n" +
	"\x11TimestampNotGTNow\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x02@\x00R\x03val\"L\n" +
	"\x0fTimestampWithin\x129\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\v\xbaH\b\xb2\x01\x05J\x03\b\x90\x1cR\x03val\"S\n" +
	"\x14TimestampLTNowWithin\x12;\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\r\xbaH\n" +
	"\xb2\x01\aJ\x03\b\x90\x1c8\x01R\x03val\"S\n" +
	"\x14TimestampGTNowWithin\x12;\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\r\xbaH\n" +
	"\xb2\x01\aJ\x03\b\x90\x1c@\x01R\x03val\"L\n" +
	"\x10TimestampExample\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\n" +
	"\xbaH\a\xb2\x01\x04R\x02\b\x03R\x03val\"6\n" +
	"\x18TimestampWrongTypeScalar\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x05B\b\xbaH\x05\xb2\x01\x028\x01R\x03val\"\x9b\x01\n" +
	"\x19TimestampWrongTypeMessage\x12_\n" +
	"\x03val\x18\x01 \x01(\v2C.buf.validate.conformance.cases.TimestampWrongTypeMessage.WrongTypeB\b\xbaH\x05\xb2\x01\x028\x01R\x03val\x1a\x1d\n" +
	"\tWrongType\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x05R\x03val\"T\n" +
	"\x19TimestampWrongTypeWrapper\x127\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.Int32ValueB\b\xbaH\x05\xb2\x01\x028\x01R\x03val\"N\n" +
	"\x15TimestampWrongTypeWKT\x125\n" +
	"\x03val\x18\x01 \x01(\v2\x19.google.protobuf.DurationB\b\xbaH\x05\xb2\x01\x028\x01R\x03valB\x9b\x02\n" +
	"\"com.buf.validate.conformance.casesB\x11WktTimestampProtoP\x01ZFbuf.build/go/protovalidate/internal/gen/buf/validate/conformance/cases\xa2\x02\x04BVCC\xaa\x02\x1eBuf.Validate.Conformance.Cases\xca\x02\x1eBuf\\Validate\\Conformance\\Cases\xe2\x02*Buf\\Validate\\Conformance\\Cases\\GPBMetadata\xea\x02!Buf::Validate::Conformance::Casesb\x06proto3"

var file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
var file_buf_validate_conformance_cases_wkt_timestamp_proto_goTypes = []any{
	(*TimestampNone)(nil),                       // 0: buf.validate.conformance.cases.TimestampNone
	(*TimestampRequired)(nil),                   // 1: buf.validate.conformance.cases.TimestampRequired
	(*TimestampConst)(nil),                      // 2: buf.validate.conformance.cases.TimestampConst
	(*TimestampLT)(nil),                         // 3: buf.validate.conformance.cases.TimestampLT
	(*TimestampLTE)(nil),                        // 4: buf.validate.conformance.cases.TimestampLTE
	(*TimestampGT)(nil),                         // 5: buf.validate.conformance.cases.TimestampGT
	(*TimestampGTE)(nil),                        // 6: buf.validate.conformance.cases.TimestampGTE
	(*TimestampGTLT)(nil),                       // 7: buf.validate.conformance.cases.TimestampGTLT
	(*TimestampExLTGT)(nil),                     // 8: buf.validate.conformance.cases.TimestampExLTGT
	(*TimestampGTELTE)(nil),                     // 9: buf.validate.conformance.cases.TimestampGTELTE
	(*TimestampExGTELTE)(nil),                   // 10: buf.validate.conformance.cases.TimestampExGTELTE
	(*TimestampLTNow)(nil),                      // 11: buf.validate.conformance.cases.TimestampLTNow
	(*TimestampNotLTNow)(nil),                   // 12: buf.validate.conformance.cases.TimestampNotLTNow
	(*TimestampGTNow)(nil),                      // 13: buf.validate.conformance.cases.TimestampGTNow
	(*TimestampNotGTNow)(nil),                   // 14: buf.validate.conformance.cases.TimestampNotGTNow
	(*TimestampWithin)(nil),                     // 15: buf.validate.conformance.cases.TimestampWithin
	(*TimestampLTNowWithin)(nil),                // 16: buf.validate.conformance.cases.TimestampLTNowWithin
	(*TimestampGTNowWithin)(nil),                // 17: buf.validate.conformance.cases.TimestampGTNowWithin
	(*TimestampExample)(nil),                    // 18: buf.validate.conformance.cases.TimestampExample
	(*TimestampWrongTypeScalar)(nil),            // 19: buf.validate.conformance.cases.TimestampWrongTypeScalar
	(*TimestampWrongTypeMessage)(nil),           // 20: buf.validate.conformance.cases.TimestampWrongTypeMessage
	(*TimestampWrongTypeWrapper)(nil),           // 21: buf.validate.conformance.cases.TimestampWrongTypeWrapper
	(*TimestampWrongTypeWKT)(nil),               // 22: buf.validate.conformance.cases.TimestampWrongTypeWKT
	(*TimestampWrongTypeMessage_WrongType)(nil), // 23: buf.validate.conformance.cases.TimestampWrongTypeMessage.WrongType
	(*timestamppb.Timestamp)(nil),               // 24: google.protobuf.Timestamp
	(*wrapperspb.Int32Value)(nil),               // 25: google.protobuf.Int32Value
	(*durationpb.Duration)(nil),                 // 26: google.protobuf.Duration
}
var file_buf_validate_conformance_cases_wkt_timestamp_proto_depIdxs = []int32{
	24, // 0: buf.validate.conformance.cases.TimestampNone.val:type_name -> google.protobuf.Timestamp
	24, // 1: buf.validate.conformance.cases.TimestampRequired.val:type_name -> google.protobuf.Timestamp
	24, // 2: buf.validate.conformance.cases.TimestampConst.val:type_name -> google.protobuf.Timestamp
	24, // 3: buf.validate.conformance.cases.TimestampLT.val:type_name -> google.protobuf.Timestamp
	24, // 4: buf.validate.conformance.cases.TimestampLTE.val:type_name -> google.protobuf.Timestamp
	24, // 5: buf.validate.conformance.cases.TimestampGT.val:type_name -> google.protobuf.Timestamp
	24, // 6: buf.validate.conformance.cases.TimestampGTE.val:type_name -> google.protobuf.Timestamp
	24, // 7: buf.validate.conformance.cases.TimestampGTLT.val:type_name -> google.protobuf.Timestamp
	24, // 8: buf.validate.conformance.cases.TimestampExLTGT.val:type_name -> google.protobuf.Timestamp
	24, // 9: buf.validate.conformance.cases.TimestampGTELTE.val:type_name -> google.protobuf.Timestamp
	24, // 10: buf.validate.conformance.cases.TimestampExGTELTE.val:type_name -> google.protobuf.Timestamp
	24, // 11: buf.validate.conformance.cases.TimestampLTNow.val:type_name -> google.protobuf.Timestamp
	24, // 12: buf.validate.conformance.cases.TimestampNotLTNow.val:type_name -> google.protobuf.Timestamp
	24, // 13: buf.validate.conformance.cases.TimestampGTNow.val:type_name -> google.protobuf.Timestamp
	24, // 14: buf.validate.conformance.cases.TimestampNotGTNow.val:type_name -> google.protobuf.Timestamp
	24, // 15: buf.validate.conformance.cases.TimestampWithin.val:type_name -> google.protobuf.Timestamp
	24, // 16: buf.validate.conformance.cases.TimestampLTNowWithin.val:type_name -> google.protobuf.Timestamp
	24, // 17: buf.validate.conformance.cases.TimestampGTNowWithin.val:type_name -> google.protobuf.Timestamp
	24, // 18: buf.validate.conformance.cases.TimestampExample.val:type_name -> google.protobuf.Timestamp
	23, // 19: buf.validate.conformance.cases.TimestampWrongTypeMessage.val:type_name -> buf.validate.conformance.cases.TimestampWrongTypeMessage.WrongType
	25, // 20: buf.validate.conformance.cases.TimestampWrongTypeWrapper.val:type_name -> google.protobuf.Int32Value
	26, // 21: buf.validate.conformance.cases.TimestampWrongTypeWKT.val:type_name -> google.protobuf.Duration
	22, // [22:22] is the sub-list for method output_type
	22, // [22:22] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_wkt_timestamp_proto_init() }
func file_buf_validate_conformance_cases_wkt_timestamp_proto_init() {
	if File_buf_validate_conformance_cases_wkt_timestamp_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_buf_validate_conformance_cases_wkt_timestamp_proto_rawDesc), len(file_buf_validate_conformance_cases_wkt_timestamp_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   24,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_wkt_timestamp_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_wkt_timestamp_proto_depIdxs,
		MessageInfos:      file_buf_validate_conformance_cases_wkt_timestamp_proto_msgTypes,
	}.Build()
	File_buf_validate_conformance_cases_wkt_timestamp_proto = out.File
	file_buf_validate_conformance_cases_wkt_timestamp_proto_goTypes = nil
	file_buf_validate_conformance_cases_wkt_timestamp_proto_depIdxs = nil
}
