func (*SourceSpan) Descriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{3}
}
Deprecated: Use SourceSpan.ProtoReflect.Descriptor instead.
package embeddedsass
import (
	reflect "reflect"
	sync "sync"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)
const (
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type InboundMessage_Syntax int32
const (
	InboundMessage_SCSS InboundMessage_Syntax = 0
	InboundMessage_INDENTED InboundMessage_Syntax = 1
	InboundMessage_CSS InboundMessage_Syntax = 2
)
var (
	InboundMessage_Syntax_name = map[int32]string{
		0: "SCSS",
		1: "INDENTED",
		2: "CSS",
	}
	InboundMessage_Syntax_value = map[string]int32{
		"SCSS":     0,
		"INDENTED": 1,
		"CSS":      2,
	}
)
func (x InboundMessage_Syntax) Enum() *InboundMessage_Syntax {
	p := new(InboundMessage_Syntax)
	*p = x
	return p
}
func (x InboundMessage_Syntax) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (InboundMessage_Syntax) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[0].Descriptor()
}
func (InboundMessage_Syntax) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[0]
}
func (x InboundMessage_Syntax) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (InboundMessage_Syntax) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{0, 0}
}
type InboundMessage_CompileRequest_OutputStyle int32
const (
	InboundMessage_CompileRequest_EXPANDED InboundMessage_CompileRequest_OutputStyle = 0
	InboundMessage_CompileRequest_COMPRESSED InboundMessage_CompileRequest_OutputStyle = 1
	InboundMessage_CompileRequest_NESTED InboundMessage_CompileRequest_OutputStyle = 2
	InboundMessage_CompileRequest_COMPACT InboundMessage_CompileRequest_OutputStyle = 3
)
var (
	InboundMessage_CompileRequest_OutputStyle_name = map[int32]string{
		0: "EXPANDED",
		1: "COMPRESSED",
		2: "NESTED",
		3: "COMPACT",
	}
	InboundMessage_CompileRequest_OutputStyle_value = map[string]int32{
		"EXPANDED":   0,
		"COMPRESSED": 1,
		"NESTED":     2,
		"COMPACT":    3,
	}
)
func (x InboundMessage_CompileRequest_OutputStyle) Enum() *InboundMessage_CompileRequest_OutputStyle {
	p := new(InboundMessage_CompileRequest_OutputStyle)
	*p = x
	return p
}
func (x InboundMessage_CompileRequest_OutputStyle) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (InboundMessage_CompileRequest_OutputStyle) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[1].Descriptor()
}
func (InboundMessage_CompileRequest_OutputStyle) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[1]
}
func (x InboundMessage_CompileRequest_OutputStyle) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (InboundMessage_CompileRequest_OutputStyle) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{0, 1, 0}
}
type OutboundMessage_LogEvent_Type int32
const (
	OutboundMessage_LogEvent_WARNING OutboundMessage_LogEvent_Type = 0
	OutboundMessage_LogEvent_DEPRECATION_WARNING OutboundMessage_LogEvent_Type = 1
	OutboundMessage_LogEvent_DEBUG OutboundMessage_LogEvent_Type = 2
)
var (
	OutboundMessage_LogEvent_Type_name = map[int32]string{
		0: "WARNING",
		1: "DEPRECATION_WARNING",
		2: "DEBUG",
	}
	OutboundMessage_LogEvent_Type_value = map[string]int32{
		"WARNING":             0,
		"DEPRECATION_WARNING": 1,
		"DEBUG":               2,
	}
)
func (x OutboundMessage_LogEvent_Type) Enum() *OutboundMessage_LogEvent_Type {
	p := new(OutboundMessage_LogEvent_Type)
	*p = x
	return p
}
func (x OutboundMessage_LogEvent_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (OutboundMessage_LogEvent_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[2].Descriptor()
}
func (OutboundMessage_LogEvent_Type) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[2]
}
func (x OutboundMessage_LogEvent_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (OutboundMessage_LogEvent_Type) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{1, 2, 0}
}
type ProtocolError_ErrorType int32
const (
	ProtocolError_PARSE ProtocolError_ErrorType = 0
	ProtocolError_PARAMS ProtocolError_ErrorType = 1
	ProtocolError_INTERNAL ProtocolError_ErrorType = 2
)
var (
	ProtocolError_ErrorType_name = map[int32]string{
		0: "PARSE",
		1: "PARAMS",
		2: "INTERNAL",
	}
	ProtocolError_ErrorType_value = map[string]int32{
		"PARSE":    0,
		"PARAMS":   1,
		"INTERNAL": 2,
	}
)
func (x ProtocolError_ErrorType) Enum() *ProtocolError_ErrorType {
	p := new(ProtocolError_ErrorType)
	*p = x
	return p
}
func (x ProtocolError_ErrorType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ProtocolError_ErrorType) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[3].Descriptor()
}
func (ProtocolError_ErrorType) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[3]
}
func (x ProtocolError_ErrorType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (ProtocolError_ErrorType) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{2, 0}
}
type Value_Singleton int32
const (
	Value_TRUE Value_Singleton = 0
	Value_FALSE Value_Singleton = 1
	Value_NULL Value_Singleton = 2
)
var (
	Value_Singleton_name = map[int32]string{
		0: "TRUE",
		1: "FALSE",
		2: "NULL",
	}
	Value_Singleton_value = map[string]int32{
		"TRUE":  0,
		"FALSE": 1,
		"NULL":  2,
	}
)
func (x Value_Singleton) Enum() *Value_Singleton {
	p := new(Value_Singleton)
	*p = x
	return p
}
func (x Value_Singleton) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Value_Singleton) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[4].Descriptor()
}
func (Value_Singleton) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[4]
}
func (x Value_Singleton) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (Value_Singleton) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{4, 0}
}
type Value_List_Separator int32
const (
	Value_List_COMMA Value_List_Separator = 0
	Value_List_SPACE Value_List_Separator = 1
	Value_List_SLASH Value_List_Separator = 2
	Value_List_UNDECIDED Value_List_Separator = 3
)
var (
	Value_List_Separator_name = map[int32]string{
		0: "COMMA",
		1: "SPACE",
		2: "SLASH",
		3: "UNDECIDED",
	}
	Value_List_Separator_value = map[string]int32{
		"COMMA":     0,
		"SPACE":     1,
		"SLASH":     2,
		"UNDECIDED": 3,
	}
)
func (x Value_List_Separator) Enum() *Value_List_Separator {
	p := new(Value_List_Separator)
	*p = x
	return p
}
func (x Value_List_Separator) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Value_List_Separator) Descriptor() protoreflect.EnumDescriptor {
	return file_embedded_sass_proto_enumTypes[5].Descriptor()
}
func (Value_List_Separator) Type() protoreflect.EnumType {
	return &file_embedded_sass_proto_enumTypes[5]
}
func (x Value_List_Separator) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (Value_List_Separator) EnumDescriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{4, 4, 0}
}
type InboundMessage struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Message isInboundMessage_Message `protobuf_oneof:"message"`
}
func (x *InboundMessage) Reset() {
	*x = InboundMessage{}
	if protoimpl.UnsafeEnabled {
		mi := &file_embedded_sass_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *InboundMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*InboundMessage) ProtoMessage() {}
func (x *InboundMessage) ProtoReflect() protoreflect.Message {
	mi := &file_embedded_sass_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*InboundMessage) Descriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{0}
}
func (m *InboundMessage) GetMessage() isInboundMessage_Message {
	if m != nil {
		return m.Message
	}
	return nil
}
func (x *InboundMessage) GetCompileRequest() *InboundMessage_CompileRequest {
	if x, ok := x.GetMessage().(*InboundMessage_CompileRequest_); ok {
		return x.CompileRequest
	}
	return nil
}
func (x *InboundMessage) GetCanonicalizeResponse() *InboundMessage_CanonicalizeResponse {
	if x, ok := x.GetMessage().(*InboundMessage_CanonicalizeResponse_); ok {
		return x.CanonicalizeResponse
	}
	return nil
}
func (x *InboundMessage) GetImportResponse() *InboundMessage_ImportResponse {
	if x, ok := x.GetMessage().(*InboundMessage_ImportResponse_); ok {
		return x.ImportResponse
	}
	return nil
}
func (x *InboundMessage) GetFileImportResponse() *InboundMessage_FileImportResponse {
	if x, ok := x.GetMessage().(*InboundMessage_FileImportResponse_); ok {
		return x.FileImportResponse
	}
	return nil
}
func (x *InboundMessage) GetFunctionCallResponse() *InboundMessage_FunctionCallResponse {
	if x, ok := x.GetMessage().(*InboundMessage_FunctionCallResponse_); ok {
		return x.FunctionCallResponse
	}
	return nil
}
func (x *InboundMessage) GetVersionRequest() *InboundMessage_VersionRequest {
	if x, ok := x.GetMessage().(*InboundMessage_VersionRequest_); ok {
		return x.VersionRequest
	}
	return nil
}
type isInboundMessage_Message interface {
	isInboundMessage_Message()
}
type InboundMessage_CompileRequest_ struct {
	CompileRequest *InboundMessage_CompileRequest `protobuf:"bytes,2,opt,name=compileRequest,proto3,oneof"`
}
type InboundMessage_CanonicalizeResponse_ struct {
	CanonicalizeResponse *InboundMessage_CanonicalizeResponse `protobuf:"bytes,3,opt,name=canonicalizeResponse,proto3,oneof"`
}
type InboundMessage_ImportResponse_ struct {
	ImportResponse *InboundMessage_ImportResponse `protobuf:"bytes,4,opt,name=importResponse,proto3,oneof"`
}
type InboundMessage_FileImportResponse_ struct {
	FileImportResponse *InboundMessage_FileImportResponse `protobuf:"bytes,5,opt,name=fileImportResponse,proto3,oneof"`
}
type InboundMessage_FunctionCallResponse_ struct {
	FunctionCallResponse *InboundMessage_FunctionCallResponse `protobuf:"bytes,6,opt,name=functionCallResponse,proto3,oneof"`
}
type InboundMessage_VersionRequest_ struct {
	VersionRequest *InboundMessage_VersionRequest `protobuf:"bytes,7,opt,name=versionRequest,proto3,oneof"`
}
func (*InboundMessage_CompileRequest_) isInboundMessage_Message() {}
func (*InboundMessage_CanonicalizeResponse_) isInboundMessage_Message() {}
func (*InboundMessage_ImportResponse_) isInboundMessage_Message() {}
func (*InboundMessage_FileImportResponse_) isInboundMessage_Message() {}
func (*InboundMessage_FunctionCallResponse_) isInboundMessage_Message() {}
func (*InboundMessage_VersionRequest_) isInboundMessage_Message() {}
type OutboundMessage struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Message isOutboundMessage_Message `protobuf_oneof:"message"`
}
func (x *OutboundMessage) Reset() {
	*x = OutboundMessage{}
	if protoimpl.UnsafeEnabled {
		mi := &file_embedded_sass_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *OutboundMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*OutboundMessage) ProtoMessage() {}
func (x *OutboundMessage) ProtoReflect() protoreflect.Message {
	mi := &file_embedded_sass_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*OutboundMessage) Descriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{1}
}
func (m *OutboundMessage) GetMessage() isOutboundMessage_Message {
	if m != nil {
		return m.Message
	}
	return nil
}
func (x *OutboundMessage) GetError() *ProtocolError {
	if x, ok := x.GetMessage().(*OutboundMessage_Error); ok {
		return x.Error
	}
	return nil
}
func (x *OutboundMessage) GetCompileResponse() *OutboundMessage_CompileResponse {
	if x, ok := x.GetMessage().(*OutboundMessage_CompileResponse_); ok {
		return x.CompileResponse
	}
	return nil
}
func (x *OutboundMessage) GetLogEvent() *OutboundMessage_LogEvent {
	if x, ok := x.GetMessage().(*OutboundMessage_LogEvent_); ok {
		return x.LogEvent
	}
	return nil
}
func (x *OutboundMessage) GetCanonicalizeRequest() *OutboundMessage_CanonicalizeRequest {
	if x, ok := x.GetMessage().(*OutboundMessage_CanonicalizeRequest_); ok {
		return x.CanonicalizeRequest
	}
	return nil
}
func (x *OutboundMessage) GetImportRequest() *OutboundMessage_ImportRequest {
	if x, ok := x.GetMessage().(*OutboundMessage_ImportRequest_); ok {
		return x.ImportRequest
	}
	return nil
}
func (x *OutboundMessage) GetFileImportRequest() *OutboundMessage_FileImportRequest {
	if x, ok := x.GetMessage().(*OutboundMessage_FileImportRequest_); ok {
		return x.FileImportRequest
	}
	return nil
}
func (x *OutboundMessage) GetFunctionCallRequest() *OutboundMessage_FunctionCallRequest {
	if x, ok := x.GetMessage().(*OutboundMessage_FunctionCallRequest_); ok {
		return x.FunctionCallRequest
	}
	return nil
}
func (x *OutboundMessage) GetVersionResponse() *OutboundMessage_VersionResponse {
	if x, ok := x.GetMessage().(*OutboundMessage_VersionResponse_); ok {
		return x.VersionResponse
	}
	return nil
}
type isOutboundMessage_Message interface {
	isOutboundMessage_Message()
}
type OutboundMessage_Error struct {
	Error *ProtocolError `protobuf:"bytes,1,opt,name=error,proto3,oneof"`
}
type OutboundMessage_CompileResponse_ struct {
	CompileResponse *OutboundMessage_CompileResponse `protobuf:"bytes,2,opt,name=compileResponse,proto3,oneof"`
}
type OutboundMessage_LogEvent_ struct {
	LogEvent *OutboundMessage_LogEvent `protobuf:"bytes,3,opt,name=logEvent,proto3,oneof"`
}
type OutboundMessage_CanonicalizeRequest_ struct {
	CanonicalizeRequest *OutboundMessage_CanonicalizeRequest `protobuf:"bytes,4,opt,name=canonicalizeRequest,proto3,oneof"`
}
type OutboundMessage_ImportRequest_ struct {
	ImportRequest *OutboundMessage_ImportRequest `protobuf:"bytes,5,opt,name=importRequest,proto3,oneof"`
}
type OutboundMessage_FileImportRequest_ struct {
	FileImportRequest *OutboundMessage_FileImportRequest `protobuf:"bytes,6,opt,name=fileImportRequest,proto3,oneof"`
}
type OutboundMessage_FunctionCallRequest_ struct {
	FunctionCallRequest *OutboundMessage_FunctionCallRequest `protobuf:"bytes,7,opt,name=functionCallRequest,proto3,oneof"`
}
type OutboundMessage_VersionResponse_ struct {
	VersionResponse *OutboundMessage_VersionResponse `protobuf:"bytes,8,opt,name=versionResponse,proto3,oneof"`
}
func (*OutboundMessage_Error) isOutboundMessage_Message() {}
func (*OutboundMessage_CompileResponse_) isOutboundMessage_Message() {}
func (*OutboundMessage_LogEvent_) isOutboundMessage_Message() {}
func (*OutboundMessage_CanonicalizeRequest_) isOutboundMessage_Message() {}
func (*OutboundMessage_ImportRequest_) isOutboundMessage_Message() {}
func (*OutboundMessage_FileImportRequest_) isOutboundMessage_Message() {}
func (*OutboundMessage_FunctionCallRequest_) isOutboundMessage_Message() {}
func (*OutboundMessage_VersionResponse_) isOutboundMessage_Message() {}
type ProtocolError struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Type ProtocolError_ErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=sass.embedded_protocol.ProtocolError_ErrorType" json:"type,omitempty"`
	Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *ProtocolError) Reset() {
	*x = ProtocolError{}
	if protoimpl.UnsafeEnabled {
		mi := &file_embedded_sass_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *ProtocolError) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*ProtocolError) ProtoMessage() {}
func (x *ProtocolError) ProtoReflect() protoreflect.Message {
	mi := &file_embedded_sass_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*ProtocolError) Descriptor() ([]byte, []int) {
	return file_embedded_sass_proto_rawDescGZIP(), []int{2}
}
func (x *ProtocolError) GetType() ProtocolError_ErrorType {
	if x != nil {
		return x.Type
	}
	return ProtocolError_PARSE
}
func (x *ProtocolError) GetId() uint32 {
	if x != nil {
		return x.Id
	}
	return 0
}
func (x *ProtocolError) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}
type SourceSpan struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	Start *SourceSpan_SourceLocation `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"`
	End *SourceSpan_SourceLocation `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"`
	Url string `protobuf:"bytes,4,opt,name=url,proto3" json:"url,omitempty"`
	Context string `protobuf:"bytes,5,opt,name=context,proto3" json:"context,omitempty"`
}
func (x *SourceSpan) Reset() {
	*x = SourceSpan{}
	if protoimpl.UnsafeEnabled {
		mi := &file_embedded_sass_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *SourceSpan) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*SourceSpan) ProtoMessage() {}
func (x *SourceSpan) ProtoReflect() protoreflect.Message {
	mi := &file_embedded_sass_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}