// Code generated by go run gob_gen.go; DO NOT EDIT.

package testconfigs

import (
 "bytes"
 "github.com/google/blueprint/gobtools"
 "github.com/google/blueprint/proptools"
)

// begin of owners.go
func init() {
 OwnersGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Owners) })
}

func (r Owners) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = gobtools.EncodeString(buf, r.Team); err != nil {
  return err
 }
 return err
}

func (r Owners) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.Owners")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Team)
 return nil
}

func (r *Owners) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 err = gobtools.DecodeString(buf, &r.Team)
 if err != nil {
  return err
 }

 return err
}

var OwnersGobRegId int16

func (r Owners) GetTypeId() int16 {
 return OwnersGobRegId
}

// end of owners.go

// begin of test_execution_plan.go
func init() {
 TestExecutionPlanPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestExecutionPlanProperties) })
 TestExecutionPlanMetadataPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestExecutionPlanMetadataProperties) })
 ModulePropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleProperties) })
 TestExecutionPlanInlinableGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestExecutionPlanInlinable) })
}

func (r TestExecutionPlanProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Tests == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Tests)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Tests); val1++ {
   if err = r.Tests[val1].Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if r.Args == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Args)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.Args); val2++ {
   if err = gobtools.EncodeString(buf, r.Args[val2]); err != nil {
    return err
   }
  }
 }

 if err = r.TestExecutionPlanMetadataProperties.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r TestExecutionPlanProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestExecutionPlanProperties")
 hasher.WriteInt(3)
 hasher.WriteString(":.[]ModuleProperties")
 hasher.WriteInt(len(r.Tests))
 for val1 := 0; val1 < len(r.Tests); val1++ {
  if err := r.Tests[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Args))
 for val2 := 0; val2 < len(r.Args); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Args[val2])
 }
 if err := r.TestExecutionPlanMetadataProperties.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *TestExecutionPlanProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Tests = make([]ModuleProperties, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   if err = r.Tests[val3].Decode(ctx, buf); err != nil {
    return err
   }
  }
 }

 var val6 int
 err = gobtools.DecodeInt(buf, &val6)
 if err != nil {
  return err
 }
 if val6 != -1 {
  r.Args = make([]string, val6)
  for val7 := 0; val7 < int(val6); val7++ {
   err = gobtools.DecodeString(buf, &r.Args[val7])
   if err != nil {
    return err
   }
  }
 }

 if err = r.TestExecutionPlanMetadataProperties.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var TestExecutionPlanPropertiesGobRegId int16

func (r TestExecutionPlanProperties) GetTypeId() int16 {
 return TestExecutionPlanPropertiesGobRegId
}

func (r TestExecutionPlanMetadataProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Code_under_test == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Code_under_test)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Code_under_test); val1++ {
   if err = gobtools.EncodeString(buf, r.Code_under_test[val1]); err != nil {
    return err
   }
  }
 }
 return err
}

func (r TestExecutionPlanMetadataProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestExecutionPlanMetadataProperties")
 hasher.WriteInt(1)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Code_under_test))
 for val1 := 0; val1 < len(r.Code_under_test); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Code_under_test[val1])
 }
 return nil
}

func (r *TestExecutionPlanMetadataProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Code_under_test = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.Code_under_test[val3])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var TestExecutionPlanMetadataPropertiesGobRegId int16

func (r TestExecutionPlanMetadataProperties) GetTypeId() int16 {
 return TestExecutionPlanMetadataPropertiesGobRegId
}

func (r ModuleProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = gobtools.EncodeString(buf, r.Module); err != nil {
  return err
 }

 if r.Include == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Include)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Include); val1++ {
   if err = gobtools.EncodeString(buf, r.Include[val1]); err != nil {
    return err
   }
  }
 }

 if r.Exclude == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Exclude)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.Exclude); val2++ {
   if err = gobtools.EncodeString(buf, r.Exclude[val2]); err != nil {
    return err
   }
  }
 }

 if r.Module_args == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Module_args)); err != nil {
   return err
  }
  for val3 := 0; val3 < len(r.Module_args); val3++ {
   if err = gobtools.EncodeString(buf, r.Module_args[val3]); err != nil {
    return err
   }
  }
 }
 return err
}

func (r ModuleProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.ModuleProperties")
 hasher.WriteInt(4)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Module)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Include))
 for val1 := 0; val1 < len(r.Include); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Include[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Exclude))
 for val2 := 0; val2 < len(r.Exclude); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Exclude[val2])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Module_args))
 for val3 := 0; val3 < len(r.Module_args); val3++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Module_args[val3])
 }
 return nil
}

func (r *ModuleProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 err = gobtools.DecodeString(buf, &r.Module)
 if err != nil {
  return err
 }

 var val3 int
 err = gobtools.DecodeInt(buf, &val3)
 if err != nil {
  return err
 }
 if val3 != -1 {
  r.Include = make([]string, val3)
  for val4 := 0; val4 < int(val3); val4++ {
   err = gobtools.DecodeString(buf, &r.Include[val4])
   if err != nil {
    return err
   }
  }
 }

 var val7 int
 err = gobtools.DecodeInt(buf, &val7)
 if err != nil {
  return err
 }
 if val7 != -1 {
  r.Exclude = make([]string, val7)
  for val8 := 0; val8 < int(val7); val8++ {
   err = gobtools.DecodeString(buf, &r.Exclude[val8])
   if err != nil {
    return err
   }
  }
 }

 var val11 int
 err = gobtools.DecodeInt(buf, &val11)
 if err != nil {
  return err
 }
 if val11 != -1 {
  r.Module_args = make([]string, val11)
  for val12 := 0; val12 < int(val11); val12++ {
   err = gobtools.DecodeString(buf, &r.Module_args[val12])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var ModulePropertiesGobRegId int16

func (r ModuleProperties) GetTypeId() int16 {
 return ModulePropertiesGobRegId
}

func (r TestExecutionPlanInlinable) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.TestExecutionPlanProperties.Encode(ctx, buf); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.Name); err != nil {
  return err
 }
 return err
}

func (r TestExecutionPlanInlinable) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestExecutionPlanInlinable")
 hasher.WriteInt(2)
 if err := r.TestExecutionPlanProperties.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 return nil
}

func (r *TestExecutionPlanInlinable) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.TestExecutionPlanProperties.Decode(ctx, buf); err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.Name)
 if err != nil {
  return err
 }

 return err
}

var TestExecutionPlanInlinableGobRegId int16

func (r TestExecutionPlanInlinable) GetTypeId() int16 {
 return TestExecutionPlanInlinableGobRegId
}

// end of test_execution_plan.go

// begin of test_scheduling_plan.go
func init() {
 TestSchedulingPlanPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestSchedulingPlanProperties) })
 TestSchedulingPlanInlinableGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestSchedulingPlanInlinable) })
}

func (r TestSchedulingPlanProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Related_plans == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Related_plans)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Related_plans); val1++ {
   if err = gobtools.EncodeString(buf, r.Related_plans[val1]); err != nil {
    return err
   }
  }
 }
 return err
}

func (r TestSchedulingPlanProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestSchedulingPlanProperties")
 hasher.WriteInt(1)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Related_plans))
 for val1 := 0; val1 < len(r.Related_plans); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Related_plans[val1])
 }
 return nil
}

func (r *TestSchedulingPlanProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Related_plans = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.Related_plans[val3])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var TestSchedulingPlanPropertiesGobRegId int16

func (r TestSchedulingPlanProperties) GetTypeId() int16 {
 return TestSchedulingPlanPropertiesGobRegId
}

func (r TestSchedulingPlanInlinable) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.TestSchedulingPlanProperties.Encode(ctx, buf); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.Name); err != nil {
  return err
 }
 return err
}

func (r TestSchedulingPlanInlinable) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestSchedulingPlanInlinable")
 hasher.WriteInt(2)
 if err := r.TestSchedulingPlanProperties.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 return nil
}

func (r *TestSchedulingPlanInlinable) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.TestSchedulingPlanProperties.Decode(ctx, buf); err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.Name)
 if err != nil {
  return err
 }

 return err
}

var TestSchedulingPlanInlinableGobRegId int16

func (r TestSchedulingPlanInlinable) GetTypeId() int16 {
 return TestSchedulingPlanInlinableGobRegId
}

// end of test_scheduling_plan.go

// begin of test_trigger.go
func init() {
 TestTriggerPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestTriggerProperties) })
 TestTriggerInlinePropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestTriggerInlineProperties) })
 TestTriggerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestTriggerInfo) })
}

func (r TestTriggerProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if r.Imports == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Imports)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Imports); val1++ {
   if err = gobtools.EncodeString(buf, r.Imports[val1]); err != nil {
    return err
   }
  }
 }

 if r.File_patterns == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.File_patterns)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.File_patterns); val2++ {
   if err = gobtools.EncodeString(buf, r.File_patterns[val2]); err != nil {
    return err
   }
  }
 }

 if r.Test_workflows == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Test_workflows)); err != nil {
   return err
  }
  for val3 := 0; val3 < len(r.Test_workflows); val3++ {
   if err = gobtools.EncodeString(buf, r.Test_workflows[val3]); err != nil {
    return err
   }
  }
 }

 if err = r.Owners.Encode(ctx, buf); err != nil {
  return err
 }

 if err = r.TestTriggerInlineProperties.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r TestTriggerProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestTriggerProperties")
 hasher.WriteInt(5)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Imports))
 for val1 := 0; val1 < len(r.Imports); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Imports[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.File_patterns))
 for val2 := 0; val2 < len(r.File_patterns); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.File_patterns[val2])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Test_workflows))
 for val3 := 0; val3 < len(r.Test_workflows); val3++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Test_workflows[val3])
 }
 if err := r.Owners.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.TestTriggerInlineProperties.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *TestTriggerProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  r.Imports = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.Imports[val3])
   if err != nil {
    return err
   }
  }
 }

 var val6 int
 err = gobtools.DecodeInt(buf, &val6)
 if err != nil {
  return err
 }
 if val6 != -1 {
  r.File_patterns = make([]string, val6)
  for val7 := 0; val7 < int(val6); val7++ {
   err = gobtools.DecodeString(buf, &r.File_patterns[val7])
   if err != nil {
    return err
   }
  }
 }

 var val10 int
 err = gobtools.DecodeInt(buf, &val10)
 if err != nil {
  return err
 }
 if val10 != -1 {
  r.Test_workflows = make([]string, val10)
  for val11 := 0; val11 < int(val10); val11++ {
   err = gobtools.DecodeString(buf, &r.Test_workflows[val11])
   if err != nil {
    return err
   }
  }
 }

 if err = r.Owners.Decode(ctx, buf); err != nil {
  return err
 }

 if err = r.TestTriggerInlineProperties.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var TestTriggerPropertiesGobRegId int16

func (r TestTriggerProperties) GetTypeId() int16 {
 return TestTriggerPropertiesGobRegId
}

func (r TestTriggerInlineProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.Scheduling_plan.Encode(ctx, buf); err != nil {
  return err
 }

 if r.Tests == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Tests)); err != nil {
   return err
  }
  for val1 := 0; val1 < len(r.Tests); val1++ {
   if err = r.Tests[val1].Encode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if err = r.TestExecutionPlanMetadataProperties.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r TestTriggerInlineProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestTriggerInlineProperties")
 hasher.WriteInt(3)
 if err := r.Scheduling_plan.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.[]ModuleProperties")
 hasher.WriteInt(len(r.Tests))
 for val1 := 0; val1 < len(r.Tests); val1++ {
  if err := r.Tests[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 if err := r.TestExecutionPlanMetadataProperties.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *TestTriggerInlineProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.Scheduling_plan.Decode(ctx, buf); err != nil {
  return err
 }

 var val3 int
 err = gobtools.DecodeInt(buf, &val3)
 if err != nil {
  return err
 }
 if val3 != -1 {
  r.Tests = make([]ModuleProperties, val3)
  for val4 := 0; val4 < int(val3); val4++ {
   if err = r.Tests[val4].Decode(ctx, buf); err != nil {
    return err
   }
  }
 }

 if err = r.TestExecutionPlanMetadataProperties.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var TestTriggerInlinePropertiesGobRegId int16

func (r TestTriggerInlineProperties) GetTypeId() int16 {
 return TestTriggerInlinePropertiesGobRegId
}

func (r TestTriggerInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.TestTriggerProperties.Encode(ctx, buf); err != nil {
  return err
 }

 if err = gobtools.EncodeString(buf, r.modulePath); err != nil {
  return err
 }
 return err
}

func (r TestTriggerInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestTriggerInfo")
 hasher.WriteInt(2)
 if err := r.TestTriggerProperties.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.modulePath)
 return nil
}

func (r *TestTriggerInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.TestTriggerProperties.Decode(ctx, buf); err != nil {
  return err
 }

 err = gobtools.DecodeString(buf, &r.modulePath)
 if err != nil {
  return err
 }

 return err
}

var TestTriggerInfoGobRegId int16

func (r TestTriggerInfo) GetTypeId() int16 {
 return TestTriggerInfoGobRegId
}

// end of test_trigger.go

// begin of test_workflow.go
func init() {
 TestWorkflowPropertiesGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(TestWorkflowProperties) })
}

func (r TestWorkflowProperties) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 var err error

 if err = r.Execution_plan.Encode(ctx, buf); err != nil {
  return err
 }

 if err = r.Scheduling_plan.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r TestWorkflowProperties) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testconfigs.TestWorkflowProperties")
 hasher.WriteInt(2)
 if err := r.Execution_plan.CustomHash(hasher); err != nil {
  return err
 }
 if err := r.Scheduling_plan.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

func (r *TestWorkflowProperties) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
 var err error

 if err = r.Execution_plan.Decode(ctx, buf); err != nil {
  return err
 }

 if err = r.Scheduling_plan.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var TestWorkflowPropertiesGobRegId int16

func (r TestWorkflowProperties) GetTypeId() int16 {
 return TestWorkflowPropertiesGobRegId
}

// end of test_workflow.go