// Code generated by protoc-gen-go.
// source: va/proto/va.proto
// DO NOT EDIT!

/*
Package proto is a generated protocol buffer package.

It is generated from these files:
	va/proto/va.proto

It has these top-level messages:
	IsCAAValidRequest
	IsCAAValidResponse
	IsSafeDomainRequest
	IsDomainSafe
	PerformValidationRequest
	AuthzMeta
	ValidationResult
*/
package proto

import proto1 "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import core "github.com/letsencrypt/boulder/core/proto"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto1.ProtoPackageIsVersion2 // please upgrade the proto package

type IsCAAValidRequest struct {
	// NOTE: Domain may be a name with a wildcard prefix (e.g. `*.example.com`)
	Domain           *string `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *IsCAAValidRequest) Reset()                    { *m = IsCAAValidRequest{} }
func (m *IsCAAValidRequest) String() string            { return proto1.CompactTextString(m) }
func (*IsCAAValidRequest) ProtoMessage()               {}
func (*IsCAAValidRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *IsCAAValidRequest) GetDomain() string {
	if m != nil && m.Domain != nil {
		return *m.Domain
	}
	return ""
}

// If CAA is valid for the requested domain, the problem will be empty
type IsCAAValidResponse struct {
	Problem          *core.ProblemDetails `protobuf:"bytes,1,opt,name=problem" json:"problem,omitempty"`
	XXX_unrecognized []byte               `json:"-"`
}

func (m *IsCAAValidResponse) Reset()                    { *m = IsCAAValidResponse{} }
func (m *IsCAAValidResponse) String() string            { return proto1.CompactTextString(m) }
func (*IsCAAValidResponse) ProtoMessage()               {}
func (*IsCAAValidResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *IsCAAValidResponse) GetProblem() *core.ProblemDetails {
	if m != nil {
		return m.Problem
	}
	return nil
}

type IsSafeDomainRequest struct {
	Domain           *string `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *IsSafeDomainRequest) Reset()                    { *m = IsSafeDomainRequest{} }
func (m *IsSafeDomainRequest) String() string            { return proto1.CompactTextString(m) }
func (*IsSafeDomainRequest) ProtoMessage()               {}
func (*IsSafeDomainRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *IsSafeDomainRequest) GetDomain() string {
	if m != nil && m.Domain != nil {
		return *m.Domain
	}
	return ""
}

type IsDomainSafe struct {
	IsSafe           *bool  `protobuf:"varint,1,opt,name=isSafe" json:"isSafe,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *IsDomainSafe) Reset()                    { *m = IsDomainSafe{} }
func (m *IsDomainSafe) String() string            { return proto1.CompactTextString(m) }
func (*IsDomainSafe) ProtoMessage()               {}
func (*IsDomainSafe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

func (m *IsDomainSafe) GetIsSafe() bool {
	if m != nil && m.IsSafe != nil {
		return *m.IsSafe
	}
	return false
}

type PerformValidationRequest struct {
	Domain           *string         `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
	Challenge        *core.Challenge `protobuf:"bytes,2,opt,name=challenge" json:"challenge,omitempty"`
	Authz            *AuthzMeta      `protobuf:"bytes,3,opt,name=authz" json:"authz,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *PerformValidationRequest) Reset()                    { *m = PerformValidationRequest{} }
func (m *PerformValidationRequest) String() string            { return proto1.CompactTextString(m) }
func (*PerformValidationRequest) ProtoMessage()               {}
func (*PerformValidationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *PerformValidationRequest) GetDomain() string {
	if m != nil && m.Domain != nil {
		return *m.Domain
	}
	return ""
}

func (m *PerformValidationRequest) GetChallenge() *core.Challenge {
	if m != nil {
		return m.Challenge
	}
	return nil
}

func (m *PerformValidationRequest) GetAuthz() *AuthzMeta {
	if m != nil {
		return m.Authz
	}
	return nil
}

type AuthzMeta struct {
	Id               *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	RegID            *int64  `protobuf:"varint,2,opt,name=regID" json:"regID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *AuthzMeta) Reset()                    { *m = AuthzMeta{} }
func (m *AuthzMeta) String() string            { return proto1.CompactTextString(m) }
func (*AuthzMeta) ProtoMessage()               {}
func (*AuthzMeta) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *AuthzMeta) GetId() string {
	if m != nil && m.Id != nil {
		return *m.Id
	}
	return ""
}

func (m *AuthzMeta) GetRegID() int64 {
	if m != nil && m.RegID != nil {
		return *m.RegID
	}
	return 0
}

type ValidationResult struct {
	Records          []*core.ValidationRecord `protobuf:"bytes,1,rep,name=records" json:"records,omitempty"`
	Problems         *core.ProblemDetails     `protobuf:"bytes,2,opt,name=problems" json:"problems,omitempty"`
	XXX_unrecognized []byte                   `json:"-"`
}

func (m *ValidationResult) Reset()                    { *m = ValidationResult{} }
func (m *ValidationResult) String() string            { return proto1.CompactTextString(m) }
func (*ValidationResult) ProtoMessage()               {}
func (*ValidationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *ValidationResult) GetRecords() []*core.ValidationRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *ValidationResult) GetProblems() *core.ProblemDetails {
	if m != nil {
		return m.Problems
	}
	return nil
}

func init() {
	proto1.RegisterType((*IsCAAValidRequest)(nil), "va.IsCAAValidRequest")
	proto1.RegisterType((*IsCAAValidResponse)(nil), "va.IsCAAValidResponse")
	proto1.RegisterType((*IsSafeDomainRequest)(nil), "va.IsSafeDomainRequest")
	proto1.RegisterType((*IsDomainSafe)(nil), "va.IsDomainSafe")
	proto1.RegisterType((*PerformValidationRequest)(nil), "va.PerformValidationRequest")
	proto1.RegisterType((*AuthzMeta)(nil), "va.AuthzMeta")
	proto1.RegisterType((*ValidationResult)(nil), "va.ValidationResult")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for VA service

type VAClient interface {
	IsSafeDomain(ctx context.Context, in *IsSafeDomainRequest, opts ...grpc.CallOption) (*IsDomainSafe, error)
	PerformValidation(ctx context.Context, in *PerformValidationRequest, opts ...grpc.CallOption) (*ValidationResult, error)
}

type vAClient struct {
	cc *grpc.ClientConn
}

func NewVAClient(cc *grpc.ClientConn) VAClient {
	return &vAClient{cc}
}

func (c *vAClient) IsSafeDomain(ctx context.Context, in *IsSafeDomainRequest, opts ...grpc.CallOption) (*IsDomainSafe, error) {
	out := new(IsDomainSafe)
	err := grpc.Invoke(ctx, "/va.VA/IsSafeDomain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vAClient) PerformValidation(ctx context.Context, in *PerformValidationRequest, opts ...grpc.CallOption) (*ValidationResult, error) {
	out := new(ValidationResult)
	err := grpc.Invoke(ctx, "/va.VA/PerformValidation", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for VA service

type VAServer interface {
	IsSafeDomain(context.Context, *IsSafeDomainRequest) (*IsDomainSafe, error)
	PerformValidation(context.Context, *PerformValidationRequest) (*ValidationResult, error)
}

func RegisterVAServer(s *grpc.Server, srv VAServer) {
	s.RegisterService(&_VA_serviceDesc, srv)
}

func _VA_IsSafeDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsSafeDomainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VAServer).IsSafeDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/va.VA/IsSafeDomain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VAServer).IsSafeDomain(ctx, req.(*IsSafeDomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VA_PerformValidation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PerformValidationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VAServer).PerformValidation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/va.VA/PerformValidation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VAServer).PerformValidation(ctx, req.(*PerformValidationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VA_serviceDesc = grpc.ServiceDesc{
	ServiceName: "va.VA",
	HandlerType: (*VAServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "IsSafeDomain",
			Handler:    _VA_IsSafeDomain_Handler,
		},
		{
			MethodName: "PerformValidation",
			Handler:    _VA_PerformValidation_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "va/proto/va.proto",
}

// Client API for CAA service

type CAAClient interface {
	IsCAAValid(ctx context.Context, in *IsCAAValidRequest, opts ...grpc.CallOption) (*IsCAAValidResponse, error)
}

type cAAClient struct {
	cc *grpc.ClientConn
}

func NewCAAClient(cc *grpc.ClientConn) CAAClient {
	return &cAAClient{cc}
}

func (c *cAAClient) IsCAAValid(ctx context.Context, in *IsCAAValidRequest, opts ...grpc.CallOption) (*IsCAAValidResponse, error) {
	out := new(IsCAAValidResponse)
	err := grpc.Invoke(ctx, "/va.CAA/IsCAAValid", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for CAA service

type CAAServer interface {
	IsCAAValid(context.Context, *IsCAAValidRequest) (*IsCAAValidResponse, error)
}

func RegisterCAAServer(s *grpc.Server, srv CAAServer) {
	s.RegisterService(&_CAA_serviceDesc, srv)
}

func _CAA_IsCAAValid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsCAAValidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CAAServer).IsCAAValid(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/va.CAA/IsCAAValid",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CAAServer).IsCAAValid(ctx, req.(*IsCAAValidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CAA_serviceDesc = grpc.ServiceDesc{
	ServiceName: "va.CAA",
	HandlerType: (*CAAServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "IsCAAValid",
			Handler:    _CAA_IsCAAValid_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "va/proto/va.proto",
}

func init() { proto1.RegisterFile("va/proto/va.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 396 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x3d, 0xaf, 0xda, 0x30,
	0x14, 0x86, 0x49, 0x22, 0xca, 0xe5, 0xdc, 0x7e, 0x5c, 0x4e, 0x81, 0x46, 0x51, 0x07, 0xe4, 0x4a,
	0x15, 0x52, 0x45, 0xa0, 0x59, 0xab, 0x0e, 0x29, 0x59, 0x32, 0x54, 0x42, 0xae, 0xc4, 0xd0, 0xcd,
	0x25, 0x06, 0x22, 0x05, 0x4c, 0xed, 0x90, 0xa1, 0x3f, 0xa0, 0x53, 0x7f, 0x74, 0x65, 0x3b, 0x10,
	0x44, 0xa9, 0xd8, 0xec, 0xf3, 0x3e, 0xf6, 0xf9, 0x78, 0x0f, 0xf4, 0x2a, 0x36, 0x3d, 0x48, 0x51,
	0x8a, 0x69, 0xc5, 0x42, 0x73, 0x40, 0xb7, 0x62, 0xc1, 0x60, 0x25, 0x24, 0xaf, 0x05, 0x7d, 0xb4,
	0x12, 0xf9, 0x00, 0xbd, 0x54, 0xcd, 0xe3, 0x78, 0xc9, 0x8a, 0x3c, 0xa3, 0xfc, 0xe7, 0x91, 0xab,
	0x12, 0x87, 0xf0, 0x2c, 0x13, 0x3b, 0x96, 0xef, 0x7d, 0x67, 0xe4, 0x8c, 0xbb, 0xb4, 0xbe, 0x91,
	0x04, 0xf0, 0x12, 0x56, 0x07, 0xb1, 0x57, 0x1c, 0x43, 0xe8, 0x1c, 0xa4, 0xf8, 0x51, 0xf0, 0x9d,
	0xc1, 0x1f, 0xa3, 0x7e, 0x68, 0x12, 0x2c, 0x6c, 0x30, 0xe1, 0x25, 0xcb, 0x0b, 0x45, 0x4f, 0x10,
	0x99, 0xc0, 0xeb, 0x54, 0x7d, 0x63, 0x6b, 0x9e, 0x98, 0x5f, 0xef, 0x25, 0x7d, 0x0f, 0xcf, 0x53,
	0x65, 0x51, 0xfd, 0x48, 0x73, 0xb9, 0x79, 0x6e, 0xb8, 0x07, 0x5a, 0xdf, 0xc8, 0x6f, 0x07, 0xfc,
	0x05, 0x97, 0x6b, 0x21, 0x77, 0xa6, 0x3e, 0x56, 0xe6, 0xe2, 0xde, 0xe7, 0x38, 0x81, 0xee, 0x6a,
	0xcb, 0x8a, 0x82, 0xef, 0x37, 0xdc, 0x77, 0x4d, 0xf5, 0xaf, 0x6c, 0xf5, 0xf3, 0x53, 0x98, 0x36,
	0x04, 0xbe, 0x83, 0x36, 0x3b, 0x96, 0xdb, 0x5f, 0xbe, 0x67, 0xd0, 0x17, 0x61, 0xc5, 0xc2, 0x58,
	0x07, 0xbe, 0xf2, 0x92, 0x51, 0xab, 0x91, 0x8f, 0xd0, 0x3d, 0xc7, 0xf0, 0x25, 0xb8, 0x79, 0x56,
	0x27, 0x75, 0xf3, 0x0c, 0xfb, 0xd0, 0x96, 0x7c, 0x93, 0x26, 0x26, 0x99, 0x47, 0xed, 0x85, 0x54,
	0xf0, 0x74, 0x59, 0xb3, 0x3a, 0x16, 0x25, 0xce, 0xa0, 0x23, 0xf9, 0x4a, 0xc8, 0x4c, 0xf9, 0xce,
	0xc8, 0x1b, 0x3f, 0x46, 0x43, 0x5b, 0xd8, 0x25, 0xa8, 0x65, 0x7a, 0xc2, 0x70, 0x06, 0x0f, 0xf5,
	0x8c, 0x55, 0xdd, 0xcb, 0x6d, 0x27, 0xce, 0x54, 0xf4, 0xc7, 0x01, 0x77, 0x19, 0xe3, 0x27, 0x3d,
	0xe2, 0xc6, 0x11, 0x7c, 0xa3, 0xfb, 0xba, 0xe1, 0x51, 0xf0, 0x64, 0x85, 0xc6, 0x0d, 0xd2, 0xc2,
	0x14, 0x7a, 0xff, 0x8c, 0x1d, 0xdf, 0x6a, 0xf0, 0x7f, 0x6e, 0x04, 0x7d, 0xad, 0x5e, 0x37, 0x4c,
	0x5a, 0x51, 0x02, 0xde, 0x3c, 0x8e, 0xf1, 0x33, 0x40, 0xb3, 0x66, 0x38, 0xb0, 0x39, 0xaf, 0x76,
	0x34, 0x18, 0x5e, 0x87, 0xed, 0x36, 0x92, 0xd6, 0x97, 0xce, 0xf7, 0xb6, 0xd9, 0xed, 0xbf, 0x01,
	0x00, 0x00, 0xff, 0xff, 0x5e, 0x1b, 0xcd, 0xab, 0x0a, 0x03, 0x00, 0x00,
}