// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto

package taskqueue

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import datastore "google.golang.org/appengine/internal/datastore"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.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 _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type TaskQueueServiceError_ErrorCode int32

const (
	TaskQueueServiceError_OK                              TaskQueueServiceError_ErrorCode = 0
	TaskQueueServiceError_UNKNOWN_QUEUE                   TaskQueueServiceError_ErrorCode = 1
	TaskQueueServiceError_TRANSIENT_ERROR                 TaskQueueServiceError_ErrorCode = 2
	TaskQueueServiceError_INTERNAL_ERROR                  TaskQueueServiceError_ErrorCode = 3
	TaskQueueServiceError_TASK_TOO_LARGE                  TaskQueueServiceError_ErrorCode = 4
	TaskQueueServiceError_INVALID_TASK_NAME               TaskQueueServiceError_ErrorCode = 5
	TaskQueueServiceError_INVALID_QUEUE_NAME              TaskQueueServiceError_ErrorCode = 6
	TaskQueueServiceError_INVALID_URL                     TaskQueueServiceError_ErrorCode = 7
	TaskQueueServiceError_INVALID_QUEUE_RATE              TaskQueueServiceError_ErrorCode = 8
	TaskQueueServiceError_PERMISSION_DENIED               TaskQueueServiceError_ErrorCode = 9
	TaskQueueServiceError_TASK_ALREADY_EXISTS             TaskQueueServiceError_ErrorCode = 10
	TaskQueueServiceError_TOMBSTONED_TASK                 TaskQueueServiceError_ErrorCode = 11
	TaskQueueServiceError_INVALID_ETA                     TaskQueueServiceError_ErrorCode = 12
	TaskQueueServiceError_INVALID_REQUEST                 TaskQueueServiceError_ErrorCode = 13
	TaskQueueServiceError_UNKNOWN_TASK                    TaskQueueServiceError_ErrorCode = 14
	TaskQueueServiceError_TOMBSTONED_QUEUE                TaskQueueServiceError_ErrorCode = 15
	TaskQueueServiceError_DUPLICATE_TASK_NAME             TaskQueueServiceError_ErrorCode = 16
	TaskQueueServiceError_SKIPPED                         TaskQueueServiceError_ErrorCode = 17
	TaskQueueServiceError_TOO_MANY_TASKS                  TaskQueueServiceError_ErrorCode = 18
	TaskQueueServiceError_INVALID_PAYLOAD                 TaskQueueServiceError_ErrorCode = 19
	TaskQueueServiceError_INVALID_RETRY_PARAMETERS        TaskQueueServiceError_ErrorCode = 20
	TaskQueueServiceError_INVALID_QUEUE_MODE              TaskQueueServiceError_ErrorCode = 21
	TaskQueueServiceError_ACL_LOOKUP_ERROR                TaskQueueServiceError_ErrorCode = 22
	TaskQueueServiceError_TRANSACTIONAL_REQUEST_TOO_LARGE TaskQueueServiceError_ErrorCode = 23
	TaskQueueServiceError_INCORRECT_CREATOR_NAME          TaskQueueServiceError_ErrorCode = 24
	TaskQueueServiceError_TASK_LEASE_EXPIRED              TaskQueueServiceError_ErrorCode = 25
	TaskQueueServiceError_QUEUE_PAUSED                    TaskQueueServiceError_ErrorCode = 26
	TaskQueueServiceError_INVALID_TAG                     TaskQueueServiceError_ErrorCode = 27
	// Reserved range for the Datastore error codes.
	// Original Datastore error code is shifted by DATASTORE_ERROR offset.
	TaskQueueServiceError_DATASTORE_ERROR TaskQueueServiceError_ErrorCode = 10000
)

var TaskQueueServiceError_ErrorCode_name = map[int32]string{
	0:     "OK",
	1:     "UNKNOWN_QUEUE",
	2:     "TRANSIENT_ERROR",
	3:     "INTERNAL_ERROR",
	4:     "TASK_TOO_LARGE",
	5:     "INVALID_TASK_NAME",
	6:     "INVALID_QUEUE_NAME",
	7:     "INVALID_URL",
	8:     "INVALID_QUEUE_RATE",
	9:     "PERMISSION_DENIED",
	10:    "TASK_ALREADY_EXISTS",
	11:    "TOMBSTONED_TASK",
	12:    "INVALID_ETA",
	13:    "INVALID_REQUEST",
	14:    "UNKNOWN_TASK",
	15:    "TOMBSTONED_QUEUE",
	16:    "DUPLICATE_TASK_NAME",
	17:    "SKIPPED",
	18:    "TOO_MANY_TASKS",
	19:    "INVALID_PAYLOAD",
	20:    "INVALID_RETRY_PARAMETERS",
	21:    "INVALID_QUEUE_MODE",
	22:    "ACL_LOOKUP_ERROR",
	23:    "TRANSACTIONAL_REQUEST_TOO_LARGE",
	24:    "INCORRECT_CREATOR_NAME",
	25:    "TASK_LEASE_EXPIRED",
	26:    "QUEUE_PAUSED",
	27:    "INVALID_TAG",
	10000: "DATASTORE_ERROR",
}
var TaskQueueServiceError_ErrorCode_value = map[string]int32{
	"OK":                              0,
	"UNKNOWN_QUEUE":                   1,
	"TRANSIENT_ERROR":                 2,
	"INTERNAL_ERROR":                  3,
	"TASK_TOO_LARGE":                  4,
	"INVALID_TASK_NAME":               5,
	"INVALID_QUEUE_NAME":              6,
	"INVALID_URL":                     7,
	"INVALID_QUEUE_RATE":              8,
	"PERMISSION_DENIED":               9,
	"TASK_ALREADY_EXISTS":             10,
	"TOMBSTONED_TASK":                 11,
	"INVALID_ETA":                     12,
	"INVALID_REQUEST":                 13,
	"UNKNOWN_TASK":                    14,
	"TOMBSTONED_QUEUE":                15,
	"DUPLICATE_TASK_NAME":             16,
	"SKIPPED":                         17,
	"TOO_MANY_TASKS":                  18,
	"INVALID_PAYLOAD":                 19,
	"INVALID_RETRY_PARAMETERS":        20,
	"INVALID_QUEUE_MODE":              21,
	"ACL_LOOKUP_ERROR":                22,
	"TRANSACTIONAL_REQUEST_TOO_LARGE": 23,
	"INCORRECT_CREATOR_NAME":          24,
	"TASK_LEASE_EXPIRED":              25,
	"QUEUE_PAUSED":                    26,
	"INVALID_TAG":                     27,
	"DATASTORE_ERROR":                 10000,
}

func (x TaskQueueServiceError_ErrorCode) Enum() *TaskQueueServiceError_ErrorCode {
	p := new(TaskQueueServiceError_ErrorCode)
	*p = x
	return p
}
func (x TaskQueueServiceError_ErrorCode) String() string {
	return proto.EnumName(TaskQueueServiceError_ErrorCode_name, int32(x))
}
func (x *TaskQueueServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueServiceError_ErrorCode_value, data, "TaskQueueServiceError_ErrorCode")
	if err != nil {
		return err
	}
	*x = TaskQueueServiceError_ErrorCode(value)
	return nil
}
func (TaskQueueServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{0, 0}
}

type TaskQueueMode_Mode int32

const (
	TaskQueueMode_PUSH TaskQueueMode_Mode = 0
	TaskQueueMode_PULL TaskQueueMode_Mode = 1
)

var TaskQueueMode_Mode_name = map[int32]string{
	0: "PUSH",
	1: "PULL",
}
var TaskQueueMode_Mode_value = map[string]int32{
	"PUSH": 0,
	"PULL": 1,
}

func (x TaskQueueMode_Mode) Enum() *TaskQueueMode_Mode {
	p := new(TaskQueueMode_Mode)
	*p = x
	return p
}
func (x TaskQueueMode_Mode) String() string {
	return proto.EnumName(TaskQueueMode_Mode_name, int32(x))
}
func (x *TaskQueueMode_Mode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueMode_Mode_value, data, "TaskQueueMode_Mode")
	if err != nil {
		return err
	}
	*x = TaskQueueMode_Mode(value)
	return nil
}
func (TaskQueueMode_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{5, 0}
}

type TaskQueueAddRequest_RequestMethod int32

const (
	TaskQueueAddRequest_GET    TaskQueueAddRequest_RequestMethod = 1
	TaskQueueAddRequest_POST   TaskQueueAddRequest_RequestMethod = 2
	TaskQueueAddRequest_HEAD   TaskQueueAddRequest_RequestMethod = 3
	TaskQueueAddRequest_PUT    TaskQueueAddRequest_RequestMethod = 4
	TaskQueueAddRequest_DELETE TaskQueueAddRequest_RequestMethod = 5
)

var TaskQueueAddRequest_RequestMethod_name = map[int32]string{
	1: "GET",
	2: "POST",
	3: "HEAD",
	4: "PUT",
	5: "DELETE",
}
var TaskQueueAddRequest_RequestMethod_value = map[string]int32{
	"GET":    1,
	"POST":   2,
	"HEAD":   3,
	"PUT":    4,
	"DELETE": 5,
}

func (x TaskQueueAddRequest_RequestMethod) Enum() *TaskQueueAddRequest_RequestMethod {
	p := new(TaskQueueAddRequest_RequestMethod)
	*p = x
	return p
}
func (x TaskQueueAddRequest_RequestMethod) String() string {
	return proto.EnumName(TaskQueueAddRequest_RequestMethod_name, int32(x))
}
func (x *TaskQueueAddRequest_RequestMethod) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueAddRequest_RequestMethod_value, data, "TaskQueueAddRequest_RequestMethod")
	if err != nil {
		return err
	}
	*x = TaskQueueAddRequest_RequestMethod(value)
	return nil
}
func (TaskQueueAddRequest_RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{6, 0}
}

type TaskQueueQueryTasksResponse_Task_RequestMethod int32

const (
	TaskQueueQueryTasksResponse_Task_GET    TaskQueueQueryTasksResponse_Task_RequestMethod = 1
	TaskQueueQueryTasksResponse_Task_POST   TaskQueueQueryTasksResponse_Task_RequestMethod = 2
	TaskQueueQueryTasksResponse_Task_HEAD   TaskQueueQueryTasksResponse_Task_RequestMethod = 3
	TaskQueueQueryTasksResponse_Task_PUT    TaskQueueQueryTasksResponse_Task_RequestMethod = 4
	TaskQueueQueryTasksResponse_Task_DELETE TaskQueueQueryTasksResponse_Task_RequestMethod = 5
)

var TaskQueueQueryTasksResponse_Task_RequestMethod_name = map[int32]string{
	1: "GET",
	2: "POST",
	3: "HEAD",
	4: "PUT",
	5: "DELETE",
}
var TaskQueueQueryTasksResponse_Task_RequestMethod_value = map[string]int32{
	"GET":    1,
	"POST":   2,
	"HEAD":   3,
	"PUT":    4,
	"DELETE": 5,
}

func (x TaskQueueQueryTasksResponse_Task_RequestMethod) Enum() *TaskQueueQueryTasksResponse_Task_RequestMethod {
	p := new(TaskQueueQueryTasksResponse_Task_RequestMethod)
	*p = x
	return p
}
func (x TaskQueueQueryTasksResponse_Task_RequestMethod) String() string {
	return proto.EnumName(TaskQueueQueryTasksResponse_Task_RequestMethod_name, int32(x))
}
func (x *TaskQueueQueryTasksResponse_Task_RequestMethod) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueQueryTasksResponse_Task_RequestMethod_value, data, "TaskQueueQueryTasksResponse_Task_RequestMethod")
	if err != nil {
		return err
	}
	*x = TaskQueueQueryTasksResponse_Task_RequestMethod(value)
	return nil
}
func (TaskQueueQueryTasksResponse_Task_RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30, 0, 0}
}

type TaskQueueServiceError struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueServiceError) Reset()         { *m = TaskQueueServiceError{} }
func (m *TaskQueueServiceError) String() string { return proto.CompactTextString(m) }
func (*TaskQueueServiceError) ProtoMessage()    {}
func (*TaskQueueServiceError) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{0}
}
func (m *TaskQueueServiceError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueServiceError.Unmarshal(m, b)
}
func (m *TaskQueueServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueServiceError.Marshal(b, m, deterministic)
}
func (dst *TaskQueueServiceError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueServiceError.Merge(dst, src)
}
func (m *TaskQueueServiceError) XXX_Size() int {
	return xxx_messageInfo_TaskQueueServiceError.Size(m)
}
func (m *TaskQueueServiceError) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueServiceError.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueServiceError proto.InternalMessageInfo

type TaskPayload struct {
	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
	proto.XXX_InternalExtensions `protobuf_messageset:"1" json:"-"`
	XXX_unrecognized             []byte `json:"-"`
	XXX_sizecache                int32  `json:"-"`
}

func (m *TaskPayload) Reset()         { *m = TaskPayload{} }
func (m *TaskPayload) String() string { return proto.CompactTextString(m) }
func (*TaskPayload) ProtoMessage()    {}
func (*TaskPayload) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{1}
}

func (m *TaskPayload) MarshalJSON() ([]byte, error) {
	return proto.MarshalMessageSetJSON(&m.XXX_InternalExtensions)
}
func (m *TaskPayload) UnmarshalJSON(buf []byte) error {
	return proto.UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)
}

var extRange_TaskPayload = []proto.ExtensionRange{
	{Start: 10, End: 2147483646},
}

func (*TaskPayload) ExtensionRangeArray() []proto.ExtensionRange {
	return extRange_TaskPayload
}
func (m *TaskPayload) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskPayload.Unmarshal(m, b)
}
func (m *TaskPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskPayload.Marshal(b, m, deterministic)
}
func (dst *TaskPayload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskPayload.Merge(dst, src)
}
func (m *TaskPayload) XXX_Size() int {
	return xxx_messageInfo_TaskPayload.Size(m)
}
func (m *TaskPayload) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskPayload.DiscardUnknown(m)
}

var xxx_messageInfo_TaskPayload proto.InternalMessageInfo

type TaskQueueRetryParameters struct {
	RetryLimit           *int32   `protobuf:"varint,1,opt,name=retry_limit,json=retryLimit" json:"retry_limit,omitempty"`
	AgeLimitSec          *int64   `protobuf:"varint,2,opt,name=age_limit_sec,json=ageLimitSec" json:"age_limit_sec,omitempty"`
	MinBackoffSec        *float64 `protobuf:"fixed64,3,opt,name=min_backoff_sec,json=minBackoffSec,def=0.1" json:"min_backoff_sec,omitempty"`
	MaxBackoffSec        *float64 `protobuf:"fixed64,4,opt,name=max_backoff_sec,json=maxBackoffSec,def=3600" json:"max_backoff_sec,omitempty"`
	MaxDoublings         *int32   `protobuf:"varint,5,opt,name=max_doublings,json=maxDoublings,def=16" json:"max_doublings,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueRetryParameters) Reset()         { *m = TaskQueueRetryParameters{} }
func (m *TaskQueueRetryParameters) String() string { return proto.CompactTextString(m) }
func (*TaskQueueRetryParameters) ProtoMessage()    {}
func (*TaskQueueRetryParameters) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{2}
}
func (m *TaskQueueRetryParameters) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueRetryParameters.Unmarshal(m, b)
}
func (m *TaskQueueRetryParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueRetryParameters.Marshal(b, m, deterministic)
}
func (dst *TaskQueueRetryParameters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueRetryParameters.Merge(dst, src)
}
func (m *TaskQueueRetryParameters) XXX_Size() int {
	return xxx_messageInfo_TaskQueueRetryParameters.Size(m)
}
func (m *TaskQueueRetryParameters) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueRetryParameters.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueRetryParameters proto.InternalMessageInfo

const Default_TaskQueueRetryParameters_MinBackoffSec float64 = 0.1
const Default_TaskQueueRetryParameters_MaxBackoffSec float64 = 3600
const Default_TaskQueueRetryParameters_MaxDoublings int32 = 16

func (m *TaskQueueRetryParameters) GetRetryLimit() int32 {
	if m != nil && m.RetryLimit != nil {
		return *m.RetryLimit
	}
	return 0
}

func (m *TaskQueueRetryParameters) GetAgeLimitSec() int64 {
	if m != nil && m.AgeLimitSec != nil {
		return *m.AgeLimitSec
	}
	return 0
}

func (m *TaskQueueRetryParameters) GetMinBackoffSec() float64 {
	if m != nil && m.MinBackoffSec != nil {
		return *m.MinBackoffSec
	}
	return Default_TaskQueueRetryParameters_MinBackoffSec
}

func (m *TaskQueueRetryParameters) GetMaxBackoffSec() float64 {
	if m != nil && m.MaxBackoffSec != nil {
		return *m.MaxBackoffSec
	}
	return Default_TaskQueueRetryParameters_MaxBackoffSec
}

func (m *TaskQueueRetryParameters) GetMaxDoublings() int32 {
	if m != nil && m.MaxDoublings != nil {
		return *m.MaxDoublings
	}
	return Default_TaskQueueRetryParameters_MaxDoublings
}

type TaskQueueAcl struct {
	UserEmail            [][]byte `protobuf:"bytes,1,rep,name=user_email,json=userEmail" json:"user_email,omitempty"`
	WriterEmail          [][]byte `protobuf:"bytes,2,rep,name=writer_email,json=writerEmail" json:"writer_email,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueAcl) Reset()         { *m = TaskQueueAcl{} }
func (m *TaskQueueAcl) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAcl) ProtoMessage()    {}
func (*TaskQueueAcl) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{3}
}
func (m *TaskQueueAcl) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueAcl.Unmarshal(m, b)
}
func (m *TaskQueueAcl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueAcl.Marshal(b, m, deterministic)
}
func (dst *TaskQueueAcl) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueAcl.Merge(dst, src)
}
func (m *TaskQueueAcl) XXX_Size() int {
	return xxx_messageInfo_TaskQueueAcl.Size(m)
}
func (m *TaskQueueAcl) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueAcl.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueAcl proto.InternalMessageInfo

func (m *TaskQueueAcl) GetUserEmail() [][]byte {
	if m != nil {
		return m.UserEmail
	}
	return nil
}

func (m *TaskQueueAcl) GetWriterEmail() [][]byte {
	if m != nil {
		return m.WriterEmail
	}
	return nil
}

type TaskQueueHttpHeader struct {
	Key                  []byte   `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueHttpHeader) Reset()         { *m = TaskQueueHttpHeader{} }
func (m *TaskQueueHttpHeader) String() string { return proto.CompactTextString(m) }
func (*TaskQueueHttpHeader) ProtoMessage()    {}
func (*TaskQueueHttpHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{4}
}
func (m *TaskQueueHttpHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueHttpHeader.Unmarshal(m, b)
}
func (m *TaskQueueHttpHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueHttpHeader.Marshal(b, m, deterministic)
}
func (dst *TaskQueueHttpHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueHttpHeader.Merge(dst, src)
}
func (m *TaskQueueHttpHeader) XXX_Size() int {
	return xxx_messageInfo_TaskQueueHttpHeader.Size(m)
}
func (m *TaskQueueHttpHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueHttpHeader.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueHttpHeader proto.InternalMessageInfo

func (m *TaskQueueHttpHeader) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueHttpHeader) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueMode struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueMode) Reset()         { *m = TaskQueueMode{} }
func (m *TaskQueueMode) String() string { return proto.CompactTextString(m) }
func (*TaskQueueMode) ProtoMessage()    {}
func (*TaskQueueMode) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{5}
}
func (m *TaskQueueMode) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueMode.Unmarshal(m, b)
}
func (m *TaskQueueMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueMode.Marshal(b, m, deterministic)
}
func (dst *TaskQueueMode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueMode.Merge(dst, src)
}
func (m *TaskQueueMode) XXX_Size() int {
	return xxx_messageInfo_TaskQueueMode.Size(m)
}
func (m *TaskQueueMode) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueMode.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueMode proto.InternalMessageInfo

type TaskQueueAddRequest struct {
	QueueName            []byte                             `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName             []byte                             `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec              *int64                             `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	Method               *TaskQueueAddRequest_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueAddRequest_RequestMethod,def=2" json:"method,omitempty"`
	Url                  []byte                             `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
	Header               []*TaskQueueAddRequest_Header      `protobuf:"group,6,rep,name=Header,json=header" json:"header,omitempty"`
	Body                 []byte                             `protobuf:"bytes,9,opt,name=body" json:"body,omitempty"`
	Transaction          *datastore.Transaction             `protobuf:"bytes,10,opt,name=transaction" json:"transaction,omitempty"`
	AppId                []byte                             `protobuf:"bytes,11,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	Crontimetable        *TaskQueueAddRequest_CronTimetable `protobuf:"group,12,opt,name=CronTimetable,json=crontimetable" json:"crontimetable,omitempty"`
	Description          []byte                             `protobuf:"bytes,15,opt,name=description" json:"description,omitempty"`
	Payload              *TaskPayload                       `protobuf:"bytes,16,opt,name=payload" json:"payload,omitempty"`
	RetryParameters      *TaskQueueRetryParameters          `protobuf:"bytes,17,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	Mode                 *TaskQueueMode_Mode                `protobuf:"varint,18,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Tag                  []byte                             `protobuf:"bytes,19,opt,name=tag" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *TaskQueueAddRequest) Reset()         { *m = TaskQueueAddRequest{} }
func (m *TaskQueueAddRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest) ProtoMessage()    {}
func (*TaskQueueAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{6}
}
func (m *TaskQueueAddRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueAddRequest.Unmarshal(m, b)
}
func (m *TaskQueueAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueAddRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueAddRequest.Merge(dst, src)
}
func (m *TaskQueueAddRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueAddRequest.Size(m)
}
func (m *TaskQueueAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueAddRequest proto.InternalMessageInfo

const Default_TaskQueueAddRequest_Method TaskQueueAddRequest_RequestMethod = TaskQueueAddRequest_POST
const Default_TaskQueueAddRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH

func (m *TaskQueueAddRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueAddRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueAddRequest) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueAddRequest) GetMethod() TaskQueueAddRequest_RequestMethod {
	if m != nil && m.Method != nil {
		return *m.Method
	}
	return Default_TaskQueueAddRequest_Method
}

func (m *TaskQueueAddRequest) GetUrl() []byte {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *TaskQueueAddRequest) GetHeader() []*TaskQueueAddRequest_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *TaskQueueAddRequest) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueAddRequest) GetTransaction() *datastore.Transaction {
	if m != nil {
		return m.Transaction
	}
	return nil
}

func (m *TaskQueueAddRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueAddRequest) GetCrontimetable() *TaskQueueAddRequest_CronTimetable {
	if m != nil {
		return m.Crontimetable
	}
	return nil
}

func (m *TaskQueueAddRequest) GetDescription() []byte {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *TaskQueueAddRequest) GetPayload() *TaskPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TaskQueueAddRequest) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueAddRequest) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueAddRequest_Mode
}

func (m *TaskQueueAddRequest) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueAddRequest_Header struct {
	Key                  []byte   `protobuf:"bytes,7,req,name=key" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,8,req,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueAddRequest_Header) Reset()         { *m = TaskQueueAddRequest_Header{} }
func (m *TaskQueueAddRequest_Header) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest_Header) ProtoMessage()    {}
func (*TaskQueueAddRequest_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{6, 0}
}
func (m *TaskQueueAddRequest_Header) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueAddRequest_Header.Unmarshal(m, b)
}
func (m *TaskQueueAddRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueAddRequest_Header.Marshal(b, m, deterministic)
}
func (dst *TaskQueueAddRequest_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueAddRequest_Header.Merge(dst, src)
}
func (m *TaskQueueAddRequest_Header) XXX_Size() int {
	return xxx_messageInfo_TaskQueueAddRequest_Header.Size(m)
}
func (m *TaskQueueAddRequest_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueAddRequest_Header.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueAddRequest_Header proto.InternalMessageInfo

func (m *TaskQueueAddRequest_Header) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueAddRequest_Header) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueAddRequest_CronTimetable struct {
	Schedule             []byte   `protobuf:"bytes,13,req,name=schedule" json:"schedule,omitempty"`
	Timezone             []byte   `protobuf:"bytes,14,req,name=timezone" json:"timezone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueAddRequest_CronTimetable) Reset()         { *m = TaskQueueAddRequest_CronTimetable{} }
func (m *TaskQueueAddRequest_CronTimetable) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest_CronTimetable) ProtoMessage()    {}
func (*TaskQueueAddRequest_CronTimetable) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{6, 1}
}
func (m *TaskQueueAddRequest_CronTimetable) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueAddRequest_CronTimetable.Unmarshal(m, b)
}
func (m *TaskQueueAddRequest_CronTimetable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueAddRequest_CronTimetable.Marshal(b, m, deterministic)
}
func (dst *TaskQueueAddRequest_CronTimetable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueAddRequest_CronTimetable.Merge(dst, src)
}
func (m *TaskQueueAddRequest_CronTimetable) XXX_Size() int {
	return xxx_messageInfo_TaskQueueAddRequest_CronTimetable.Size(m)
}
func (m *TaskQueueAddRequest_CronTimetable) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueAddRequest_CronTimetable.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueAddRequest_CronTimetable proto.InternalMessageInfo

func (m *TaskQueueAddRequest_CronTimetable) GetSchedule() []byte {
	if m != nil {
		return m.Schedule
	}
	return nil
}

func (m *TaskQueueAddRequest_CronTimetable) GetTimezone() []byte {
	if m != nil {
		return m.Timezone
	}
	return nil
}

type TaskQueueAddResponse struct {
	ChosenTaskName       []byte   `protobuf:"bytes,1,opt,name=chosen_task_name,json=chosenTaskName" json:"chosen_task_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueAddResponse) Reset()         { *m = TaskQueueAddResponse{} }
func (m *TaskQueueAddResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddResponse) ProtoMessage()    {}
func (*TaskQueueAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{7}
}
func (m *TaskQueueAddResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueAddResponse.Unmarshal(m, b)
}
func (m *TaskQueueAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueAddResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueAddResponse.Merge(dst, src)
}
func (m *TaskQueueAddResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueAddResponse.Size(m)
}
func (m *TaskQueueAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueAddResponse proto.InternalMessageInfo

func (m *TaskQueueAddResponse) GetChosenTaskName() []byte {
	if m != nil {
		return m.ChosenTaskName
	}
	return nil
}

type TaskQueueBulkAddRequest struct {
	AddRequest           []*TaskQueueAddRequest `protobuf:"bytes,1,rep,name=add_request,json=addRequest" json:"add_request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *TaskQueueBulkAddRequest) Reset()         { *m = TaskQueueBulkAddRequest{} }
func (m *TaskQueueBulkAddRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddRequest) ProtoMessage()    {}
func (*TaskQueueBulkAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{8}
}
func (m *TaskQueueBulkAddRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueBulkAddRequest.Unmarshal(m, b)
}
func (m *TaskQueueBulkAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueBulkAddRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueBulkAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueBulkAddRequest.Merge(dst, src)
}
func (m *TaskQueueBulkAddRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueBulkAddRequest.Size(m)
}
func (m *TaskQueueBulkAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueBulkAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueBulkAddRequest proto.InternalMessageInfo

func (m *TaskQueueBulkAddRequest) GetAddRequest() []*TaskQueueAddRequest {
	if m != nil {
		return m.AddRequest
	}
	return nil
}

type TaskQueueBulkAddResponse struct {
	Taskresult           []*TaskQueueBulkAddResponse_TaskResult `protobuf:"group,1,rep,name=TaskResult,json=taskresult" json:"taskresult,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

func (m *TaskQueueBulkAddResponse) Reset()         { *m = TaskQueueBulkAddResponse{} }
func (m *TaskQueueBulkAddResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddResponse) ProtoMessage()    {}
func (*TaskQueueBulkAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{9}
}
func (m *TaskQueueBulkAddResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueBulkAddResponse.Unmarshal(m, b)
}
func (m *TaskQueueBulkAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueBulkAddResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueBulkAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueBulkAddResponse.Merge(dst, src)
}
func (m *TaskQueueBulkAddResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueBulkAddResponse.Size(m)
}
func (m *TaskQueueBulkAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueBulkAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueBulkAddResponse proto.InternalMessageInfo

func (m *TaskQueueBulkAddResponse) GetTaskresult() []*TaskQueueBulkAddResponse_TaskResult {
	if m != nil {
		return m.Taskresult
	}
	return nil
}

type TaskQueueBulkAddResponse_TaskResult struct {
	Result               *TaskQueueServiceError_ErrorCode `protobuf:"varint,2,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	ChosenTaskName       []byte                           `protobuf:"bytes,3,opt,name=chosen_task_name,json=chosenTaskName" json:"chosen_task_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *TaskQueueBulkAddResponse_TaskResult) Reset()         { *m = TaskQueueBulkAddResponse_TaskResult{} }
func (m *TaskQueueBulkAddResponse_TaskResult) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddResponse_TaskResult) ProtoMessage()    {}
func (*TaskQueueBulkAddResponse_TaskResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{9, 0}
}
func (m *TaskQueueBulkAddResponse_TaskResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult.Unmarshal(m, b)
}
func (m *TaskQueueBulkAddResponse_TaskResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult.Marshal(b, m, deterministic)
}
func (dst *TaskQueueBulkAddResponse_TaskResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult.Merge(dst, src)
}
func (m *TaskQueueBulkAddResponse_TaskResult) XXX_Size() int {
	return xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult.Size(m)
}
func (m *TaskQueueBulkAddResponse_TaskResult) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueBulkAddResponse_TaskResult proto.InternalMessageInfo

func (m *TaskQueueBulkAddResponse_TaskResult) GetResult() TaskQueueServiceError_ErrorCode {
	if m != nil && m.Result != nil {
		return *m.Result
	}
	return TaskQueueServiceError_OK
}

func (m *TaskQueueBulkAddResponse_TaskResult) GetChosenTaskName() []byte {
	if m != nil {
		return m.ChosenTaskName
	}
	return nil
}

type TaskQueueDeleteRequest struct {
	QueueName            []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName             [][]byte `protobuf:"bytes,2,rep,name=task_name,json=taskName" json:"task_name,omitempty"`
	AppId                []byte   `protobuf:"bytes,3,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueDeleteRequest) Reset()         { *m = TaskQueueDeleteRequest{} }
func (m *TaskQueueDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteRequest) ProtoMessage()    {}
func (*TaskQueueDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{10}
}
func (m *TaskQueueDeleteRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteRequest.Unmarshal(m, b)
}
func (m *TaskQueueDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteRequest.Merge(dst, src)
}
func (m *TaskQueueDeleteRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteRequest.Size(m)
}
func (m *TaskQueueDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteRequest proto.InternalMessageInfo

func (m *TaskQueueDeleteRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueDeleteRequest) GetTaskName() [][]byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueDeleteRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

type TaskQueueDeleteResponse struct {
	Result               []TaskQueueServiceError_ErrorCode `protobuf:"varint,3,rep,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *TaskQueueDeleteResponse) Reset()         { *m = TaskQueueDeleteResponse{} }
func (m *TaskQueueDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteResponse) ProtoMessage()    {}
func (*TaskQueueDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{11}
}
func (m *TaskQueueDeleteResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteResponse.Unmarshal(m, b)
}
func (m *TaskQueueDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteResponse.Merge(dst, src)
}
func (m *TaskQueueDeleteResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteResponse.Size(m)
}
func (m *TaskQueueDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteResponse proto.InternalMessageInfo

func (m *TaskQueueDeleteResponse) GetResult() []TaskQueueServiceError_ErrorCode {
	if m != nil {
		return m.Result
	}
	return nil
}

type TaskQueueForceRunRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName             []byte   `protobuf:"bytes,3,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueForceRunRequest) Reset()         { *m = TaskQueueForceRunRequest{} }
func (m *TaskQueueForceRunRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueForceRunRequest) ProtoMessage()    {}
func (*TaskQueueForceRunRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{12}
}
func (m *TaskQueueForceRunRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueForceRunRequest.Unmarshal(m, b)
}
func (m *TaskQueueForceRunRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueForceRunRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueForceRunRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueForceRunRequest.Merge(dst, src)
}
func (m *TaskQueueForceRunRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueForceRunRequest.Size(m)
}
func (m *TaskQueueForceRunRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueForceRunRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueForceRunRequest proto.InternalMessageInfo

func (m *TaskQueueForceRunRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueForceRunRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueForceRunRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

type TaskQueueForceRunResponse struct {
	Result               *TaskQueueServiceError_ErrorCode `protobuf:"varint,3,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *TaskQueueForceRunResponse) Reset()         { *m = TaskQueueForceRunResponse{} }
func (m *TaskQueueForceRunResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueForceRunResponse) ProtoMessage()    {}
func (*TaskQueueForceRunResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{13}
}
func (m *TaskQueueForceRunResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueForceRunResponse.Unmarshal(m, b)
}
func (m *TaskQueueForceRunResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueForceRunResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueForceRunResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueForceRunResponse.Merge(dst, src)
}
func (m *TaskQueueForceRunResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueForceRunResponse.Size(m)
}
func (m *TaskQueueForceRunResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueForceRunResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueForceRunResponse proto.InternalMessageInfo

func (m *TaskQueueForceRunResponse) GetResult() TaskQueueServiceError_ErrorCode {
	if m != nil && m.Result != nil {
		return *m.Result
	}
	return TaskQueueServiceError_OK
}

type TaskQueueUpdateQueueRequest struct {
	AppId                 []byte                    `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName             []byte                    `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	BucketRefillPerSecond *float64                  `protobuf:"fixed64,3,req,name=bucket_refill_per_second,json=bucketRefillPerSecond" json:"bucket_refill_per_second,omitempty"`
	BucketCapacity        *int32                    `protobuf:"varint,4,req,name=bucket_capacity,json=bucketCapacity" json:"bucket_capacity,omitempty"`
	UserSpecifiedRate     *string                   `protobuf:"bytes,5,opt,name=user_specified_rate,json=userSpecifiedRate" json:"user_specified_rate,omitempty"`
	RetryParameters       *TaskQueueRetryParameters `protobuf:"bytes,6,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	MaxConcurrentRequests *int32                    `protobuf:"varint,7,opt,name=max_concurrent_requests,json=maxConcurrentRequests" json:"max_concurrent_requests,omitempty"`
	Mode                  *TaskQueueMode_Mode       `protobuf:"varint,8,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Acl                   *TaskQueueAcl             `protobuf:"bytes,9,opt,name=acl" json:"acl,omitempty"`
	HeaderOverride        []*TaskQueueHttpHeader    `protobuf:"bytes,10,rep,name=header_override,json=headerOverride" json:"header_override,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                  `json:"-"`
	XXX_unrecognized      []byte                    `json:"-"`
	XXX_sizecache         int32                     `json:"-"`
}

func (m *TaskQueueUpdateQueueRequest) Reset()         { *m = TaskQueueUpdateQueueRequest{} }
func (m *TaskQueueUpdateQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateQueueRequest) ProtoMessage()    {}
func (*TaskQueueUpdateQueueRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{14}
}
func (m *TaskQueueUpdateQueueRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueUpdateQueueRequest.Unmarshal(m, b)
}
func (m *TaskQueueUpdateQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueUpdateQueueRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueUpdateQueueRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueUpdateQueueRequest.Merge(dst, src)
}
func (m *TaskQueueUpdateQueueRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueUpdateQueueRequest.Size(m)
}
func (m *TaskQueueUpdateQueueRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueUpdateQueueRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueUpdateQueueRequest proto.InternalMessageInfo

const Default_TaskQueueUpdateQueueRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH

func (m *TaskQueueUpdateQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetBucketRefillPerSecond() float64 {
	if m != nil && m.BucketRefillPerSecond != nil {
		return *m.BucketRefillPerSecond
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetBucketCapacity() int32 {
	if m != nil && m.BucketCapacity != nil {
		return *m.BucketCapacity
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetUserSpecifiedRate() string {
	if m != nil && m.UserSpecifiedRate != nil {
		return *m.UserSpecifiedRate
	}
	return ""
}

func (m *TaskQueueUpdateQueueRequest) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetMaxConcurrentRequests() int32 {
	if m != nil && m.MaxConcurrentRequests != nil {
		return *m.MaxConcurrentRequests
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueUpdateQueueRequest_Mode
}

func (m *TaskQueueUpdateQueueRequest) GetAcl() *TaskQueueAcl {
	if m != nil {
		return m.Acl
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetHeaderOverride() []*TaskQueueHttpHeader {
	if m != nil {
		return m.HeaderOverride
	}
	return nil
}

type TaskQueueUpdateQueueResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueUpdateQueueResponse) Reset()         { *m = TaskQueueUpdateQueueResponse{} }
func (m *TaskQueueUpdateQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateQueueResponse) ProtoMessage()    {}
func (*TaskQueueUpdateQueueResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{15}
}
func (m *TaskQueueUpdateQueueResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueUpdateQueueResponse.Unmarshal(m, b)
}
func (m *TaskQueueUpdateQueueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueUpdateQueueResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueUpdateQueueResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueUpdateQueueResponse.Merge(dst, src)
}
func (m *TaskQueueUpdateQueueResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueUpdateQueueResponse.Size(m)
}
func (m *TaskQueueUpdateQueueResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueUpdateQueueResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueUpdateQueueResponse proto.InternalMessageInfo

type TaskQueueFetchQueuesRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	MaxRows              *int32   `protobuf:"varint,2,req,name=max_rows,json=maxRows" json:"max_rows,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueFetchQueuesRequest) Reset()         { *m = TaskQueueFetchQueuesRequest{} }
func (m *TaskQueueFetchQueuesRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesRequest) ProtoMessage()    {}
func (*TaskQueueFetchQueuesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{16}
}
func (m *TaskQueueFetchQueuesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueuesRequest.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueuesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueuesRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueuesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueuesRequest.Merge(dst, src)
}
func (m *TaskQueueFetchQueuesRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueuesRequest.Size(m)
}
func (m *TaskQueueFetchQueuesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueuesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueuesRequest proto.InternalMessageInfo

func (m *TaskQueueFetchQueuesRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchQueuesRequest) GetMaxRows() int32 {
	if m != nil && m.MaxRows != nil {
		return *m.MaxRows
	}
	return 0
}

type TaskQueueFetchQueuesResponse struct {
	Queue                []*TaskQueueFetchQueuesResponse_Queue `protobuf:"group,1,rep,name=Queue,json=queue" json:"queue,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *TaskQueueFetchQueuesResponse) Reset()         { *m = TaskQueueFetchQueuesResponse{} }
func (m *TaskQueueFetchQueuesResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesResponse) ProtoMessage()    {}
func (*TaskQueueFetchQueuesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{17}
}
func (m *TaskQueueFetchQueuesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueuesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueuesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueuesResponse.Merge(dst, src)
}
func (m *TaskQueueFetchQueuesResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse.Size(m)
}
func (m *TaskQueueFetchQueuesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueuesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueuesResponse proto.InternalMessageInfo

func (m *TaskQueueFetchQueuesResponse) GetQueue() []*TaskQueueFetchQueuesResponse_Queue {
	if m != nil {
		return m.Queue
	}
	return nil
}

type TaskQueueFetchQueuesResponse_Queue struct {
	QueueName             []byte                    `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	BucketRefillPerSecond *float64                  `protobuf:"fixed64,3,req,name=bucket_refill_per_second,json=bucketRefillPerSecond" json:"bucket_refill_per_second,omitempty"`
	BucketCapacity        *float64                  `protobuf:"fixed64,4,req,name=bucket_capacity,json=bucketCapacity" json:"bucket_capacity,omitempty"`
	UserSpecifiedRate     *string                   `protobuf:"bytes,5,opt,name=user_specified_rate,json=userSpecifiedRate" json:"user_specified_rate,omitempty"`
	Paused                *bool                     `protobuf:"varint,6,req,name=paused,def=0" json:"paused,omitempty"`
	RetryParameters       *TaskQueueRetryParameters `protobuf:"bytes,7,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	MaxConcurrentRequests *int32                    `protobuf:"varint,8,opt,name=max_concurrent_requests,json=maxConcurrentRequests" json:"max_concurrent_requests,omitempty"`
	Mode                  *TaskQueueMode_Mode       `protobuf:"varint,9,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Acl                   *TaskQueueAcl             `protobuf:"bytes,10,opt,name=acl" json:"acl,omitempty"`
	HeaderOverride        []*TaskQueueHttpHeader    `protobuf:"bytes,11,rep,name=header_override,json=headerOverride" json:"header_override,omitempty"`
	CreatorName           *string                   `protobuf:"bytes,12,opt,name=creator_name,json=creatorName,def=apphosting" json:"creator_name,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                  `json:"-"`
	XXX_unrecognized      []byte                    `json:"-"`
	XXX_sizecache         int32                     `json:"-"`
}

func (m *TaskQueueFetchQueuesResponse_Queue) Reset()         { *m = TaskQueueFetchQueuesResponse_Queue{} }
func (m *TaskQueueFetchQueuesResponse_Queue) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesResponse_Queue) ProtoMessage()    {}
func (*TaskQueueFetchQueuesResponse_Queue) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{17, 0}
}
func (m *TaskQueueFetchQueuesResponse_Queue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueuesResponse_Queue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueuesResponse_Queue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue.Merge(dst, src)
}
func (m *TaskQueueFetchQueuesResponse_Queue) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue.Size(m)
}
func (m *TaskQueueFetchQueuesResponse_Queue) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueuesResponse_Queue proto.InternalMessageInfo

const Default_TaskQueueFetchQueuesResponse_Queue_Paused bool = false
const Default_TaskQueueFetchQueuesResponse_Queue_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH
const Default_TaskQueueFetchQueuesResponse_Queue_CreatorName string = "apphosting"

func (m *TaskQueueFetchQueuesResponse_Queue) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketRefillPerSecond() float64 {
	if m != nil && m.BucketRefillPerSecond != nil {
		return *m.BucketRefillPerSecond
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketCapacity() float64 {
	if m != nil && m.BucketCapacity != nil {
		return *m.BucketCapacity
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetUserSpecifiedRate() string {
	if m != nil && m.UserSpecifiedRate != nil {
		return *m.UserSpecifiedRate
	}
	return ""
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetPaused() bool {
	if m != nil && m.Paused != nil {
		return *m.Paused
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_Paused
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetMaxConcurrentRequests() int32 {
	if m != nil && m.MaxConcurrentRequests != nil {
		return *m.MaxConcurrentRequests
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_Mode
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetAcl() *TaskQueueAcl {
	if m != nil {
		return m.Acl
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetHeaderOverride() []*TaskQueueHttpHeader {
	if m != nil {
		return m.HeaderOverride
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetCreatorName() string {
	if m != nil && m.CreatorName != nil {
		return *m.CreatorName
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_CreatorName
}

type TaskQueueFetchQueueStatsRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            [][]byte `protobuf:"bytes,2,rep,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	MaxNumTasks          *int32   `protobuf:"varint,3,opt,name=max_num_tasks,json=maxNumTasks,def=0" json:"max_num_tasks,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueFetchQueueStatsRequest) Reset()         { *m = TaskQueueFetchQueueStatsRequest{} }
func (m *TaskQueueFetchQueueStatsRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueueStatsRequest) ProtoMessage()    {}
func (*TaskQueueFetchQueueStatsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{18}
}
func (m *TaskQueueFetchQueueStatsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueueStatsRequest.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueueStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueueStatsRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueueStatsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueueStatsRequest.Merge(dst, src)
}
func (m *TaskQueueFetchQueueStatsRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueueStatsRequest.Size(m)
}
func (m *TaskQueueFetchQueueStatsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueueStatsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueueStatsRequest proto.InternalMessageInfo

const Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks int32 = 0

func (m *TaskQueueFetchQueueStatsRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchQueueStatsRequest) GetQueueName() [][]byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchQueueStatsRequest) GetMaxNumTasks() int32 {
	if m != nil && m.MaxNumTasks != nil {
		return *m.MaxNumTasks
	}
	return Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks
}

type TaskQueueScannerQueueInfo struct {
	ExecutedLastMinute      *int64   `protobuf:"varint,1,req,name=executed_last_minute,json=executedLastMinute" json:"executed_last_minute,omitempty"`
	ExecutedLastHour        *int64   `protobuf:"varint,2,req,name=executed_last_hour,json=executedLastHour" json:"executed_last_hour,omitempty"`
	SamplingDurationSeconds *float64 `protobuf:"fixed64,3,req,name=sampling_duration_seconds,json=samplingDurationSeconds" json:"sampling_duration_seconds,omitempty"`
	RequestsInFlight        *int32   `protobuf:"varint,4,opt,name=requests_in_flight,json=requestsInFlight" json:"requests_in_flight,omitempty"`
	EnforcedRate            *float64 `protobuf:"fixed64,5,opt,name=enforced_rate,json=enforcedRate" json:"enforced_rate,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_unrecognized        []byte   `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

func (m *TaskQueueScannerQueueInfo) Reset()         { *m = TaskQueueScannerQueueInfo{} }
func (m *TaskQueueScannerQueueInfo) String() string { return proto.CompactTextString(m) }
func (*TaskQueueScannerQueueInfo) ProtoMessage()    {}
func (*TaskQueueScannerQueueInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{19}
}
func (m *TaskQueueScannerQueueInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueScannerQueueInfo.Unmarshal(m, b)
}
func (m *TaskQueueScannerQueueInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueScannerQueueInfo.Marshal(b, m, deterministic)
}
func (dst *TaskQueueScannerQueueInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueScannerQueueInfo.Merge(dst, src)
}
func (m *TaskQueueScannerQueueInfo) XXX_Size() int {
	return xxx_messageInfo_TaskQueueScannerQueueInfo.Size(m)
}
func (m *TaskQueueScannerQueueInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueScannerQueueInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueScannerQueueInfo proto.InternalMessageInfo

func (m *TaskQueueScannerQueueInfo) GetExecutedLastMinute() int64 {
	if m != nil && m.ExecutedLastMinute != nil {
		return *m.ExecutedLastMinute
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetExecutedLastHour() int64 {
	if m != nil && m.ExecutedLastHour != nil {
		return *m.ExecutedLastHour
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetSamplingDurationSeconds() float64 {
	if m != nil && m.SamplingDurationSeconds != nil {
		return *m.SamplingDurationSeconds
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetRequestsInFlight() int32 {
	if m != nil && m.RequestsInFlight != nil {
		return *m.RequestsInFlight
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetEnforcedRate() float64 {
	if m != nil && m.EnforcedRate != nil {
		return *m.EnforcedRate
	}
	return 0
}

type TaskQueueFetchQueueStatsResponse struct {
	Queuestats           []*TaskQueueFetchQueueStatsResponse_QueueStats `protobuf:"group,1,rep,name=QueueStats,json=queuestats" json:"queuestats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                       `json:"-"`
	XXX_unrecognized     []byte                                         `json:"-"`
	XXX_sizecache        int32                                          `json:"-"`
}

func (m *TaskQueueFetchQueueStatsResponse) Reset()         { *m = TaskQueueFetchQueueStatsResponse{} }
func (m *TaskQueueFetchQueueStatsResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueueStatsResponse) ProtoMessage()    {}
func (*TaskQueueFetchQueueStatsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{20}
}
func (m *TaskQueueFetchQueueStatsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueueStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueueStatsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueueStatsResponse.Merge(dst, src)
}
func (m *TaskQueueFetchQueueStatsResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse.Size(m)
}
func (m *TaskQueueFetchQueueStatsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueueStatsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueueStatsResponse proto.InternalMessageInfo

func (m *TaskQueueFetchQueueStatsResponse) GetQueuestats() []*TaskQueueFetchQueueStatsResponse_QueueStats {
	if m != nil {
		return m.Queuestats
	}
	return nil
}

type TaskQueueFetchQueueStatsResponse_QueueStats struct {
	NumTasks             *int32                     `protobuf:"varint,2,req,name=num_tasks,json=numTasks" json:"num_tasks,omitempty"`
	OldestEtaUsec        *int64                     `protobuf:"varint,3,req,name=oldest_eta_usec,json=oldestEtaUsec" json:"oldest_eta_usec,omitempty"`
	ScannerInfo          *TaskQueueScannerQueueInfo `protobuf:"bytes,4,opt,name=scanner_info,json=scannerInfo" json:"scanner_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) Reset() {
	*m = TaskQueueFetchQueueStatsResponse_QueueStats{}
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) String() string {
	return proto.CompactTextString(m)
}
func (*TaskQueueFetchQueueStatsResponse_QueueStats) ProtoMessage() {}
func (*TaskQueueFetchQueueStatsResponse_QueueStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{20, 0}
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats.Unmarshal(m, b)
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchQueueStatsResponse_QueueStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats.Merge(dst, src)
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats.Size(m)
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchQueueStatsResponse_QueueStats proto.InternalMessageInfo

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetNumTasks() int32 {
	if m != nil && m.NumTasks != nil {
		return *m.NumTasks
	}
	return 0
}

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetOldestEtaUsec() int64 {
	if m != nil && m.OldestEtaUsec != nil {
		return *m.OldestEtaUsec
	}
	return 0
}

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetScannerInfo() *TaskQueueScannerQueueInfo {
	if m != nil {
		return m.ScannerInfo
	}
	return nil
}

type TaskQueuePauseQueueRequest struct {
	AppId                []byte   `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	Pause                *bool    `protobuf:"varint,3,req,name=pause" json:"pause,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueuePauseQueueRequest) Reset()         { *m = TaskQueuePauseQueueRequest{} }
func (m *TaskQueuePauseQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePauseQueueRequest) ProtoMessage()    {}
func (*TaskQueuePauseQueueRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{21}
}
func (m *TaskQueuePauseQueueRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueuePauseQueueRequest.Unmarshal(m, b)
}
func (m *TaskQueuePauseQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueuePauseQueueRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueuePauseQueueRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueuePauseQueueRequest.Merge(dst, src)
}
func (m *TaskQueuePauseQueueRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueuePauseQueueRequest.Size(m)
}
func (m *TaskQueuePauseQueueRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueuePauseQueueRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueuePauseQueueRequest proto.InternalMessageInfo

func (m *TaskQueuePauseQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueuePauseQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueuePauseQueueRequest) GetPause() bool {
	if m != nil && m.Pause != nil {
		return *m.Pause
	}
	return false
}

type TaskQueuePauseQueueResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueuePauseQueueResponse) Reset()         { *m = TaskQueuePauseQueueResponse{} }
func (m *TaskQueuePauseQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePauseQueueResponse) ProtoMessage()    {}
func (*TaskQueuePauseQueueResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{22}
}
func (m *TaskQueuePauseQueueResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueuePauseQueueResponse.Unmarshal(m, b)
}
func (m *TaskQueuePauseQueueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueuePauseQueueResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueuePauseQueueResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueuePauseQueueResponse.Merge(dst, src)
}
func (m *TaskQueuePauseQueueResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueuePauseQueueResponse.Size(m)
}
func (m *TaskQueuePauseQueueResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueuePauseQueueResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueuePauseQueueResponse proto.InternalMessageInfo

type TaskQueuePurgeQueueRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueuePurgeQueueRequest) Reset()         { *m = TaskQueuePurgeQueueRequest{} }
func (m *TaskQueuePurgeQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePurgeQueueRequest) ProtoMessage()    {}
func (*TaskQueuePurgeQueueRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{23}
}
func (m *TaskQueuePurgeQueueRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueuePurgeQueueRequest.Unmarshal(m, b)
}
func (m *TaskQueuePurgeQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueuePurgeQueueRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueuePurgeQueueRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueuePurgeQueueRequest.Merge(dst, src)
}
func (m *TaskQueuePurgeQueueRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueuePurgeQueueRequest.Size(m)
}
func (m *TaskQueuePurgeQueueRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueuePurgeQueueRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueuePurgeQueueRequest proto.InternalMessageInfo

func (m *TaskQueuePurgeQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueuePurgeQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

type TaskQueuePurgeQueueResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueuePurgeQueueResponse) Reset()         { *m = TaskQueuePurgeQueueResponse{} }
func (m *TaskQueuePurgeQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePurgeQueueResponse) ProtoMessage()    {}
func (*TaskQueuePurgeQueueResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{24}
}
func (m *TaskQueuePurgeQueueResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueuePurgeQueueResponse.Unmarshal(m, b)
}
func (m *TaskQueuePurgeQueueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueuePurgeQueueResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueuePurgeQueueResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueuePurgeQueueResponse.Merge(dst, src)
}
func (m *TaskQueuePurgeQueueResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueuePurgeQueueResponse.Size(m)
}
func (m *TaskQueuePurgeQueueResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueuePurgeQueueResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueuePurgeQueueResponse proto.InternalMessageInfo

type TaskQueueDeleteQueueRequest struct {
	AppId                []byte   `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueDeleteQueueRequest) Reset()         { *m = TaskQueueDeleteQueueRequest{} }
func (m *TaskQueueDeleteQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteQueueRequest) ProtoMessage()    {}
func (*TaskQueueDeleteQueueRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{25}
}
func (m *TaskQueueDeleteQueueRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteQueueRequest.Unmarshal(m, b)
}
func (m *TaskQueueDeleteQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteQueueRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteQueueRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteQueueRequest.Merge(dst, src)
}
func (m *TaskQueueDeleteQueueRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteQueueRequest.Size(m)
}
func (m *TaskQueueDeleteQueueRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteQueueRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteQueueRequest proto.InternalMessageInfo

func (m *TaskQueueDeleteQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueDeleteQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

type TaskQueueDeleteQueueResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueDeleteQueueResponse) Reset()         { *m = TaskQueueDeleteQueueResponse{} }
func (m *TaskQueueDeleteQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteQueueResponse) ProtoMessage()    {}
func (*TaskQueueDeleteQueueResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{26}
}
func (m *TaskQueueDeleteQueueResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteQueueResponse.Unmarshal(m, b)
}
func (m *TaskQueueDeleteQueueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteQueueResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteQueueResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteQueueResponse.Merge(dst, src)
}
func (m *TaskQueueDeleteQueueResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteQueueResponse.Size(m)
}
func (m *TaskQueueDeleteQueueResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteQueueResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteQueueResponse proto.InternalMessageInfo

type TaskQueueDeleteGroupRequest struct {
	AppId                []byte   `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueDeleteGroupRequest) Reset()         { *m = TaskQueueDeleteGroupRequest{} }
func (m *TaskQueueDeleteGroupRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteGroupRequest) ProtoMessage()    {}
func (*TaskQueueDeleteGroupRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{27}
}
func (m *TaskQueueDeleteGroupRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteGroupRequest.Unmarshal(m, b)
}
func (m *TaskQueueDeleteGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteGroupRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteGroupRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteGroupRequest.Merge(dst, src)
}
func (m *TaskQueueDeleteGroupRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteGroupRequest.Size(m)
}
func (m *TaskQueueDeleteGroupRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteGroupRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteGroupRequest proto.InternalMessageInfo

func (m *TaskQueueDeleteGroupRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

type TaskQueueDeleteGroupResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueDeleteGroupResponse) Reset()         { *m = TaskQueueDeleteGroupResponse{} }
func (m *TaskQueueDeleteGroupResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteGroupResponse) ProtoMessage()    {}
func (*TaskQueueDeleteGroupResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{28}
}
func (m *TaskQueueDeleteGroupResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueDeleteGroupResponse.Unmarshal(m, b)
}
func (m *TaskQueueDeleteGroupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueDeleteGroupResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueDeleteGroupResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueDeleteGroupResponse.Merge(dst, src)
}
func (m *TaskQueueDeleteGroupResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueDeleteGroupResponse.Size(m)
}
func (m *TaskQueueDeleteGroupResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueDeleteGroupResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueDeleteGroupResponse proto.InternalMessageInfo

type TaskQueueQueryTasksRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	StartTaskName        []byte   `protobuf:"bytes,3,opt,name=start_task_name,json=startTaskName" json:"start_task_name,omitempty"`
	StartEtaUsec         *int64   `protobuf:"varint,4,opt,name=start_eta_usec,json=startEtaUsec" json:"start_eta_usec,omitempty"`
	StartTag             []byte   `protobuf:"bytes,6,opt,name=start_tag,json=startTag" json:"start_tag,omitempty"`
	MaxRows              *int32   `protobuf:"varint,5,opt,name=max_rows,json=maxRows,def=1" json:"max_rows,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryTasksRequest) Reset()         { *m = TaskQueueQueryTasksRequest{} }
func (m *TaskQueueQueryTasksRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksRequest) ProtoMessage()    {}
func (*TaskQueueQueryTasksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{29}
}
func (m *TaskQueueQueryTasksRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksRequest.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksRequest.Merge(dst, src)
}
func (m *TaskQueueQueryTasksRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksRequest.Size(m)
}
func (m *TaskQueueQueryTasksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksRequest proto.InternalMessageInfo

const Default_TaskQueueQueryTasksRequest_MaxRows int32 = 1

func (m *TaskQueueQueryTasksRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetStartTaskName() []byte {
	if m != nil {
		return m.StartTaskName
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetStartEtaUsec() int64 {
	if m != nil && m.StartEtaUsec != nil {
		return *m.StartEtaUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksRequest) GetStartTag() []byte {
	if m != nil {
		return m.StartTag
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetMaxRows() int32 {
	if m != nil && m.MaxRows != nil {
		return *m.MaxRows
	}
	return Default_TaskQueueQueryTasksRequest_MaxRows
}

type TaskQueueQueryTasksResponse struct {
	Task                 []*TaskQueueQueryTasksResponse_Task `protobuf:"group,1,rep,name=Task,json=task" json:"task,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *TaskQueueQueryTasksResponse) Reset()         { *m = TaskQueueQueryTasksResponse{} }
func (m *TaskQueueQueryTasksResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse) ProtoMessage()    {}
func (*TaskQueueQueryTasksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30}
}
func (m *TaskQueueQueryTasksResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksResponse.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksResponse.Merge(dst, src)
}
func (m *TaskQueueQueryTasksResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksResponse.Size(m)
}
func (m *TaskQueueQueryTasksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksResponse proto.InternalMessageInfo

func (m *TaskQueueQueryTasksResponse) GetTask() []*TaskQueueQueryTasksResponse_Task {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task struct {
	TaskName             []byte                                          `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec              *int64                                          `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	Url                  []byte                                          `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
	Method               *TaskQueueQueryTasksResponse_Task_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueQueryTasksResponse_Task_RequestMethod" json:"method,omitempty"`
	RetryCount           *int32                                          `protobuf:"varint,6,opt,name=retry_count,json=retryCount,def=0" json:"retry_count,omitempty"`
	Header               []*TaskQueueQueryTasksResponse_Task_Header      `protobuf:"group,7,rep,name=Header,json=header" json:"header,omitempty"`
	BodySize             *int32                                          `protobuf:"varint,10,opt,name=body_size,json=bodySize" json:"body_size,omitempty"`
	Body                 []byte                                          `protobuf:"bytes,11,opt,name=body" json:"body,omitempty"`
	CreationTimeUsec     *int64                                          `protobuf:"varint,12,req,name=creation_time_usec,json=creationTimeUsec" json:"creation_time_usec,omitempty"`
	Crontimetable        *TaskQueueQueryTasksResponse_Task_CronTimetable `protobuf:"group,13,opt,name=CronTimetable,json=crontimetable" json:"crontimetable,omitempty"`
	Runlog               *TaskQueueQueryTasksResponse_Task_RunLog        `protobuf:"group,16,opt,name=RunLog,json=runlog" json:"runlog,omitempty"`
	Description          []byte                                          `protobuf:"bytes,21,opt,name=description" json:"description,omitempty"`
	Payload              *TaskPayload                                    `protobuf:"bytes,22,opt,name=payload" json:"payload,omitempty"`
	RetryParameters      *TaskQueueRetryParameters                       `protobuf:"bytes,23,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	FirstTryUsec         *int64                                          `protobuf:"varint,24,opt,name=first_try_usec,json=firstTryUsec" json:"first_try_usec,omitempty"`
	Tag                  []byte                                          `protobuf:"bytes,25,opt,name=tag" json:"tag,omitempty"`
	ExecutionCount       *int32                                          `protobuf:"varint,26,opt,name=execution_count,json=executionCount,def=0" json:"execution_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}

func (m *TaskQueueQueryTasksResponse_Task) Reset()         { *m = TaskQueueQueryTasksResponse_Task{} }
func (m *TaskQueueQueryTasksResponse_Task) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task) ProtoMessage()    {}
func (*TaskQueueQueryTasksResponse_Task) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30, 0}
}
func (m *TaskQueueQueryTasksResponse_Task) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksResponse_Task) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksResponse_Task) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task.Merge(dst, src)
}
func (m *TaskQueueQueryTasksResponse_Task) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task.Size(m)
}
func (m *TaskQueueQueryTasksResponse_Task) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksResponse_Task proto.InternalMessageInfo

const Default_TaskQueueQueryTasksResponse_Task_RetryCount int32 = 0
const Default_TaskQueueQueryTasksResponse_Task_ExecutionCount int32 = 0

func (m *TaskQueueQueryTasksResponse_Task) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetUrl() []byte {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetMethod() TaskQueueQueryTasksResponse_Task_RequestMethod {
	if m != nil && m.Method != nil {
		return *m.Method
	}
	return TaskQueueQueryTasksResponse_Task_GET
}

func (m *TaskQueueQueryTasksResponse_Task) GetRetryCount() int32 {
	if m != nil && m.RetryCount != nil {
		return *m.RetryCount
	}
	return Default_TaskQueueQueryTasksResponse_Task_RetryCount
}

func (m *TaskQueueQueryTasksResponse_Task) GetHeader() []*TaskQueueQueryTasksResponse_Task_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetBodySize() int32 {
	if m != nil && m.BodySize != nil {
		return *m.BodySize
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetCreationTimeUsec() int64 {
	if m != nil && m.CreationTimeUsec != nil {
		return *m.CreationTimeUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetCrontimetable() *TaskQueueQueryTasksResponse_Task_CronTimetable {
	if m != nil {
		return m.Crontimetable
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetRunlog() *TaskQueueQueryTasksResponse_Task_RunLog {
	if m != nil {
		return m.Runlog
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetDescription() []byte {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetPayload() *TaskPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetFirstTryUsec() int64 {
	if m != nil && m.FirstTryUsec != nil {
		return *m.FirstTryUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetExecutionCount() int32 {
	if m != nil && m.ExecutionCount != nil {
		return *m.ExecutionCount
	}
	return Default_TaskQueueQueryTasksResponse_Task_ExecutionCount
}

type TaskQueueQueryTasksResponse_Task_Header struct {
	Key                  []byte   `protobuf:"bytes,8,req,name=key" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,9,req,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryTasksResponse_Task_Header) Reset() {
	*m = TaskQueueQueryTasksResponse_Task_Header{}
}
func (m *TaskQueueQueryTasksResponse_Task_Header) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task_Header) ProtoMessage()    {}
func (*TaskQueueQueryTasksResponse_Task_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30, 0, 0}
}
func (m *TaskQueueQueryTasksResponse_Task_Header) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksResponse_Task_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksResponse_Task_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header.Merge(dst, src)
}
func (m *TaskQueueQueryTasksResponse_Task_Header) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header.Size(m)
}
func (m *TaskQueueQueryTasksResponse_Task_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksResponse_Task_Header proto.InternalMessageInfo

func (m *TaskQueueQueryTasksResponse_Task_Header) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task_Header) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task_CronTimetable struct {
	Schedule             []byte   `protobuf:"bytes,14,req,name=schedule" json:"schedule,omitempty"`
	Timezone             []byte   `protobuf:"bytes,15,req,name=timezone" json:"timezone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) Reset() {
	*m = TaskQueueQueryTasksResponse_Task_CronTimetable{}
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) String() string {
	return proto.CompactTextString(m)
}
func (*TaskQueueQueryTasksResponse_Task_CronTimetable) ProtoMessage() {}
func (*TaskQueueQueryTasksResponse_Task_CronTimetable) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30, 0, 1}
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksResponse_Task_CronTimetable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable.Merge(dst, src)
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable.Size(m)
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksResponse_Task_CronTimetable proto.InternalMessageInfo

func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetSchedule() []byte {
	if m != nil {
		return m.Schedule
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetTimezone() []byte {
	if m != nil {
		return m.Timezone
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task_RunLog struct {
	DispatchedUsec       *int64   `protobuf:"varint,17,req,name=dispatched_usec,json=dispatchedUsec" json:"dispatched_usec,omitempty"`
	LagUsec              *int64   `protobuf:"varint,18,req,name=lag_usec,json=lagUsec" json:"lag_usec,omitempty"`
	ElapsedUsec          *int64   `protobuf:"varint,19,req,name=elapsed_usec,json=elapsedUsec" json:"elapsed_usec,omitempty"`
	ResponseCode         *int64   `protobuf:"varint,20,opt,name=response_code,json=responseCode" json:"response_code,omitempty"`
	RetryReason          *string  `protobuf:"bytes,27,opt,name=retry_reason,json=retryReason" json:"retry_reason,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) Reset() {
	*m = TaskQueueQueryTasksResponse_Task_RunLog{}
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task_RunLog) ProtoMessage()    {}
func (*TaskQueueQueryTasksResponse_Task_RunLog) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{30, 0, 2}
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog.Unmarshal(m, b)
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryTasksResponse_Task_RunLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog.Merge(dst, src)
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog.Size(m)
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryTasksResponse_Task_RunLog proto.InternalMessageInfo

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetDispatchedUsec() int64 {
	if m != nil && m.DispatchedUsec != nil {
		return *m.DispatchedUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetLagUsec() int64 {
	if m != nil && m.LagUsec != nil {
		return *m.LagUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetElapsedUsec() int64 {
	if m != nil && m.ElapsedUsec != nil {
		return *m.ElapsedUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetResponseCode() int64 {
	if m != nil && m.ResponseCode != nil {
		return *m.ResponseCode
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetRetryReason() string {
	if m != nil && m.RetryReason != nil {
		return *m.RetryReason
	}
	return ""
}

type TaskQueueFetchTaskRequest struct {
	AppId                []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName            []byte   `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName             []byte   `protobuf:"bytes,3,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueFetchTaskRequest) Reset()         { *m = TaskQueueFetchTaskRequest{} }
func (m *TaskQueueFetchTaskRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchTaskRequest) ProtoMessage()    {}
func (*TaskQueueFetchTaskRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{31}
}
func (m *TaskQueueFetchTaskRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchTaskRequest.Unmarshal(m, b)
}
func (m *TaskQueueFetchTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchTaskRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchTaskRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchTaskRequest.Merge(dst, src)
}
func (m *TaskQueueFetchTaskRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchTaskRequest.Size(m)
}
func (m *TaskQueueFetchTaskRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchTaskRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchTaskRequest proto.InternalMessageInfo

func (m *TaskQueueFetchTaskRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchTaskRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchTaskRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

type TaskQueueFetchTaskResponse struct {
	Task                 *TaskQueueQueryTasksResponse `protobuf:"bytes,1,req,name=task" json:"task,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *TaskQueueFetchTaskResponse) Reset()         { *m = TaskQueueFetchTaskResponse{} }
func (m *TaskQueueFetchTaskResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchTaskResponse) ProtoMessage()    {}
func (*TaskQueueFetchTaskResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{32}
}
func (m *TaskQueueFetchTaskResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueFetchTaskResponse.Unmarshal(m, b)
}
func (m *TaskQueueFetchTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueFetchTaskResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueFetchTaskResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueFetchTaskResponse.Merge(dst, src)
}
func (m *TaskQueueFetchTaskResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueFetchTaskResponse.Size(m)
}
func (m *TaskQueueFetchTaskResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueFetchTaskResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueFetchTaskResponse proto.InternalMessageInfo

func (m *TaskQueueFetchTaskResponse) GetTask() *TaskQueueQueryTasksResponse {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueUpdateStorageLimitRequest struct {
	AppId                []byte   `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	Limit                *int64   `protobuf:"varint,2,req,name=limit" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueUpdateStorageLimitRequest) Reset()         { *m = TaskQueueUpdateStorageLimitRequest{} }
func (m *TaskQueueUpdateStorageLimitRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateStorageLimitRequest) ProtoMessage()    {}
func (*TaskQueueUpdateStorageLimitRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{33}
}
func (m *TaskQueueUpdateStorageLimitRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitRequest.Unmarshal(m, b)
}
func (m *TaskQueueUpdateStorageLimitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueUpdateStorageLimitRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueUpdateStorageLimitRequest.Merge(dst, src)
}
func (m *TaskQueueUpdateStorageLimitRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitRequest.Size(m)
}
func (m *TaskQueueUpdateStorageLimitRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueUpdateStorageLimitRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueUpdateStorageLimitRequest proto.InternalMessageInfo

func (m *TaskQueueUpdateStorageLimitRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueUpdateStorageLimitRequest) GetLimit() int64 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

type TaskQueueUpdateStorageLimitResponse struct {
	NewLimit             *int64   `protobuf:"varint,1,req,name=new_limit,json=newLimit" json:"new_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueUpdateStorageLimitResponse) Reset()         { *m = TaskQueueUpdateStorageLimitResponse{} }
func (m *TaskQueueUpdateStorageLimitResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateStorageLimitResponse) ProtoMessage()    {}
func (*TaskQueueUpdateStorageLimitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{34}
}
func (m *TaskQueueUpdateStorageLimitResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitResponse.Unmarshal(m, b)
}
func (m *TaskQueueUpdateStorageLimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueUpdateStorageLimitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueUpdateStorageLimitResponse.Merge(dst, src)
}
func (m *TaskQueueUpdateStorageLimitResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueUpdateStorageLimitResponse.Size(m)
}
func (m *TaskQueueUpdateStorageLimitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueUpdateStorageLimitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueUpdateStorageLimitResponse proto.InternalMessageInfo

func (m *TaskQueueUpdateStorageLimitResponse) GetNewLimit() int64 {
	if m != nil && m.NewLimit != nil {
		return *m.NewLimit
	}
	return 0
}

type TaskQueueQueryAndOwnTasksRequest struct {
	QueueName            []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	LeaseSeconds         *float64 `protobuf:"fixed64,2,req,name=lease_seconds,json=leaseSeconds" json:"lease_seconds,omitempty"`
	MaxTasks             *int64   `protobuf:"varint,3,req,name=max_tasks,json=maxTasks" json:"max_tasks,omitempty"`
	GroupByTag           *bool    `protobuf:"varint,4,opt,name=group_by_tag,json=groupByTag,def=0" json:"group_by_tag,omitempty"`
	Tag                  []byte   `protobuf:"bytes,5,opt,name=tag" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryAndOwnTasksRequest) Reset()         { *m = TaskQueueQueryAndOwnTasksRequest{} }
func (m *TaskQueueQueryAndOwnTasksRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksRequest) ProtoMessage()    {}
func (*TaskQueueQueryAndOwnTasksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{35}
}
func (m *TaskQueueQueryAndOwnTasksRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest.Unmarshal(m, b)
}
func (m *TaskQueueQueryAndOwnTasksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryAndOwnTasksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest.Merge(dst, src)
}
func (m *TaskQueueQueryAndOwnTasksRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest.Size(m)
}
func (m *TaskQueueQueryAndOwnTasksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryAndOwnTasksRequest proto.InternalMessageInfo

const Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag bool = false

func (m *TaskQueueQueryAndOwnTasksRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetLeaseSeconds() float64 {
	if m != nil && m.LeaseSeconds != nil {
		return *m.LeaseSeconds
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetMaxTasks() int64 {
	if m != nil && m.MaxTasks != nil {
		return *m.MaxTasks
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetGroupByTag() bool {
	if m != nil && m.GroupByTag != nil {
		return *m.GroupByTag
	}
	return Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueQueryAndOwnTasksResponse struct {
	Task                 []*TaskQueueQueryAndOwnTasksResponse_Task `protobuf:"group,1,rep,name=Task,json=task" json:"task,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
	XXX_unrecognized     []byte                                    `json:"-"`
	XXX_sizecache        int32                                     `json:"-"`
}

func (m *TaskQueueQueryAndOwnTasksResponse) Reset()         { *m = TaskQueueQueryAndOwnTasksResponse{} }
func (m *TaskQueueQueryAndOwnTasksResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksResponse) ProtoMessage()    {}
func (*TaskQueueQueryAndOwnTasksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{36}
}
func (m *TaskQueueQueryAndOwnTasksResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse.Unmarshal(m, b)
}
func (m *TaskQueueQueryAndOwnTasksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryAndOwnTasksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse.Merge(dst, src)
}
func (m *TaskQueueQueryAndOwnTasksResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse.Size(m)
}
func (m *TaskQueueQueryAndOwnTasksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse proto.InternalMessageInfo

func (m *TaskQueueQueryAndOwnTasksResponse) GetTask() []*TaskQueueQueryAndOwnTasksResponse_Task {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueQueryAndOwnTasksResponse_Task struct {
	TaskName             []byte   `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec              *int64   `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	RetryCount           *int32   `protobuf:"varint,4,opt,name=retry_count,json=retryCount,def=0" json:"retry_count,omitempty"`
	Body                 []byte   `protobuf:"bytes,5,opt,name=body" json:"body,omitempty"`
	Tag                  []byte   `protobuf:"bytes,6,opt,name=tag" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) Reset() {
	*m = TaskQueueQueryAndOwnTasksResponse_Task{}
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksResponse_Task) ProtoMessage()    {}
func (*TaskQueueQueryAndOwnTasksResponse_Task) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{36, 0}
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task.Unmarshal(m, b)
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task.Marshal(b, m, deterministic)
}
func (dst *TaskQueueQueryAndOwnTasksResponse_Task) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task.Merge(dst, src)
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) XXX_Size() int {
	return xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task.Size(m)
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueQueryAndOwnTasksResponse_Task proto.InternalMessageInfo

const Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount int32 = 0

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetRetryCount() int32 {
	if m != nil && m.RetryCount != nil {
		return *m.RetryCount
	}
	return Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueModifyTaskLeaseRequest struct {
	QueueName            []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName             []byte   `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec              *int64   `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	LeaseSeconds         *float64 `protobuf:"fixed64,4,req,name=lease_seconds,json=leaseSeconds" json:"lease_seconds,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueModifyTaskLeaseRequest) Reset()         { *m = TaskQueueModifyTaskLeaseRequest{} }
func (m *TaskQueueModifyTaskLeaseRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueModifyTaskLeaseRequest) ProtoMessage()    {}
func (*TaskQueueModifyTaskLeaseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{37}
}
func (m *TaskQueueModifyTaskLeaseRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseRequest.Unmarshal(m, b)
}
func (m *TaskQueueModifyTaskLeaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseRequest.Marshal(b, m, deterministic)
}
func (dst *TaskQueueModifyTaskLeaseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueModifyTaskLeaseRequest.Merge(dst, src)
}
func (m *TaskQueueModifyTaskLeaseRequest) XXX_Size() int {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseRequest.Size(m)
}
func (m *TaskQueueModifyTaskLeaseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueModifyTaskLeaseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueModifyTaskLeaseRequest proto.InternalMessageInfo

func (m *TaskQueueModifyTaskLeaseRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueModifyTaskLeaseRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueModifyTaskLeaseRequest) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueModifyTaskLeaseRequest) GetLeaseSeconds() float64 {
	if m != nil && m.LeaseSeconds != nil {
		return *m.LeaseSeconds
	}
	return 0
}

type TaskQueueModifyTaskLeaseResponse struct {
	UpdatedEtaUsec       *int64   `protobuf:"varint,1,req,name=updated_eta_usec,json=updatedEtaUsec" json:"updated_eta_usec,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskQueueModifyTaskLeaseResponse) Reset()         { *m = TaskQueueModifyTaskLeaseResponse{} }
func (m *TaskQueueModifyTaskLeaseResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueModifyTaskLeaseResponse) ProtoMessage()    {}
func (*TaskQueueModifyTaskLeaseResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_taskqueue_service_05300f6f4e69f490, []int{38}
}
func (m *TaskQueueModifyTaskLeaseResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseResponse.Unmarshal(m, b)
}
func (m *TaskQueueModifyTaskLeaseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseResponse.Marshal(b, m, deterministic)
}
func (dst *TaskQueueModifyTaskLeaseResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskQueueModifyTaskLeaseResponse.Merge(dst, src)
}
func (m *TaskQueueModifyTaskLeaseResponse) XXX_Size() int {
	return xxx_messageInfo_TaskQueueModifyTaskLeaseResponse.Size(m)
}
func (m *TaskQueueModifyTaskLeaseResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskQueueModifyTaskLeaseResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TaskQueueModifyTaskLeaseResponse proto.InternalMessageInfo

func (m *TaskQueueModifyTaskLeaseResponse) GetUpdatedEtaUsec() int64 {
	if m != nil && m.UpdatedEtaUsec != nil {
		return *m.UpdatedEtaUsec
	}
	return 0
}

func init() {
	proto.RegisterType((*TaskQueueServiceError)(nil), "appengine.TaskQueueServiceError")
	proto.RegisterType((*TaskPayload)(nil), "appengine.TaskPayload")
	proto.RegisterType((*TaskQueueRetryParameters)(nil), "appengine.TaskQueueRetryParameters")
	proto.RegisterType((*TaskQueueAcl)(nil), "appengine.TaskQueueAcl")
	proto.RegisterType((*TaskQueueHttpHeader)(nil), "appengine.TaskQueueHttpHeader")
	proto.RegisterType((*TaskQueueMode)(nil), "appengine.TaskQueueMode")
	proto.RegisterType((*TaskQueueAddRequest)(nil), "appengine.TaskQueueAddRequest")
	proto.RegisterType((*TaskQueueAddRequest_Header)(nil), "appengine.TaskQueueAddRequest.Header")
	proto.RegisterType((*TaskQueueAddRequest_CronTimetable)(nil), "appengine.TaskQueueAddRequest.CronTimetable")
	proto.RegisterType((*TaskQueueAddResponse)(nil), "appengine.TaskQueueAddResponse")
	proto.RegisterType((*TaskQueueBulkAddRequest)(nil), "appengine.TaskQueueBulkAddRequest")
	proto.RegisterType((*TaskQueueBulkAddResponse)(nil), "appengine.TaskQueueBulkAddResponse")
	proto.RegisterType((*TaskQueueBulkAddResponse_TaskResult)(nil), "appengine.TaskQueueBulkAddResponse.TaskResult")
	proto.RegisterType((*TaskQueueDeleteRequest)(nil), "appengine.TaskQueueDeleteRequest")
	proto.RegisterType((*TaskQueueDeleteResponse)(nil), "appengine.TaskQueueDeleteResponse")
	proto.RegisterType((*TaskQueueForceRunRequest)(nil), "appengine.TaskQueueForceRunRequest")
	proto.RegisterType((*TaskQueueForceRunResponse)(nil), "appengine.TaskQueueForceRunResponse")
	proto.RegisterType((*TaskQueueUpdateQueueRequest)(nil), "appengine.TaskQueueUpdateQueueRequest")
	proto.RegisterType((*TaskQueueUpdateQueueResponse)(nil), "appengine.TaskQueueUpdateQueueResponse")
	proto.RegisterType((*TaskQueueFetchQueuesRequest)(nil), "appengine.TaskQueueFetchQueuesRequest")
	proto.RegisterType((*TaskQueueFetchQueuesResponse)(nil), "appengine.TaskQueueFetchQueuesResponse")
	proto.RegisterType((*TaskQueueFetchQueuesResponse_Queue)(nil), "appengine.TaskQueueFetchQueuesResponse.Queue")
	proto.RegisterType((*TaskQueueFetchQueueStatsRequest)(nil), "appengine.TaskQueueFetchQueueStatsRequest")
	proto.RegisterType((*TaskQueueScannerQueueInfo)(nil), "appengine.TaskQueueScannerQueueInfo")
	proto.RegisterType((*TaskQueueFetchQueueStatsResponse)(nil), "appengine.TaskQueueFetchQueueStatsResponse")
	proto.RegisterType((*TaskQueueFetchQueueStatsResponse_QueueStats)(nil), "appengine.TaskQueueFetchQueueStatsResponse.QueueStats")
	proto.RegisterType((*TaskQueuePauseQueueRequest)(nil), "appengine.TaskQueuePauseQueueRequest")
	proto.RegisterType((*TaskQueuePauseQueueResponse)(nil), "appengine.TaskQueuePauseQueueResponse")
	proto.RegisterType((*TaskQueuePurgeQueueRequest)(nil), "appengine.TaskQueuePurgeQueueRequest")
	proto.RegisterType((*TaskQueuePurgeQueueResponse)(nil), "appengine.TaskQueuePurgeQueueResponse")
	proto.RegisterType((*TaskQueueDeleteQueueRequest)(nil), "appengine.TaskQueueDeleteQueueRequest")
	proto.RegisterType((*TaskQueueDeleteQueueResponse)(nil), "appengine.TaskQueueDeleteQueueResponse")
	proto.RegisterType((*TaskQueueDeleteGroupRequest)(nil), "appengine.TaskQueueDeleteGroupRequest")
	proto.RegisterType((*TaskQueueDeleteGroupResponse)(nil), "appengine.TaskQueueDeleteGroupResponse")
	proto.RegisterType((*TaskQueueQueryTasksRequest)(nil), "appengine.TaskQueueQueryTasksRequest")
	proto.RegisterType((*TaskQueueQueryTasksResponse)(nil), "appengine.TaskQueueQueryTasksResponse")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task)(nil), "appengine.TaskQueueQueryTasksResponse.Task")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_Header)(nil), "appengine.TaskQueueQueryTasksResponse.Task.Header")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_CronTimetable)(nil), "appengine.TaskQueueQueryTasksResponse.Task.CronTimetable")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_RunLog)(nil), "appengine.TaskQueueQueryTasksResponse.Task.RunLog")
	proto.RegisterType((*TaskQueueFetchTaskRequest)(nil), "appengine.TaskQueueFetchTaskRequest")
	proto.RegisterType((*TaskQueueFetchTaskResponse)(nil), "appengine.TaskQueueFetchTaskResponse")
	proto.RegisterType((*TaskQueueUpdateStorageLimitRequest)(nil), "appengine.TaskQueueUpdateStorageLimitRequest")
	proto.RegisterType((*TaskQueueUpdateStorageLimitResponse)(nil), "appengine.TaskQueueUpdateStorageLimitResponse")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksRequest)(nil), "appengine.TaskQueueQueryAndOwnTasksRequest")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksResponse)(nil), "appengine.TaskQueueQueryAndOwnTasksResponse")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksResponse_Task)(nil), "appengine.TaskQueueQueryAndOwnTasksResponse.Task")
	proto.RegisterType((*TaskQueueModifyTaskLeaseRequest)(nil), "appengine.TaskQueueModifyTaskLeaseRequest")
	proto.RegisterType((*TaskQueueModifyTaskLeaseResponse)(nil), "appengine.TaskQueueModifyTaskLeaseResponse")
}

func init() {
	proto.RegisterFile("google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto", fileDescriptor_taskqueue_service_05300f6f4e69f490)
}

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