bline/channel/channel.go

// Code generated by Thrift Compiler (0.15.0). DO NOT EDIT.

package channel

import (
	"bytes"
	"context"
	"database/sql/driver"
	"errors"
	"fmt"
	"time"
	"github.com/bashery/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = context.Background
var _ = time.Now
var _ = bytes.Equal

type AppStoreCode int64
const (
  AppStoreCode_PAYMENT_APPLE AppStoreCode = 1
  AppStoreCode_PAYMENT_GOOGLE AppStoreCode = 2
)

func (p AppStoreCode) String() string {
  switch p {
  case AppStoreCode_PAYMENT_APPLE: return "PAYMENT_APPLE"
  case AppStoreCode_PAYMENT_GOOGLE: return "PAYMENT_GOOGLE"
  }
  return "<UNSET>"
}

func AppStoreCodeFromString(s string) (AppStoreCode, error) {
  switch s {
  case "PAYMENT_APPLE": return AppStoreCode_PAYMENT_APPLE, nil 
  case "PAYMENT_GOOGLE": return AppStoreCode_PAYMENT_GOOGLE, nil 
  }
  return AppStoreCode(0), fmt.Errorf("not a valid AppStoreCode string")
}


func AppStoreCodePtr(v AppStoreCode) *AppStoreCode { return &v }

func (p AppStoreCode) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *AppStoreCode) UnmarshalText(text []byte) error {
q, err := AppStoreCodeFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *AppStoreCode) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = AppStoreCode(v)
return nil
}

func (p * AppStoreCode) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type ChannelAllowedPermission int64
const (
  ChannelAllowedPermission_PROFILE ChannelAllowedPermission = 0
  ChannelAllowedPermission_FRIENDS ChannelAllowedPermission = 1
  ChannelAllowedPermission_GROUP ChannelAllowedPermission = 2
)

func (p ChannelAllowedPermission) String() string {
  switch p {
  case ChannelAllowedPermission_PROFILE: return "PROFILE"
  case ChannelAllowedPermission_FRIENDS: return "FRIENDS"
  case ChannelAllowedPermission_GROUP: return "GROUP"
  }
  return "<UNSET>"
}

func ChannelAllowedPermissionFromString(s string) (ChannelAllowedPermission, error) {
  switch s {
  case "PROFILE": return ChannelAllowedPermission_PROFILE, nil 
  case "FRIENDS": return ChannelAllowedPermission_FRIENDS, nil 
  case "GROUP": return ChannelAllowedPermission_GROUP, nil 
  }
  return ChannelAllowedPermission(0), fmt.Errorf("not a valid ChannelAllowedPermission string")
}


func ChannelAllowedPermissionPtr(v ChannelAllowedPermission) *ChannelAllowedPermission { return &v }

func (p ChannelAllowedPermission) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *ChannelAllowedPermission) UnmarshalText(text []byte) error {
q, err := ChannelAllowedPermissionFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *ChannelAllowedPermission) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = ChannelAllowedPermission(v)
return nil
}

func (p * ChannelAllowedPermission) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type ChannelConfiguration int64
const (
  ChannelConfiguration_MESSAGE ChannelConfiguration = 0
  ChannelConfiguration_MESSAGE_NOTIFICATION ChannelConfiguration = 1
  ChannelConfiguration_NOTIFICATION_CENTER ChannelConfiguration = 2
)

func (p ChannelConfiguration) String() string {
  switch p {
  case ChannelConfiguration_MESSAGE: return "MESSAGE"
  case ChannelConfiguration_MESSAGE_NOTIFICATION: return "MESSAGE_NOTIFICATION"
  case ChannelConfiguration_NOTIFICATION_CENTER: return "NOTIFICATION_CENTER"
  }
  return "<UNSET>"
}

func ChannelConfigurationFromString(s string) (ChannelConfiguration, error) {
  switch s {
  case "MESSAGE": return ChannelConfiguration_MESSAGE, nil 
  case "MESSAGE_NOTIFICATION": return ChannelConfiguration_MESSAGE_NOTIFICATION, nil 
  case "NOTIFICATION_CENTER": return ChannelConfiguration_NOTIFICATION_CENTER, nil 
  }
  return ChannelConfiguration(0), fmt.Errorf("not a valid ChannelConfiguration string")
}


func ChannelConfigurationPtr(v ChannelConfiguration) *ChannelConfiguration { return &v }

func (p ChannelConfiguration) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *ChannelConfiguration) UnmarshalText(text []byte) error {
q, err := ChannelConfigurationFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *ChannelConfiguration) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = ChannelConfiguration(v)
return nil
}

func (p * ChannelConfiguration) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type ChannelErrorCode int64
const (
  ChannelErrorCode_ILLEGAL_ARGUMENT ChannelErrorCode = 0
  ChannelErrorCode_INTERNAL_ERROR ChannelErrorCode = 1
  ChannelErrorCode_CONNECTION_ERROR ChannelErrorCode = 2
  ChannelErrorCode_AUTHENTICATIONI_FAILED ChannelErrorCode = 3
  ChannelErrorCode_NEED_PERMISSION_APPROVAL ChannelErrorCode = 4
  ChannelErrorCode_COIN_NOT_USABLE ChannelErrorCode = 5
  ChannelErrorCode_WEBVIEW_NOT_ALLOWED ChannelErrorCode = 6
)

func (p ChannelErrorCode) String() string {
  switch p {
  case ChannelErrorCode_ILLEGAL_ARGUMENT: return "ILLEGAL_ARGUMENT"
  case ChannelErrorCode_INTERNAL_ERROR: return "INTERNAL_ERROR"
  case ChannelErrorCode_CONNECTION_ERROR: return "CONNECTION_ERROR"
  case ChannelErrorCode_AUTHENTICATIONI_FAILED: return "AUTHENTICATIONI_FAILED"
  case ChannelErrorCode_NEED_PERMISSION_APPROVAL: return "NEED_PERMISSION_APPROVAL"
  case ChannelErrorCode_COIN_NOT_USABLE: return "COIN_NOT_USABLE"
  case ChannelErrorCode_WEBVIEW_NOT_ALLOWED: return "WEBVIEW_NOT_ALLOWED"
  }
  return "<UNSET>"
}

func ChannelErrorCodeFromString(s string) (ChannelErrorCode, error) {
  switch s {
  case "ILLEGAL_ARGUMENT": return ChannelErrorCode_ILLEGAL_ARGUMENT, nil 
  case "INTERNAL_ERROR": return ChannelErrorCode_INTERNAL_ERROR, nil 
  case "CONNECTION_ERROR": return ChannelErrorCode_CONNECTION_ERROR, nil 
  case "AUTHENTICATIONI_FAILED": return ChannelErrorCode_AUTHENTICATIONI_FAILED, nil 
  case "NEED_PERMISSION_APPROVAL": return ChannelErrorCode_NEED_PERMISSION_APPROVAL, nil 
  case "COIN_NOT_USABLE": return ChannelErrorCode_COIN_NOT_USABLE, nil 
  case "WEBVIEW_NOT_ALLOWED": return ChannelErrorCode_WEBVIEW_NOT_ALLOWED, nil 
  }
  return ChannelErrorCode(0), fmt.Errorf("not a valid ChannelErrorCode string")
}


func ChannelErrorCodePtr(v ChannelErrorCode) *ChannelErrorCode { return &v }

func (p ChannelErrorCode) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *ChannelErrorCode) UnmarshalText(text []byte) error {
q, err := ChannelErrorCodeFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *ChannelErrorCode) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = ChannelErrorCode(v)
return nil
}

func (p * ChannelErrorCode) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type ChannelFeatureLicense int64
const (
  ChannelFeatureLicense_BLE_LCS_API_USABLE ChannelFeatureLicense = 26
  ChannelFeatureLicense_PROHIBIT_MINIMIZE_CHANNEL_BROWSER ChannelFeatureLicense = 27
  ChannelFeatureLicense_ALLOW_IOS_WEBKIT ChannelFeatureLicense = 28
  ChannelFeatureLicense_PURCHASE_LCS_API_USABLE ChannelFeatureLicense = 38
)

func (p ChannelFeatureLicense) String() string {
  switch p {
  case ChannelFeatureLicense_BLE_LCS_API_USABLE: return "BLE_LCS_API_USABLE"
  case ChannelFeatureLicense_PROHIBIT_MINIMIZE_CHANNEL_BROWSER: return "PROHIBIT_MINIMIZE_CHANNEL_BROWSER"
  case ChannelFeatureLicense_ALLOW_IOS_WEBKIT: return "ALLOW_IOS_WEBKIT"
  case ChannelFeatureLicense_PURCHASE_LCS_API_USABLE: return "PURCHASE_LCS_API_USABLE"
  }
  return "<UNSET>"
}

func ChannelFeatureLicenseFromString(s string) (ChannelFeatureLicense, error) {
  switch s {
  case "BLE_LCS_API_USABLE": return ChannelFeatureLicense_BLE_LCS_API_USABLE, nil 
  case "PROHIBIT_MINIMIZE_CHANNEL_BROWSER": return ChannelFeatureLicense_PROHIBIT_MINIMIZE_CHANNEL_BROWSER, nil 
  case "ALLOW_IOS_WEBKIT": return ChannelFeatureLicense_ALLOW_IOS_WEBKIT, nil 
  case "PURCHASE_LCS_API_USABLE": return ChannelFeatureLicense_PURCHASE_LCS_API_USABLE, nil 
  }
  return ChannelFeatureLicense(0), fmt.Errorf("not a valid ChannelFeatureLicense string")
}


func ChannelFeatureLicensePtr(v ChannelFeatureLicense) *ChannelFeatureLicense { return &v }

func (p ChannelFeatureLicense) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *ChannelFeatureLicense) UnmarshalText(text []byte) error {
q, err := ChannelFeatureLicenseFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *ChannelFeatureLicense) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = ChannelFeatureLicense(v)
return nil
}

func (p * ChannelFeatureLicense) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type PublicType int64
const (
  PublicType_HIDDEN PublicType = 0
  PublicType_PUBLIC PublicType = 1000
)

func (p PublicType) String() string {
  switch p {
  case PublicType_HIDDEN: return "HIDDEN"
  case PublicType_PUBLIC: return "PUBLIC"
  }
  return "<UNSET>"
}

func PublicTypeFromString(s string) (PublicType, error) {
  switch s {
  case "HIDDEN": return PublicType_HIDDEN, nil 
  case "PUBLIC": return PublicType_PUBLIC, nil 
  }
  return PublicType(0), fmt.Errorf("not a valid PublicType string")
}


func PublicTypePtr(v PublicType) *PublicType { return &v }

func (p PublicType) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *PublicType) UnmarshalText(text []byte) error {
q, err := PublicTypeFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *PublicType) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = PublicType(v)
return nil
}

func (p * PublicType) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
// Attributes:
//  - Code
//  - Reason
//  - ParameterMap
type ChannelException struct {
  Code ChannelErrorCode `thrift:"code,1" db:"code" json:"code"`
  Reason string `thrift:"reason,2" db:"reason" json:"reason"`
  ParameterMap map[string]string `thrift:"parameterMap,3" db:"parameterMap" json:"parameterMap"`
}

func NewChannelException() *ChannelException {
  return &ChannelException{}
}


func (p *ChannelException) GetCode() ChannelErrorCode {
  return p.Code
}

func (p *ChannelException) GetReason() string {
  return p.Reason
}

func (p *ChannelException) GetParameterMap() map[string]string {
  return p.ParameterMap
}
func (p *ChannelException) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelException)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := ChannelErrorCode(v)
  p.Code = temp
}
  return nil
}

func (p *ChannelException)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Reason = v
}
  return nil
}

func (p *ChannelException)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[string]string, size)
  p.ParameterMap =  tMap
  for i := 0; i < size; i ++ {
var _key0 string
    if v, err := iprot.ReadString(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _key0 = v
}
var _val1 string
    if v, err := iprot.ReadString(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _val1 = v
}
    p.ParameterMap[_key0] = _val1
  }
  if err := iprot.ReadMapEnd(ctx); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *ChannelException) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelException"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelException) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "code", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:code: ", p), err) }
  if err := oprot.WriteI32(ctx, int32(p.Code)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.code (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:code: ", p), err) }
  return err
}

func (p *ChannelException) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "reason", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:reason: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Reason)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.reason (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:reason: ", p), err) }
  return err
}

func (p *ChannelException) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "parameterMap", thrift.MAP, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:parameterMap: ", p), err) }
  if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.ParameterMap)); err != nil {
    return thrift.PrependError("error writing map begin: ", err)
  }
  for k, v := range p.ParameterMap {
    if err := oprot.WriteString(ctx, string(k)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    if err := oprot.WriteString(ctx, string(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteMapEnd(ctx); err != nil {
    return thrift.PrependError("error writing map end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:parameterMap: ", p), err) }
  return err
}

func (p *ChannelException) Equals(other *ChannelException) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.Code != other.Code { return false }
  if p.Reason != other.Reason { return false }
  if len(p.ParameterMap) != len(other.ParameterMap) { return false }
  for k, _tgt := range p.ParameterMap {
    _src2 := other.ParameterMap[k]
    if _tgt != _src2 { return false }
  }
  return true
}

func (p *ChannelException) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelException(%+v)", *p)
}

func (p *ChannelException) Error() string {
  return p.String()
}

func (ChannelException) TExceptionType() thrift.TExceptionType {
  return thrift.TExceptionTypeCompiled
}

var _ thrift.TException = (*ChannelException)(nil)

// Attributes:
//  - ChannelInfo
//  - ApprovedAt
type ApprovedChannelInfo struct {
  ChannelInfo *ChannelInfo `thrift:"channelInfo,1" db:"channelInfo" json:"channelInfo"`
  ApprovedAt int64 `thrift:"approvedAt,2" db:"approvedAt" json:"approvedAt"`
}

func NewApprovedChannelInfo() *ApprovedChannelInfo {
  return &ApprovedChannelInfo{}
}

var ApprovedChannelInfo_ChannelInfo_DEFAULT *ChannelInfo
func (p *ApprovedChannelInfo) GetChannelInfo() *ChannelInfo {
  if !p.IsSetChannelInfo() {
    return ApprovedChannelInfo_ChannelInfo_DEFAULT
  }
return p.ChannelInfo
}

func (p *ApprovedChannelInfo) GetApprovedAt() int64 {
  return p.ApprovedAt
}
func (p *ApprovedChannelInfo) IsSetChannelInfo() bool {
  return p.ChannelInfo != nil
}

func (p *ApprovedChannelInfo) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ApprovedChannelInfo)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.ChannelInfo = &ChannelInfo{}
  if err := p.ChannelInfo.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ChannelInfo), err)
  }
  return nil
}

func (p *ApprovedChannelInfo)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ApprovedAt = v
}
  return nil
}

func (p *ApprovedChannelInfo) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ApprovedChannelInfo"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ApprovedChannelInfo) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelInfo", thrift.STRUCT, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelInfo: ", p), err) }
  if err := p.ChannelInfo.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ChannelInfo), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelInfo: ", p), err) }
  return err
}

func (p *ApprovedChannelInfo) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "approvedAt", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:approvedAt: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.ApprovedAt)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.approvedAt (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:approvedAt: ", p), err) }
  return err
}

func (p *ApprovedChannelInfo) Equals(other *ApprovedChannelInfo) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if !p.ChannelInfo.Equals(other.ChannelInfo) { return false }
  if p.ApprovedAt != other.ApprovedAt { return false }
  return true
}

func (p *ApprovedChannelInfo) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ApprovedChannelInfo(%+v)", *p)
}

// Attributes:
//  - ApprovedChannelInfos
//  - Revision
type ApprovedChannelInfos struct {
  ApprovedChannelInfos []*ApprovedChannelInfo `thrift:"approvedChannelInfos,1" db:"approvedChannelInfos" json:"approvedChannelInfos"`
  Revision int64 `thrift:"revision,2" db:"revision" json:"revision"`
}

func NewApprovedChannelInfos() *ApprovedChannelInfos {
  return &ApprovedChannelInfos{}
}


func (p *ApprovedChannelInfos) GetApprovedChannelInfos() []*ApprovedChannelInfo {
  return p.ApprovedChannelInfos
}

func (p *ApprovedChannelInfos) GetRevision() int64 {
  return p.Revision
}
func (p *ApprovedChannelInfos) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ApprovedChannelInfos)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ApprovedChannelInfo, 0, size)
  p.ApprovedChannelInfos =  tSlice
  for i := 0; i < size; i ++ {
    _elem3 := &ApprovedChannelInfo{}
    if err := _elem3.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem3), err)
    }
    p.ApprovedChannelInfos = append(p.ApprovedChannelInfos, _elem3)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ApprovedChannelInfos)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Revision = v
}
  return nil
}

func (p *ApprovedChannelInfos) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ApprovedChannelInfos"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ApprovedChannelInfos) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "approvedChannelInfos", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:approvedChannelInfos: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.ApprovedChannelInfos)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.ApprovedChannelInfos {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:approvedChannelInfos: ", p), err) }
  return err
}

func (p *ApprovedChannelInfos) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "revision", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:revision: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.Revision)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.revision (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:revision: ", p), err) }
  return err
}

func (p *ApprovedChannelInfos) Equals(other *ApprovedChannelInfos) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if len(p.ApprovedChannelInfos) != len(other.ApprovedChannelInfos) { return false }
  for i, _tgt := range p.ApprovedChannelInfos {
    _src4 := other.ApprovedChannelInfos[i]
    if !_tgt.Equals(_src4) { return false }
  }
  if p.Revision != other.Revision { return false }
  return true
}

func (p *ApprovedChannelInfos) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ApprovedChannelInfos(%+v)", *p)
}

// Attributes:
//  - Host
//  - Removed
type ChannelDomain struct {
  Host string `thrift:"host,1" db:"host" json:"host"`
  Removed bool `thrift:"removed,2" db:"removed" json:"removed"`
}

func NewChannelDomain() *ChannelDomain {
  return &ChannelDomain{}
}


func (p *ChannelDomain) GetHost() string {
  return p.Host
}

func (p *ChannelDomain) GetRemoved() bool {
  return p.Removed
}
func (p *ChannelDomain) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelDomain)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Host = v
}
  return nil
}

func (p *ChannelDomain)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Removed = v
}
  return nil
}

func (p *ChannelDomain) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelDomain"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelDomain) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "host", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:host: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Host)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.host (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:host: ", p), err) }
  return err
}

func (p *ChannelDomain) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "removed", thrift.BOOL, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:removed: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.Removed)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.removed (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:removed: ", p), err) }
  return err
}

func (p *ChannelDomain) Equals(other *ChannelDomain) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.Host != other.Host { return false }
  if p.Removed != other.Removed { return false }
  return true
}

func (p *ChannelDomain) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelDomain(%+v)", *p)
}

// Attributes:
//  - ChannelDomains
//  - Revision
type ChannelDomains struct {
  ChannelDomains []*ChannelDomain `thrift:"channelDomains,1" db:"channelDomains" json:"channelDomains"`
  Revision int64 `thrift:"revision,2" db:"revision" json:"revision"`
}

func NewChannelDomains() *ChannelDomains {
  return &ChannelDomains{}
}


func (p *ChannelDomains) GetChannelDomains() []*ChannelDomain {
  return p.ChannelDomains
}

func (p *ChannelDomains) GetRevision() int64 {
  return p.Revision
}
func (p *ChannelDomains) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelDomains)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ChannelDomain, 0, size)
  p.ChannelDomains =  tSlice
  for i := 0; i < size; i ++ {
    _elem5 := &ChannelDomain{}
    if err := _elem5.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem5), err)
    }
    p.ChannelDomains = append(p.ChannelDomains, _elem5)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelDomains)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Revision = v
}
  return nil
}

func (p *ChannelDomains) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelDomains"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelDomains) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelDomains", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelDomains: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.ChannelDomains)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.ChannelDomains {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelDomains: ", p), err) }
  return err
}

func (p *ChannelDomains) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "revision", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:revision: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.Revision)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.revision (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:revision: ", p), err) }
  return err
}

func (p *ChannelDomains) Equals(other *ChannelDomains) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if len(p.ChannelDomains) != len(other.ChannelDomains) { return false }
  for i, _tgt := range p.ChannelDomains {
    _src6 := other.ChannelDomains[i]
    if !_tgt.Equals(_src6) { return false }
  }
  if p.Revision != other.Revision { return false }
  return true
}

func (p *ChannelDomains) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelDomains(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - LastUpdated
type ChannelIdWithLastUpdated struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  LastUpdated int64 `thrift:"lastUpdated,2" db:"lastUpdated" json:"lastUpdated"`
}

func NewChannelIdWithLastUpdated() *ChannelIdWithLastUpdated {
  return &ChannelIdWithLastUpdated{}
}


func (p *ChannelIdWithLastUpdated) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelIdWithLastUpdated) GetLastUpdated() int64 {
  return p.LastUpdated
}
func (p *ChannelIdWithLastUpdated) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelIdWithLastUpdated)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelIdWithLastUpdated)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.LastUpdated = v
}
  return nil
}

func (p *ChannelIdWithLastUpdated) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelIdWithLastUpdated"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelIdWithLastUpdated) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelIdWithLastUpdated) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "lastUpdated", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:lastUpdated: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.LastUpdated)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.lastUpdated (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:lastUpdated: ", p), err) }
  return err
}

func (p *ChannelIdWithLastUpdated) Equals(other *ChannelIdWithLastUpdated) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ChannelId != other.ChannelId { return false }
  if p.LastUpdated != other.LastUpdated { return false }
  return true
}

func (p *ChannelIdWithLastUpdated) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelIdWithLastUpdated(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - Name
//  - EntryPageUrl
//  - DescriptionText
//  - Provider
//  - PublicType
//  - IconImage
//  - Permissions
//  - IconThumbnailImage
//  - ChannelConfigurations
//  - LcsAllApiUsable
//  - AllowedPermissions
//  - ChannelDomains
//  - UpdatedTimestamp
//  - FeatureLicenses
type ChannelInfo struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  // unused field # 2
  Name string `thrift:"name,3" db:"name" json:"name"`
  EntryPageUrl string `thrift:"entryPageUrl,4" db:"entryPageUrl" json:"entryPageUrl"`
  DescriptionText string `thrift:"descriptionText,5" db:"descriptionText" json:"descriptionText"`
  Provider *ChannelProvider `thrift:"provider,6" db:"provider" json:"provider"`
  PublicType PublicType `thrift:"publicType,7" db:"publicType" json:"publicType"`
  IconImage string `thrift:"iconImage,8" db:"iconImage" json:"iconImage"`
  Permissions []string `thrift:"permissions,9" db:"permissions" json:"permissions"`
  // unused field # 10
  IconThumbnailImage string `thrift:"iconThumbnailImage,11" db:"iconThumbnailImage" json:"iconThumbnailImage"`
  ChannelConfigurations []ChannelConfiguration `thrift:"channelConfigurations,12" db:"channelConfigurations" json:"channelConfigurations"`
  LcsAllApiUsable bool `thrift:"lcsAllApiUsable,13" db:"lcsAllApiUsable" json:"lcsAllApiUsable"`
  AllowedPermissions []ChannelAllowedPermission `thrift:"allowedPermissions,14" db:"allowedPermissions" json:"allowedPermissions"`
  ChannelDomains []*ChannelDomain `thrift:"channelDomains,15" db:"channelDomains" json:"channelDomains"`
  UpdatedTimestamp int64 `thrift:"updatedTimestamp,16" db:"updatedTimestamp" json:"updatedTimestamp"`
  FeatureLicenses []ChannelFeatureLicense `thrift:"featureLicenses,17" db:"featureLicenses" json:"featureLicenses"`
}

func NewChannelInfo() *ChannelInfo {
  return &ChannelInfo{}
}


func (p *ChannelInfo) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelInfo) GetName() string {
  return p.Name
}

func (p *ChannelInfo) GetEntryPageUrl() string {
  return p.EntryPageUrl
}

func (p *ChannelInfo) GetDescriptionText() string {
  return p.DescriptionText
}
var ChannelInfo_Provider_DEFAULT *ChannelProvider
func (p *ChannelInfo) GetProvider() *ChannelProvider {
  if !p.IsSetProvider() {
    return ChannelInfo_Provider_DEFAULT
  }
return p.Provider
}

func (p *ChannelInfo) GetPublicType() PublicType {
  return p.PublicType
}

func (p *ChannelInfo) GetIconImage() string {
  return p.IconImage
}

func (p *ChannelInfo) GetPermissions() []string {
  return p.Permissions
}

func (p *ChannelInfo) GetIconThumbnailImage() string {
  return p.IconThumbnailImage
}

func (p *ChannelInfo) GetChannelConfigurations() []ChannelConfiguration {
  return p.ChannelConfigurations
}

func (p *ChannelInfo) GetLcsAllApiUsable() bool {
  return p.LcsAllApiUsable
}

func (p *ChannelInfo) GetAllowedPermissions() []ChannelAllowedPermission {
  return p.AllowedPermissions
}

func (p *ChannelInfo) GetChannelDomains() []*ChannelDomain {
  return p.ChannelDomains
}

func (p *ChannelInfo) GetUpdatedTimestamp() int64 {
  return p.UpdatedTimestamp
}

func (p *ChannelInfo) GetFeatureLicenses() []ChannelFeatureLicense {
  return p.FeatureLicenses
}
func (p *ChannelInfo) IsSetProvider() bool {
  return p.Provider != nil
}

func (p *ChannelInfo) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 4:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField4(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 5:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField5(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 6:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField6(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 7:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField7(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 8:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField8(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 9:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField9(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 11:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField11(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 12:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField12(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 13:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField13(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 14:
      if fieldTypeId == thrift.SET {
        if err := p.ReadField14(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 15:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField15(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 16:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField16(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 17:
      if fieldTypeId == thrift.SET {
        if err := p.ReadField17(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelInfo)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Name = v
}
  return nil
}

func (p *ChannelInfo)  ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.EntryPageUrl = v
}
  return nil
}

func (p *ChannelInfo)  ReadField5(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.DescriptionText = v
}
  return nil
}

func (p *ChannelInfo)  ReadField6(ctx context.Context, iprot thrift.TProtocol) error {
  p.Provider = &ChannelProvider{}
  if err := p.Provider.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Provider), err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField7(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(ctx); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  temp := PublicType(v)
  p.PublicType = temp
}
  return nil
}

func (p *ChannelInfo)  ReadField8(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 8: ", err)
} else {
  p.IconImage = v
}
  return nil
}

func (p *ChannelInfo)  ReadField9(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]string, 0, size)
  p.Permissions =  tSlice
  for i := 0; i < size; i ++ {
var _elem7 string
    if v, err := iprot.ReadString(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _elem7 = v
}
    p.Permissions = append(p.Permissions, _elem7)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField11(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 11: ", err)
} else {
  p.IconThumbnailImage = v
}
  return nil
}

func (p *ChannelInfo)  ReadField12(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]ChannelConfiguration, 0, size)
  p.ChannelConfigurations =  tSlice
  for i := 0; i < size; i ++ {
var _elem8 ChannelConfiguration
    if v, err := iprot.ReadI32(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := ChannelConfiguration(v)
    _elem8 = temp
}
    p.ChannelConfigurations = append(p.ChannelConfigurations, _elem8)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField13(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 13: ", err)
} else {
  p.LcsAllApiUsable = v
}
  return nil
}

func (p *ChannelInfo)  ReadField14(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadSetBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading set begin: ", err)
  }
  tSet := make([]ChannelAllowedPermission, 0, size)
  p.AllowedPermissions =  tSet
  for i := 0; i < size; i ++ {
var _elem9 ChannelAllowedPermission
    if v, err := iprot.ReadI32(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := ChannelAllowedPermission(v)
    _elem9 = temp
}
    p.AllowedPermissions = append(p.AllowedPermissions, _elem9)
  }
  if err := iprot.ReadSetEnd(ctx); err != nil {
    return thrift.PrependError("error reading set end: ", err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField15(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ChannelDomain, 0, size)
  p.ChannelDomains =  tSlice
  for i := 0; i < size; i ++ {
    _elem10 := &ChannelDomain{}
    if err := _elem10.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem10), err)
    }
    p.ChannelDomains = append(p.ChannelDomains, _elem10)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelInfo)  ReadField16(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 16: ", err)
} else {
  p.UpdatedTimestamp = v
}
  return nil
}

func (p *ChannelInfo)  ReadField17(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadSetBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading set begin: ", err)
  }
  tSet := make([]ChannelFeatureLicense, 0, size)
  p.FeatureLicenses =  tSet
  for i := 0; i < size; i ++ {
var _elem11 ChannelFeatureLicense
    if v, err := iprot.ReadI32(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := ChannelFeatureLicense(v)
    _elem11 = temp
}
    p.FeatureLicenses = append(p.FeatureLicenses, _elem11)
  }
  if err := iprot.ReadSetEnd(ctx); err != nil {
    return thrift.PrependError("error reading set end: ", err)
  }
  return nil
}

func (p *ChannelInfo) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelInfo"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
    if err := p.writeField4(ctx, oprot); err != nil { return err }
    if err := p.writeField5(ctx, oprot); err != nil { return err }
    if err := p.writeField6(ctx, oprot); err != nil { return err }
    if err := p.writeField7(ctx, oprot); err != nil { return err }
    if err := p.writeField8(ctx, oprot); err != nil { return err }
    if err := p.writeField9(ctx, oprot); err != nil { return err }
    if err := p.writeField11(ctx, oprot); err != nil { return err }
    if err := p.writeField12(ctx, oprot); err != nil { return err }
    if err := p.writeField13(ctx, oprot); err != nil { return err }
    if err := p.writeField14(ctx, oprot); err != nil { return err }
    if err := p.writeField15(ctx, oprot); err != nil { return err }
    if err := p.writeField16(ctx, oprot); err != nil { return err }
    if err := p.writeField17(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelInfo) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "name", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:name: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Name)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.name (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:name: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "entryPageUrl", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:entryPageUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.EntryPageUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entryPageUrl (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:entryPageUrl: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField5(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "descriptionText", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:descriptionText: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.DescriptionText)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.descriptionText (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:descriptionText: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField6(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "provider", thrift.STRUCT, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:provider: ", p), err) }
  if err := p.Provider.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Provider), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:provider: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField7(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "publicType", thrift.I32, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:publicType: ", p), err) }
  if err := oprot.WriteI32(ctx, int32(p.PublicType)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.publicType (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:publicType: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField8(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "iconImage", thrift.STRING, 8); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:iconImage: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.IconImage)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.iconImage (8) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 8:iconImage: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField9(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "permissions", thrift.LIST, 9); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:permissions: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.Permissions)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Permissions {
    if err := oprot.WriteString(ctx, string(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 9:permissions: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField11(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "iconThumbnailImage", thrift.STRING, 11); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:iconThumbnailImage: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.IconThumbnailImage)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.iconThumbnailImage (11) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 11:iconThumbnailImage: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField12(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelConfigurations", thrift.LIST, 12); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 12:channelConfigurations: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.I32, len(p.ChannelConfigurations)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.ChannelConfigurations {
    if err := oprot.WriteI32(ctx, int32(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 12:channelConfigurations: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField13(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "lcsAllApiUsable", thrift.BOOL, 13); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 13:lcsAllApiUsable: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.LcsAllApiUsable)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.lcsAllApiUsable (13) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 13:lcsAllApiUsable: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField14(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "allowedPermissions", thrift.SET, 14); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 14:allowedPermissions: ", p), err) }
  if err := oprot.WriteSetBegin(ctx, thrift.I32, len(p.AllowedPermissions)); err != nil {
    return thrift.PrependError("error writing set begin: ", err)
  }
  for i := 0; i<len(p.AllowedPermissions); i++ {
    for j := i+1; j<len(p.AllowedPermissions); j++ {
      if func(tgt, src ChannelAllowedPermission) bool {
        if tgt != src { return false }
        return true
      }(p.AllowedPermissions[i], p.AllowedPermissions[j]) {
        return thrift.PrependError("", fmt.Errorf("%T error writing set field: slice is not unique", p.AllowedPermissions))
      }
    }
  }
  for _, v := range p.AllowedPermissions {
    if err := oprot.WriteI32(ctx, int32(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteSetEnd(ctx); err != nil {
    return thrift.PrependError("error writing set end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 14:allowedPermissions: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField15(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelDomains", thrift.LIST, 15); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 15:channelDomains: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.ChannelDomains)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.ChannelDomains {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 15:channelDomains: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField16(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "updatedTimestamp", thrift.I64, 16); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 16:updatedTimestamp: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.UpdatedTimestamp)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.updatedTimestamp (16) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 16:updatedTimestamp: ", p), err) }
  return err
}

func (p *ChannelInfo) writeField17(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "featureLicenses", thrift.SET, 17); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 17:featureLicenses: ", p), err) }
  if err := oprot.WriteSetBegin(ctx, thrift.I32, len(p.FeatureLicenses)); err != nil {
    return thrift.PrependError("error writing set begin: ", err)
  }
  for i := 0; i<len(p.FeatureLicenses); i++ {
    for j := i+1; j<len(p.FeatureLicenses); j++ {
      if func(tgt, src ChannelFeatureLicense) bool {
        if tgt != src { return false }
        return true
      }(p.FeatureLicenses[i], p.FeatureLicenses[j]) {
        return thrift.PrependError("", fmt.Errorf("%T error writing set field: slice is not unique", p.FeatureLicenses))
      }
    }
  }
  for _, v := range p.FeatureLicenses {
    if err := oprot.WriteI32(ctx, int32(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteSetEnd(ctx); err != nil {
    return thrift.PrependError("error writing set end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 17:featureLicenses: ", p), err) }
  return err
}

func (p *ChannelInfo) Equals(other *ChannelInfo) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ChannelId != other.ChannelId { return false }
  if p.Name != other.Name { return false }
  if p.EntryPageUrl != other.EntryPageUrl { return false }
  if p.DescriptionText != other.DescriptionText { return false }
  if !p.Provider.Equals(other.Provider) { return false }
  if p.PublicType != other.PublicType { return false }
  if p.IconImage != other.IconImage { return false }
  if len(p.Permissions) != len(other.Permissions) { return false }
  for i, _tgt := range p.Permissions {
    _src12 := other.Permissions[i]
    if _tgt != _src12 { return false }
  }
  if p.IconThumbnailImage != other.IconThumbnailImage { return false }
  if len(p.ChannelConfigurations) != len(other.ChannelConfigurations) { return false }
  for i, _tgt := range p.ChannelConfigurations {
    _src13 := other.ChannelConfigurations[i]
    if _tgt != _src13 { return false }
  }
  if p.LcsAllApiUsable != other.LcsAllApiUsable { return false }
  if len(p.AllowedPermissions) != len(other.AllowedPermissions) { return false }
  for i, _tgt := range p.AllowedPermissions {
    _src14 := other.AllowedPermissions[i]
    if _tgt != _src14 { return false }
  }
  if len(p.ChannelDomains) != len(other.ChannelDomains) { return false }
  for i, _tgt := range p.ChannelDomains {
    _src15 := other.ChannelDomains[i]
    if !_tgt.Equals(_src15) { return false }
  }
  if p.UpdatedTimestamp != other.UpdatedTimestamp { return false }
  if len(p.FeatureLicenses) != len(other.FeatureLicenses) { return false }
  for i, _tgt := range p.FeatureLicenses {
    _src16 := other.FeatureLicenses[i]
    if _tgt != _src16 { return false }
  }
  return true
}

func (p *ChannelInfo) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelInfo(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - Name
//  - NotificationReceivable
//  - MessageReceivable
//  - ShowDefault
type ChannelNotificationSetting struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  Name string `thrift:"name,2" db:"name" json:"name"`
  NotificationReceivable bool `thrift:"notificationReceivable,3" db:"notificationReceivable" json:"notificationReceivable"`
  MessageReceivable bool `thrift:"messageReceivable,4" db:"messageReceivable" json:"messageReceivable"`
  ShowDefault bool `thrift:"showDefault,5" db:"showDefault" json:"showDefault"`
}

func NewChannelNotificationSetting() *ChannelNotificationSetting {
  return &ChannelNotificationSetting{}
}


func (p *ChannelNotificationSetting) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelNotificationSetting) GetName() string {
  return p.Name
}

func (p *ChannelNotificationSetting) GetNotificationReceivable() bool {
  return p.NotificationReceivable
}

func (p *ChannelNotificationSetting) GetMessageReceivable() bool {
  return p.MessageReceivable
}

func (p *ChannelNotificationSetting) GetShowDefault() bool {
  return p.ShowDefault
}
func (p *ChannelNotificationSetting) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 4:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField4(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 5:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField5(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelNotificationSetting)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelNotificationSetting)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Name = v
}
  return nil
}

func (p *ChannelNotificationSetting)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.NotificationReceivable = v
}
  return nil
}

func (p *ChannelNotificationSetting)  ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.MessageReceivable = v
}
  return nil
}

func (p *ChannelNotificationSetting)  ReadField5(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.ShowDefault = v
}
  return nil
}

func (p *ChannelNotificationSetting) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelNotificationSetting"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
    if err := p.writeField4(ctx, oprot); err != nil { return err }
    if err := p.writeField5(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelNotificationSetting) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelNotificationSetting) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "name", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:name: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Name)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.name (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:name: ", p), err) }
  return err
}

func (p *ChannelNotificationSetting) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "notificationReceivable", thrift.BOOL, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:notificationReceivable: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.NotificationReceivable)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.notificationReceivable (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:notificationReceivable: ", p), err) }
  return err
}

func (p *ChannelNotificationSetting) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "messageReceivable", thrift.BOOL, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:messageReceivable: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.MessageReceivable)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.messageReceivable (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:messageReceivable: ", p), err) }
  return err
}

func (p *ChannelNotificationSetting) writeField5(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "showDefault", thrift.BOOL, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:showDefault: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.ShowDefault)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.showDefault (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:showDefault: ", p), err) }
  return err
}

func (p *ChannelNotificationSetting) Equals(other *ChannelNotificationSetting) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ChannelId != other.ChannelId { return false }
  if p.Name != other.Name { return false }
  if p.NotificationReceivable != other.NotificationReceivable { return false }
  if p.MessageReceivable != other.MessageReceivable { return false }
  if p.ShowDefault != other.ShowDefault { return false }
  return true
}

func (p *ChannelNotificationSetting) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelNotificationSetting(%+v)", *p)
}

// Attributes:
//  - Name
type ChannelProvider struct {
  Name string `thrift:"name,1" db:"name" json:"name"`
}

func NewChannelProvider() *ChannelProvider {
  return &ChannelProvider{}
}


func (p *ChannelProvider) GetName() string {
  return p.Name
}
func (p *ChannelProvider) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelProvider)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Name = v
}
  return nil
}

func (p *ChannelProvider) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelProvider"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelProvider) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "name", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Name)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.name (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err) }
  return err
}

func (p *ChannelProvider) Equals(other *ChannelProvider) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.Name != other.Name { return false }
  return true
}

func (p *ChannelProvider) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelProvider(%+v)", *p)
}

// Attributes:
//  - UnapprovedMessageReceivable
type ChannelSettings struct {
  UnapprovedMessageReceivable bool `thrift:"unapprovedMessageReceivable,1" db:"unapprovedMessageReceivable" json:"unapprovedMessageReceivable"`
}

func NewChannelSettings() *ChannelSettings {
  return &ChannelSettings{}
}


func (p *ChannelSettings) GetUnapprovedMessageReceivable() bool {
  return p.UnapprovedMessageReceivable
}
func (p *ChannelSettings) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelSettings)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.UnapprovedMessageReceivable = v
}
  return nil
}

func (p *ChannelSettings) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelSettings"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelSettings) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "unapprovedMessageReceivable", thrift.BOOL, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:unapprovedMessageReceivable: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.UnapprovedMessageReceivable)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.unapprovedMessageReceivable (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:unapprovedMessageReceivable: ", p), err) }
  return err
}

func (p *ChannelSettings) Equals(other *ChannelSettings) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.UnapprovedMessageReceivable != other.UnapprovedMessageReceivable { return false }
  return true
}

func (p *ChannelSettings) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelSettings(%+v)", *p)
}

// Attributes:
//  - Token
//  - ObsToken
//  - Expiration
//  - RefreshToken
//  - ChannelAccessToken
type ChannelToken struct {
  Token string `thrift:"token,1" db:"token" json:"token"`
  ObsToken string `thrift:"obsToken,2" db:"obsToken" json:"obsToken"`
  Expiration int64 `thrift:"expiration,3" db:"expiration" json:"expiration"`
  RefreshToken string `thrift:"refreshToken,4" db:"refreshToken" json:"refreshToken"`
  ChannelAccessToken string `thrift:"channelAccessToken,5" db:"channelAccessToken" json:"channelAccessToken"`
}

func NewChannelToken() *ChannelToken {
  return &ChannelToken{}
}


func (p *ChannelToken) GetToken() string {
  return p.Token
}

func (p *ChannelToken) GetObsToken() string {
  return p.ObsToken
}

func (p *ChannelToken) GetExpiration() int64 {
  return p.Expiration
}

func (p *ChannelToken) GetRefreshToken() string {
  return p.RefreshToken
}

func (p *ChannelToken) GetChannelAccessToken() string {
  return p.ChannelAccessToken
}
func (p *ChannelToken) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 4:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField4(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 5:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField5(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelToken)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Token = v
}
  return nil
}

func (p *ChannelToken)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ObsToken = v
}
  return nil
}

func (p *ChannelToken)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Expiration = v
}
  return nil
}

func (p *ChannelToken)  ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.RefreshToken = v
}
  return nil
}

func (p *ChannelToken)  ReadField5(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.ChannelAccessToken = v
}
  return nil
}

func (p *ChannelToken) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "ChannelToken"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
    if err := p.writeField4(ctx, oprot); err != nil { return err }
    if err := p.writeField5(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelToken) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "token", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:token: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Token)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.token (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:token: ", p), err) }
  return err
}

func (p *ChannelToken) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "obsToken", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:obsToken: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ObsToken)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.obsToken (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:obsToken: ", p), err) }
  return err
}

func (p *ChannelToken) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "expiration", thrift.I64, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:expiration: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.Expiration)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.expiration (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:expiration: ", p), err) }
  return err
}

func (p *ChannelToken) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "refreshToken", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:refreshToken: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.RefreshToken)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.refreshToken (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:refreshToken: ", p), err) }
  return err
}

func (p *ChannelToken) writeField5(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelAccessToken", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:channelAccessToken: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelAccessToken)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelAccessToken (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:channelAccessToken: ", p), err) }
  return err
}

func (p *ChannelToken) Equals(other *ChannelToken) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.Token != other.Token { return false }
  if p.ObsToken != other.ObsToken { return false }
  if p.Expiration != other.Expiration { return false }
  if p.RefreshToken != other.RefreshToken { return false }
  if p.ChannelAccessToken != other.ChannelAccessToken { return false }
  return true
}

func (p *ChannelToken) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelToken(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - ShopOrderId
//  - AppStoreCode
//  - Items
//  - Country
type CoinUseReservation struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  ShopOrderId string `thrift:"shopOrderId,2" db:"shopOrderId" json:"shopOrderId"`
  AppStoreCode AppStoreCode `thrift:"appStoreCode,3" db:"appStoreCode" json:"appStoreCode"`
  Items []*CoinUseReservationItem `thrift:"items,4" db:"items" json:"items"`
  Country string `thrift:"country,5" db:"country" json:"country"`
}

func NewCoinUseReservation() *CoinUseReservation {
  return &CoinUseReservation{}
}


func (p *CoinUseReservation) GetChannelId() string {
  return p.ChannelId
}

func (p *CoinUseReservation) GetShopOrderId() string {
  return p.ShopOrderId
}

func (p *CoinUseReservation) GetAppStoreCode() AppStoreCode {
  return p.AppStoreCode
}

func (p *CoinUseReservation) GetItems() []*CoinUseReservationItem {
  return p.Items
}

func (p *CoinUseReservation) GetCountry() string {
  return p.Country
}
func (p *CoinUseReservation) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 4:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField4(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 5:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField5(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *CoinUseReservation)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *CoinUseReservation)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ShopOrderId = v
}
  return nil
}

func (p *CoinUseReservation)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  temp := AppStoreCode(v)
  p.AppStoreCode = temp
}
  return nil
}

func (p *CoinUseReservation)  ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*CoinUseReservationItem, 0, size)
  p.Items =  tSlice
  for i := 0; i < size; i ++ {
    _elem17 := &CoinUseReservationItem{}
    if err := _elem17.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem17), err)
    }
    p.Items = append(p.Items, _elem17)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *CoinUseReservation)  ReadField5(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.Country = v
}
  return nil
}

func (p *CoinUseReservation) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "CoinUseReservation"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
    if err := p.writeField4(ctx, oprot); err != nil { return err }
    if err := p.writeField5(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *CoinUseReservation) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *CoinUseReservation) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "shopOrderId", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:shopOrderId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ShopOrderId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.shopOrderId (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:shopOrderId: ", p), err) }
  return err
}

func (p *CoinUseReservation) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "appStoreCode", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:appStoreCode: ", p), err) }
  if err := oprot.WriteI32(ctx, int32(p.AppStoreCode)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.appStoreCode (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:appStoreCode: ", p), err) }
  return err
}

func (p *CoinUseReservation) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "items", thrift.LIST, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:items: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.Items)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Items {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:items: ", p), err) }
  return err
}

func (p *CoinUseReservation) writeField5(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "country", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:country: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Country)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.country (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:country: ", p), err) }
  return err
}

func (p *CoinUseReservation) Equals(other *CoinUseReservation) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ChannelId != other.ChannelId { return false }
  if p.ShopOrderId != other.ShopOrderId { return false }
  if p.AppStoreCode != other.AppStoreCode { return false }
  if len(p.Items) != len(other.Items) { return false }
  for i, _tgt := range p.Items {
    _src18 := other.Items[i]
    if !_tgt.Equals(_src18) { return false }
  }
  if p.Country != other.Country { return false }
  return true
}

func (p *CoinUseReservation) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("CoinUseReservation(%+v)", *p)
}

// Attributes:
//  - ItemId
//  - ItemName
//  - Amount
type CoinUseReservationItem struct {
  ItemId string `thrift:"itemId,1" db:"itemId" json:"itemId"`
  ItemName string `thrift:"itemName,2" db:"itemName" json:"itemName"`
  Amount int32 `thrift:"amount,3" db:"amount" json:"amount"`
}

func NewCoinUseReservationItem() *CoinUseReservationItem {
  return &CoinUseReservationItem{}
}


func (p *CoinUseReservationItem) GetItemId() string {
  return p.ItemId
}

func (p *CoinUseReservationItem) GetItemName() string {
  return p.ItemName
}

func (p *CoinUseReservationItem) GetAmount() int32 {
  return p.Amount
}
func (p *CoinUseReservationItem) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *CoinUseReservationItem)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ItemId = v
}
  return nil
}

func (p *CoinUseReservationItem)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ItemName = v
}
  return nil
}

func (p *CoinUseReservationItem)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Amount = v
}
  return nil
}

func (p *CoinUseReservationItem) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "CoinUseReservationItem"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *CoinUseReservationItem) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "itemId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:itemId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ItemId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.itemId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:itemId: ", p), err) }
  return err
}

func (p *CoinUseReservationItem) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "itemName", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:itemName: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ItemName)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.itemName (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:itemName: ", p), err) }
  return err
}

func (p *CoinUseReservationItem) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "amount", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:amount: ", p), err) }
  if err := oprot.WriteI32(ctx, int32(p.Amount)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.amount (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:amount: ", p), err) }
  return err
}

func (p *CoinUseReservationItem) Equals(other *CoinUseReservationItem) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ItemId != other.ItemId { return false }
  if p.ItemName != other.ItemName { return false }
  if p.Amount != other.Amount { return false }
  return true
}

func (p *CoinUseReservationItem) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("CoinUseReservationItem(%+v)", *p)
}

// Attributes:
//  - RequestToken
//  - ReturnUrl
type RequestTokenResponse struct {
  RequestToken string `thrift:"requestToken,1" db:"requestToken" json:"requestToken"`
  ReturnUrl string `thrift:"returnUrl,2" db:"returnUrl" json:"returnUrl"`
}

func NewRequestTokenResponse() *RequestTokenResponse {
  return &RequestTokenResponse{}
}


func (p *RequestTokenResponse) GetRequestToken() string {
  return p.RequestToken
}

func (p *RequestTokenResponse) GetReturnUrl() string {
  return p.ReturnUrl
}
func (p *RequestTokenResponse) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *RequestTokenResponse)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.RequestToken = v
}
  return nil
}

func (p *RequestTokenResponse)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ReturnUrl = v
}
  return nil
}

func (p *RequestTokenResponse) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "RequestTokenResponse"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *RequestTokenResponse) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "requestToken", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:requestToken: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.RequestToken)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.requestToken (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:requestToken: ", p), err) }
  return err
}

func (p *RequestTokenResponse) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "returnUrl", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:returnUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ReturnUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.returnUrl (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:returnUrl: ", p), err) }
  return err
}

func (p *RequestTokenResponse) Equals(other *RequestTokenResponse) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.RequestToken != other.RequestToken { return false }
  if p.ReturnUrl != other.ReturnUrl { return false }
  return true
}

func (p *RequestTokenResponse) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("RequestTokenResponse(%+v)", *p)
}

// Attributes:
//  - HookedFullUrl
//  - SessionString
//  - FromIAB
type WebLoginRequest struct {
  HookedFullUrl string `thrift:"hookedFullUrl,1" db:"hookedFullUrl" json:"hookedFullUrl"`
  SessionString string `thrift:"sessionString,2" db:"sessionString" json:"sessionString"`
  FromIAB bool `thrift:"fromIAB,3" db:"fromIAB" json:"fromIAB"`
}

func NewWebLoginRequest() *WebLoginRequest {
  return &WebLoginRequest{}
}


func (p *WebLoginRequest) GetHookedFullUrl() string {
  return p.HookedFullUrl
}

func (p *WebLoginRequest) GetSessionString() string {
  return p.SessionString
}

func (p *WebLoginRequest) GetFromIAB() bool {
  return p.FromIAB
}
func (p *WebLoginRequest) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *WebLoginRequest)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.HookedFullUrl = v
}
  return nil
}

func (p *WebLoginRequest)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.SessionString = v
}
  return nil
}

func (p *WebLoginRequest)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.FromIAB = v
}
  return nil
}

func (p *WebLoginRequest) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "WebLoginRequest"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *WebLoginRequest) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "hookedFullUrl", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:hookedFullUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.HookedFullUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.hookedFullUrl (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:hookedFullUrl: ", p), err) }
  return err
}

func (p *WebLoginRequest) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "sessionString", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:sessionString: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.SessionString)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.sessionString (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:sessionString: ", p), err) }
  return err
}

func (p *WebLoginRequest) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "fromIAB", thrift.BOOL, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fromIAB: ", p), err) }
  if err := oprot.WriteBool(ctx, bool(p.FromIAB)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.fromIAB (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fromIAB: ", p), err) }
  return err
}

func (p *WebLoginRequest) Equals(other *WebLoginRequest) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.HookedFullUrl != other.HookedFullUrl { return false }
  if p.SessionString != other.SessionString { return false }
  if p.FromIAB != other.FromIAB { return false }
  return true
}

func (p *WebLoginRequest) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("WebLoginRequest(%+v)", *p)
}

// Attributes:
//  - ReturnUrl
//  - OptionalReturnUrl
type WebLoginResponse struct {
  ReturnUrl string `thrift:"returnUrl,1" db:"returnUrl" json:"returnUrl"`
  OptionalReturnUrl string `thrift:"optionalReturnUrl,2" db:"optionalReturnUrl" json:"optionalReturnUrl"`
}

func NewWebLoginResponse() *WebLoginResponse {
  return &WebLoginResponse{}
}


func (p *WebLoginResponse) GetReturnUrl() string {
  return p.ReturnUrl
}

func (p *WebLoginResponse) GetOptionalReturnUrl() string {
  return p.OptionalReturnUrl
}
func (p *WebLoginResponse) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *WebLoginResponse)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ReturnUrl = v
}
  return nil
}

func (p *WebLoginResponse)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.OptionalReturnUrl = v
}
  return nil
}

func (p *WebLoginResponse) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "WebLoginResponse"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *WebLoginResponse) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "returnUrl", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:returnUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ReturnUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.returnUrl (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:returnUrl: ", p), err) }
  return err
}

func (p *WebLoginResponse) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "optionalReturnUrl", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:optionalReturnUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.OptionalReturnUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.optionalReturnUrl (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:optionalReturnUrl: ", p), err) }
  return err
}

func (p *WebLoginResponse) Equals(other *WebLoginResponse) bool {
  if p == other {
    return true
  } else if p == nil || other == nil {
    return false
  }
  if p.ReturnUrl != other.ReturnUrl { return false }
  if p.OptionalReturnUrl != other.OptionalReturnUrl { return false }
  return true
}

func (p *WebLoginResponse) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("WebLoginResponse(%+v)", *p)
}

type ChannelService interface {
  // Parameters:
  //  - ChannelId
  ApproveChannelAndIssueChannelToken(ctx context.Context, channelId string) (_r *ChannelToken, _err error)
  // Parameters:
  //  - LastSynced
  //  - Locale
  GetApprovedChannels(ctx context.Context, lastSynced int64, locale string) (_r *ApprovedChannelInfos, _err error)
  // Parameters:
  //  - ChannelId
  //  - Locale
  GetChannelInfo(ctx context.Context, channelId string, locale string) (_r *ChannelInfo, _err error)
  // Parameters:
  //  - ChannelId
  //  - Locale
  GetChannelNotificationSetting(ctx context.Context, channelId string, locale string) (_r *ChannelNotificationSetting, _err error)
  // Parameters:
  //  - Locale
  GetChannelNotificationSettings(ctx context.Context, locale string) (_r []*ChannelNotificationSetting, _err error)
  GetChannelSettings(ctx context.Context) (_r *ChannelSettings, _err error)
  // Parameters:
  //  - LastSynced
  GetCommonDomains(ctx context.Context, lastSynced int64) (_r *ChannelDomains, _err error)
  // Parameters:
  //  - WebLoginRequest
  GetReturnUrlWithRequestTokenForAutoLogin(ctx context.Context, webLoginRequest *WebLoginRequest) (_r *WebLoginResponse, _err error)
  // Parameters:
  //  - ChannelIds
  GetUpdatedChannelIds(ctx context.Context, channelIds []*ChannelIdWithLastUpdated) (_r []string, _err error)
  // Parameters:
  //  - WebLoginRequest
  GetWebLoginDisallowedUrl(ctx context.Context, webLoginRequest *WebLoginRequest) (_r *WebLoginResponse, _err error)
  // Parameters:
  //  - ChannelId
  IssueChannelToken(ctx context.Context, channelId string) (_r *ChannelToken, _err error)
  // Parameters:
  //  - ChannelId
  //  - OtpId
  //  - AuthScheme
  //  - ReturnUrl
  IssueRequestTokenWithAuthScheme(ctx context.Context, channelId string, otpId string, authScheme []string, returnUrl string) (_r *RequestTokenResponse, _err error)
  // Parameters:
  //  - Request
  //  - Locale
  ReserveCoinUse(ctx context.Context, request *CoinUseReservation, locale string) (_r string, _err error)
  // Parameters:
  //  - ChannelId
  RevokeChannel(ctx context.Context, channelId string) (_err error)
  // Parameters:
  //  - Setting
  UpdateChannelNotificationSetting(ctx context.Context, setting []*ChannelNotificationSetting) (_err error)
  // Parameters:
  //  - ChannelSettings
  UpdateChannelSettings(ctx context.Context, channelSettings *ChannelSettings) (_r bool, _err error)
}

type ChannelServiceClient struct {
  c thrift.TClient
  meta thrift.ResponseMeta
}

func NewChannelServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ChannelServiceClient {
  return &ChannelServiceClient{
    c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)),
  }
}

func NewChannelServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ChannelServiceClient {
  return &ChannelServiceClient{
    c: thrift.NewTStandardClient(iprot, oprot),
  }
}

func NewChannelServiceClient(c thrift.TClient) *ChannelServiceClient {
  return &ChannelServiceClient{
    c: c,
  }
}

func (p *ChannelServiceClient) Client_() thrift.TClient {
  return p.c
}

func (p *ChannelServiceClient) LastResponseMeta_() thrift.ResponseMeta {
  return p.meta
}

func (p *ChannelServiceClient) SetLastResponseMeta_(meta thrift.ResponseMeta) {
  p.meta = meta
}

// Parameters:
//  - ChannelId
func (p *ChannelServiceClient) ApproveChannelAndIssueChannelToken(ctx context.Context, channelId string) (_r *ChannelToken, _err error) {
  var _args19 ChannelServiceApproveChannelAndIssueChannelTokenArgs
  _args19.ChannelId = channelId
  var _result21 ChannelServiceApproveChannelAndIssueChannelTokenResult
  var _meta20 thrift.ResponseMeta
  _meta20, _err = p.Client_().Call(ctx, "approveChannelAndIssueChannelToken", &_args19, &_result21)
  p.SetLastResponseMeta_(_meta20)
  if _err != nil {
    return
  }
  switch {
  case _result21.E!= nil:
    return _r, _result21.E
  }

  if _ret22 := _result21.GetSuccess(); _ret22 != nil {
    return _ret22, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "approveChannelAndIssueChannelToken failed: unknown result")
}

// Parameters:
//  - LastSynced
//  - Locale
func (p *ChannelServiceClient) GetApprovedChannels(ctx context.Context, lastSynced int64, locale string) (_r *ApprovedChannelInfos, _err error) {
  var _args23 ChannelServiceGetApprovedChannelsArgs
  _args23.LastSynced = lastSynced
  _args23.Locale = locale
  var _result25 ChannelServiceGetApprovedChannelsResult
  var _meta24 thrift.ResponseMeta
  _meta24, _err = p.Client_().Call(ctx, "getApprovedChannels", &_args23, &_result25)
  p.SetLastResponseMeta_(_meta24)
  if _err != nil {
    return
  }
  switch {
  case _result25.E!= nil:
    return _r, _result25.E
  }

  if _ret26 := _result25.GetSuccess(); _ret26 != nil {
    return _ret26, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getApprovedChannels failed: unknown result")
}

// Parameters:
//  - ChannelId
//  - Locale
func (p *ChannelServiceClient) GetChannelInfo(ctx context.Context, channelId string, locale string) (_r *ChannelInfo, _err error) {
  var _args27 ChannelServiceGetChannelInfoArgs
  _args27.ChannelId = channelId
  _args27.Locale = locale
  var _result29 ChannelServiceGetChannelInfoResult
  var _meta28 thrift.ResponseMeta
  _meta28, _err = p.Client_().Call(ctx, "getChannelInfo", &_args27, &_result29)
  p.SetLastResponseMeta_(_meta28)
  if _err != nil {
    return
  }
  switch {
  case _result29.E!= nil:
    return _r, _result29.E
  }

  if _ret30 := _result29.GetSuccess(); _ret30 != nil {
    return _ret30, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getChannelInfo failed: unknown result")
}

// Parameters:
//  - ChannelId
//  - Locale
func (p *ChannelServiceClient) GetChannelNotificationSetting(ctx context.Context, channelId string, locale string) (_r *ChannelNotificationSetting, _err error) {
  var _args31 ChannelServiceGetChannelNotificationSettingArgs
  _args31.ChannelId = channelId
  _args31.Locale = locale
  var _result33 ChannelServiceGetChannelNotificationSettingResult
  var _meta32 thrift.ResponseMeta
  _meta32, _err = p.Client_().Call(ctx, "getChannelNotificationSetting", &_args31, &_result33)
  p.SetLastResponseMeta_(_meta32)
  if _err != nil {
    return
  }
  switch {
  case _result33.E!= nil:
    return _r, _result33.E
  }

  if _ret34 := _result33.GetSuccess(); _ret34 != nil {
    return _ret34, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getChannelNotificationSetting failed: unknown result")
}

// Parameters:
//  - Locale
func (p *ChannelServiceClient) GetChannelNotificationSettings(ctx context.Context, locale string) (_r []*ChannelNotificationSetting, _err error) {
  var _args35 ChannelServiceGetChannelNotificationSettingsArgs
  _args35.Locale = locale
  var _result37 ChannelServiceGetChannelNotificationSettingsResult
  var _meta36 thrift.ResponseMeta
  _meta36, _err = p.Client_().Call(ctx, "getChannelNotificationSettings", &_args35, &_result37)
  p.SetLastResponseMeta_(_meta36)
  if _err != nil {
    return
  }
  switch {
  case _result37.E!= nil:
    return _r, _result37.E
  }

  return _result37.GetSuccess(), nil
}

func (p *ChannelServiceClient) GetChannelSettings(ctx context.Context) (_r *ChannelSettings, _err error) {
  var _args38 ChannelServiceGetChannelSettingsArgs
  var _result40 ChannelServiceGetChannelSettingsResult
  var _meta39 thrift.ResponseMeta
  _meta39, _err = p.Client_().Call(ctx, "getChannelSettings", &_args38, &_result40)
  p.SetLastResponseMeta_(_meta39)
  if _err != nil {
    return
  }
  switch {
  case _result40.E!= nil:
    return _r, _result40.E
  }

  if _ret41 := _result40.GetSuccess(); _ret41 != nil {
    return _ret41, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getChannelSettings failed: unknown result")
}

// Parameters:
//  - LastSynced
func (p *ChannelServiceClient) GetCommonDomains(ctx context.Context, lastSynced int64) (_r *ChannelDomains, _err error) {
  var _args42 ChannelServiceGetCommonDomainsArgs
  _args42.LastSynced = lastSynced
  var _result44 ChannelServiceGetCommonDomainsResult
  var _meta43 thrift.ResponseMeta
  _meta43, _err = p.Client_().Call(ctx, "getCommonDomains", &_args42, &_result44)
  p.SetLastResponseMeta_(_meta43)
  if _err != nil {
    return
  }
  switch {
  case _result44.E!= nil:
    return _r, _result44.E
  }

  if _ret45 := _result44.GetSuccess(); _ret45 != nil {
    return _ret45, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getCommonDomains failed: unknown result")
}

// Parameters:
//  - WebLoginRequest
func (p *ChannelServiceClient) GetReturnUrlWithRequestTokenForAutoLogin(ctx context.Context, webLoginRequest *WebLoginRequest) (_r *WebLoginResponse, _err error) {
  var _args46 ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs
  _args46.WebLoginRequest = webLoginRequest
  var _result48 ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult
  var _meta47 thrift.ResponseMeta
  _meta47, _err = p.Client_().Call(ctx, "getReturnUrlWithRequestTokenForAutoLogin", &_args46, &_result48)
  p.SetLastResponseMeta_(_meta47)
  if _err != nil {
    return
  }
  switch {
  case _result48.E!= nil:
    return _r, _result48.E
  }

  if _ret49 := _result48.GetSuccess(); _ret49 != nil {
    return _ret49, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getReturnUrlWithRequestTokenForAutoLogin failed: unknown result")
}

// Parameters:
//  - ChannelIds
func (p *ChannelServiceClient) GetUpdatedChannelIds(ctx context.Context, channelIds []*ChannelIdWithLastUpdated) (_r []string, _err error) {
  var _args50 ChannelServiceGetUpdatedChannelIdsArgs
  _args50.ChannelIds = channelIds
  var _result52 ChannelServiceGetUpdatedChannelIdsResult
  var _meta51 thrift.ResponseMeta
  _meta51, _err = p.Client_().Call(ctx, "getUpdatedChannelIds", &_args50, &_result52)
  p.SetLastResponseMeta_(_meta51)
  if _err != nil {
    return
  }
  switch {
  case _result52.E!= nil:
    return _r, _result52.E
  }

  return _result52.GetSuccess(), nil
}

// Parameters:
//  - WebLoginRequest
func (p *ChannelServiceClient) GetWebLoginDisallowedUrl(ctx context.Context, webLoginRequest *WebLoginRequest) (_r *WebLoginResponse, _err error) {
  var _args53 ChannelServiceGetWebLoginDisallowedUrlArgs
  _args53.WebLoginRequest = webLoginRequest
  var _result55 ChannelServiceGetWebLoginDisallowedUrlResult
  var _meta54 thrift.ResponseMeta
  _meta54, _err = p.Client_().Call(ctx, "getWebLoginDisallowedUrl", &_args53, &_result55)
  p.SetLastResponseMeta_(_meta54)
  if _err != nil {
    return
  }
  switch {
  case _result55.E!= nil:
    return _r, _result55.E
  }

  if _ret56 := _result55.GetSuccess(); _ret56 != nil {
    return _ret56, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getWebLoginDisallowedUrl failed: unknown result")
}

// Parameters:
//  - ChannelId
func (p *ChannelServiceClient) IssueChannelToken(ctx context.Context, channelId string) (_r *ChannelToken, _err error) {
  var _args57 ChannelServiceIssueChannelTokenArgs
  _args57.ChannelId = channelId
  var _result59 ChannelServiceIssueChannelTokenResult
  var _meta58 thrift.ResponseMeta
  _meta58, _err = p.Client_().Call(ctx, "issueChannelToken", &_args57, &_result59)
  p.SetLastResponseMeta_(_meta58)
  if _err != nil {
    return
  }
  switch {
  case _result59.E!= nil:
    return _r, _result59.E
  }

  if _ret60 := _result59.GetSuccess(); _ret60 != nil {
    return _ret60, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "issueChannelToken failed: unknown result")
}

// Parameters:
//  - ChannelId
//  - OtpId
//  - AuthScheme
//  - ReturnUrl
func (p *ChannelServiceClient) IssueRequestTokenWithAuthScheme(ctx context.Context, channelId string, otpId string, authScheme []string, returnUrl string) (_r *RequestTokenResponse, _err error) {
  var _args61 ChannelServiceIssueRequestTokenWithAuthSchemeArgs
  _args61.ChannelId = channelId
  _args61.OtpId = otpId
  _args61.AuthScheme = authScheme
  _args61.ReturnUrl = returnUrl
  var _result63 ChannelServiceIssueRequestTokenWithAuthSchemeResult
  var _meta62 thrift.ResponseMeta
  _meta62, _err = p.Client_().Call(ctx, "issueRequestTokenWithAuthScheme", &_args61, &_result63)
  p.SetLastResponseMeta_(_meta62)
  if _err != nil {
    return
  }
  switch {
  case _result63.E!= nil:
    return _r, _result63.E
  }

  if _ret64 := _result63.GetSuccess(); _ret64 != nil {
    return _ret64, nil
  }
  return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "issueRequestTokenWithAuthScheme failed: unknown result")
}

// Parameters:
//  - Request
//  - Locale
func (p *ChannelServiceClient) ReserveCoinUse(ctx context.Context, request *CoinUseReservation, locale string) (_r string, _err error) {
  var _args65 ChannelServiceReserveCoinUseArgs
  _args65.Request = request
  _args65.Locale = locale
  var _result67 ChannelServiceReserveCoinUseResult
  var _meta66 thrift.ResponseMeta
  _meta66, _err = p.Client_().Call(ctx, "reserveCoinUse", &_args65, &_result67)
  p.SetLastResponseMeta_(_meta66)
  if _err != nil {
    return
  }
  switch {
  case _result67.E!= nil:
    return _r, _result67.E
  }

  return _result67.GetSuccess(), nil
}

// Parameters:
//  - ChannelId
func (p *ChannelServiceClient) RevokeChannel(ctx context.Context, channelId string) (_err error) {
  var _args68 ChannelServiceRevokeChannelArgs
  _args68.ChannelId = channelId
  var _result70 ChannelServiceRevokeChannelResult
  var _meta69 thrift.ResponseMeta
  _meta69, _err = p.Client_().Call(ctx, "revokeChannel", &_args68, &_result70)
  p.SetLastResponseMeta_(_meta69)
  if _err != nil {
    return
  }
  switch {
  case _result70.E!= nil:
    return _result70.E
  }

  return nil
}

// Parameters:
//  - Setting
func (p *ChannelServiceClient) UpdateChannelNotificationSetting(ctx context.Context, setting []*ChannelNotificationSetting) (_err error) {
  var _args71 ChannelServiceUpdateChannelNotificationSettingArgs
  _args71.Setting = setting
  var _result73 ChannelServiceUpdateChannelNotificationSettingResult
  var _meta72 thrift.ResponseMeta
  _meta72, _err = p.Client_().Call(ctx, "updateChannelNotificationSetting", &_args71, &_result73)
  p.SetLastResponseMeta_(_meta72)
  if _err != nil {
    return
  }
  switch {
  case _result73.E!= nil:
    return _result73.E
  }

  return nil
}

// Parameters:
//  - ChannelSettings
func (p *ChannelServiceClient) UpdateChannelSettings(ctx context.Context, channelSettings *ChannelSettings) (_r bool, _err error) {
  var _args74 ChannelServiceUpdateChannelSettingsArgs
  _args74.ChannelSettings = channelSettings
  var _result76 ChannelServiceUpdateChannelSettingsResult
  var _meta75 thrift.ResponseMeta
  _meta75, _err = p.Client_().Call(ctx, "updateChannelSettings", &_args74, &_result76)
  p.SetLastResponseMeta_(_meta75)
  if _err != nil {
    return
  }
  switch {
  case _result76.E!= nil:
    return _r, _result76.E
  }

  return _result76.GetSuccess(), nil
}

type ChannelServiceProcessor struct {
  processorMap map[string]thrift.TProcessorFunction
  handler ChannelService
}

func (p *ChannelServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
  p.processorMap[key] = processor
}

func (p *ChannelServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
  processor, ok = p.processorMap[key]
  return processor, ok
}

func (p *ChannelServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
  return p.processorMap
}

func NewChannelServiceProcessor(handler ChannelService) *ChannelServiceProcessor {

  self77 := &ChannelServiceProcessor{handler:handler, processorMap:make(map[string]thrift.TProcessorFunction)}
  self77.processorMap["approveChannelAndIssueChannelToken"] = &channelServiceProcessorApproveChannelAndIssueChannelToken{handler:handler}
  self77.processorMap["getApprovedChannels"] = &channelServiceProcessorGetApprovedChannels{handler:handler}
  self77.processorMap["getChannelInfo"] = &channelServiceProcessorGetChannelInfo{handler:handler}
  self77.processorMap["getChannelNotificationSetting"] = &channelServiceProcessorGetChannelNotificationSetting{handler:handler}
  self77.processorMap["getChannelNotificationSettings"] = &channelServiceProcessorGetChannelNotificationSettings{handler:handler}
  self77.processorMap["getChannelSettings"] = &channelServiceProcessorGetChannelSettings{handler:handler}
  self77.processorMap["getCommonDomains"] = &channelServiceProcessorGetCommonDomains{handler:handler}
  self77.processorMap["getReturnUrlWithRequestTokenForAutoLogin"] = &channelServiceProcessorGetReturnUrlWithRequestTokenForAutoLogin{handler:handler}
  self77.processorMap["getUpdatedChannelIds"] = &channelServiceProcessorGetUpdatedChannelIds{handler:handler}
  self77.processorMap["getWebLoginDisallowedUrl"] = &channelServiceProcessorGetWebLoginDisallowedUrl{handler:handler}
  self77.processorMap["issueChannelToken"] = &channelServiceProcessorIssueChannelToken{handler:handler}
  self77.processorMap["issueRequestTokenWithAuthScheme"] = &channelServiceProcessorIssueRequestTokenWithAuthScheme{handler:handler}
  self77.processorMap["reserveCoinUse"] = &channelServiceProcessorReserveCoinUse{handler:handler}
  self77.processorMap["revokeChannel"] = &channelServiceProcessorRevokeChannel{handler:handler}
  self77.processorMap["updateChannelNotificationSetting"] = &channelServiceProcessorUpdateChannelNotificationSetting{handler:handler}
  self77.processorMap["updateChannelSettings"] = &channelServiceProcessorUpdateChannelSettings{handler:handler}
return self77
}

func (p *ChannelServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  name, _, seqId, err2 := iprot.ReadMessageBegin(ctx)
  if err2 != nil { return false, thrift.WrapTException(err2) }
  if processor, ok := p.GetProcessorFunction(name); ok {
    return processor.Process(ctx, seqId, iprot, oprot)
  }
  iprot.Skip(ctx, thrift.STRUCT)
  iprot.ReadMessageEnd(ctx)
  x78 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function " + name)
  oprot.WriteMessageBegin(ctx, name, thrift.EXCEPTION, seqId)
  x78.Write(ctx, oprot)
  oprot.WriteMessageEnd(ctx)
  oprot.Flush(ctx)
  return false, x78

}

type channelServiceProcessorApproveChannelAndIssueChannelToken struct {
  handler ChannelService
}

func (p *channelServiceProcessorApproveChannelAndIssueChannelToken) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceApproveChannelAndIssueChannelTokenArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "approveChannelAndIssueChannelToken", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceApproveChannelAndIssueChannelTokenResult{}
  var retval *ChannelToken
  if retval, err2 = p.handler.ApproveChannelAndIssueChannelToken(ctx, args.ChannelId); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing approveChannelAndIssueChannelToken: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "approveChannelAndIssueChannelToken", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "approveChannelAndIssueChannelToken", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetApprovedChannels struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetApprovedChannels) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetApprovedChannelsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getApprovedChannels", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetApprovedChannelsResult{}
  var retval *ApprovedChannelInfos
  if retval, err2 = p.handler.GetApprovedChannels(ctx, args.LastSynced, args.Locale); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getApprovedChannels: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getApprovedChannels", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getApprovedChannels", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetChannelInfo struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetChannelInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetChannelInfoArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelInfo", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetChannelInfoResult{}
  var retval *ChannelInfo
  if retval, err2 = p.handler.GetChannelInfo(ctx, args.ChannelId, args.Locale); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getChannelInfo: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelInfo", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getChannelInfo", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetChannelNotificationSetting struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetChannelNotificationSetting) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetChannelNotificationSettingArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelNotificationSetting", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetChannelNotificationSettingResult{}
  var retval *ChannelNotificationSetting
  if retval, err2 = p.handler.GetChannelNotificationSetting(ctx, args.ChannelId, args.Locale); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getChannelNotificationSetting: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelNotificationSetting", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getChannelNotificationSetting", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetChannelNotificationSettings struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetChannelNotificationSettings) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetChannelNotificationSettingsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelNotificationSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetChannelNotificationSettingsResult{}
  var retval []*ChannelNotificationSetting
  if retval, err2 = p.handler.GetChannelNotificationSettings(ctx, args.Locale); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getChannelNotificationSettings: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelNotificationSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getChannelNotificationSettings", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetChannelSettings struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetChannelSettings) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetChannelSettingsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetChannelSettingsResult{}
  var retval *ChannelSettings
  if retval, err2 = p.handler.GetChannelSettings(ctx); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getChannelSettings: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getChannelSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getChannelSettings", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetCommonDomains struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetCommonDomains) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetCommonDomainsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getCommonDomains", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetCommonDomainsResult{}
  var retval *ChannelDomains
  if retval, err2 = p.handler.GetCommonDomains(ctx, args.LastSynced); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getCommonDomains: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getCommonDomains", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getCommonDomains", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetReturnUrlWithRequestTokenForAutoLogin struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetReturnUrlWithRequestTokenForAutoLogin) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getReturnUrlWithRequestTokenForAutoLogin", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult{}
  var retval *WebLoginResponse
  if retval, err2 = p.handler.GetReturnUrlWithRequestTokenForAutoLogin(ctx, args.WebLoginRequest); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getReturnUrlWithRequestTokenForAutoLogin: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getReturnUrlWithRequestTokenForAutoLogin", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getReturnUrlWithRequestTokenForAutoLogin", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetUpdatedChannelIds struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetUpdatedChannelIds) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetUpdatedChannelIdsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getUpdatedChannelIds", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetUpdatedChannelIdsResult{}
  var retval []string
  if retval, err2 = p.handler.GetUpdatedChannelIds(ctx, args.ChannelIds); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getUpdatedChannelIds: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getUpdatedChannelIds", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getUpdatedChannelIds", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorGetWebLoginDisallowedUrl struct {
  handler ChannelService
}

func (p *channelServiceProcessorGetWebLoginDisallowedUrl) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceGetWebLoginDisallowedUrlArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "getWebLoginDisallowedUrl", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceGetWebLoginDisallowedUrlResult{}
  var retval *WebLoginResponse
  if retval, err2 = p.handler.GetWebLoginDisallowedUrl(ctx, args.WebLoginRequest); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWebLoginDisallowedUrl: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "getWebLoginDisallowedUrl", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "getWebLoginDisallowedUrl", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorIssueChannelToken struct {
  handler ChannelService
}

func (p *channelServiceProcessorIssueChannelToken) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceIssueChannelTokenArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "issueChannelToken", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceIssueChannelTokenResult{}
  var retval *ChannelToken
  if retval, err2 = p.handler.IssueChannelToken(ctx, args.ChannelId); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing issueChannelToken: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "issueChannelToken", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "issueChannelToken", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorIssueRequestTokenWithAuthScheme struct {
  handler ChannelService
}

func (p *channelServiceProcessorIssueRequestTokenWithAuthScheme) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceIssueRequestTokenWithAuthSchemeArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "issueRequestTokenWithAuthScheme", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceIssueRequestTokenWithAuthSchemeResult{}
  var retval *RequestTokenResponse
  if retval, err2 = p.handler.IssueRequestTokenWithAuthScheme(ctx, args.ChannelId, args.OtpId, args.AuthScheme, args.ReturnUrl); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing issueRequestTokenWithAuthScheme: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "issueRequestTokenWithAuthScheme", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "issueRequestTokenWithAuthScheme", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorReserveCoinUse struct {
  handler ChannelService
}

func (p *channelServiceProcessorReserveCoinUse) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceReserveCoinUseArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "reserveCoinUse", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceReserveCoinUseResult{}
  var retval string
  if retval, err2 = p.handler.ReserveCoinUse(ctx, args.Request, args.Locale); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing reserveCoinUse: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "reserveCoinUse", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = &retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "reserveCoinUse", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorRevokeChannel struct {
  handler ChannelService
}

func (p *channelServiceProcessorRevokeChannel) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceRevokeChannelArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "revokeChannel", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceRevokeChannelResult{}
  if err2 = p.handler.RevokeChannel(ctx, args.ChannelId); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing revokeChannel: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "revokeChannel", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "revokeChannel", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorUpdateChannelNotificationSetting struct {
  handler ChannelService
}

func (p *channelServiceProcessorUpdateChannelNotificationSetting) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceUpdateChannelNotificationSettingArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "updateChannelNotificationSetting", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceUpdateChannelNotificationSettingResult{}
  if err2 = p.handler.UpdateChannelNotificationSetting(ctx, args.Setting); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing updateChannelNotificationSetting: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "updateChannelNotificationSetting", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "updateChannelNotificationSetting", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}

type channelServiceProcessorUpdateChannelSettings struct {
  handler ChannelService
}

func (p *channelServiceProcessorUpdateChannelSettings) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := ChannelServiceUpdateChannelSettingsArgs{}
  var err2 error
  if err2 = args.Read(ctx, iprot); err2 != nil {
    iprot.ReadMessageEnd(ctx)
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
    oprot.WriteMessageBegin(ctx, "updateChannelSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return false, thrift.WrapTException(err2)
  }
  iprot.ReadMessageEnd(ctx)

  tickerCancel := func() {}
  // Start a goroutine to do server side connectivity check.
  if thrift.ServerConnectivityCheckInterval > 0 {
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    var tickerCtx context.Context
    tickerCtx, tickerCancel = context.WithCancel(context.Background())
    defer tickerCancel()
    go func(ctx context.Context, cancel context.CancelFunc) {
      ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
      defer ticker.Stop()
      for {
        select {
        case <-ctx.Done():
          return
        case <-ticker.C:
          if !iprot.Transport().IsOpen() {
            cancel()
            return
          }
        }
      }
    }(tickerCtx, cancel)
  }

  result := ChannelServiceUpdateChannelSettingsResult{}
  var retval bool
  if retval, err2 = p.handler.UpdateChannelSettings(ctx, args.ChannelSettings); err2 != nil {
    tickerCancel()
  switch v := err2.(type) {
    case *ChannelException:
  result.E = v
    default:
    if err2 == thrift.ErrAbandonRequest {
      return false, thrift.WrapTException(err2)
    }
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing updateChannelSettings: " + err2.Error())
    oprot.WriteMessageBegin(ctx, "updateChannelSettings", thrift.EXCEPTION, seqId)
    x.Write(ctx, oprot)
    oprot.WriteMessageEnd(ctx)
    oprot.Flush(ctx)
    return true, thrift.WrapTException(err2)
  }
  } else {
    result.Success = &retval
  }
  tickerCancel()
  if err2 = oprot.WriteMessageBegin(ctx, "updateChannelSettings", thrift.REPLY, seqId); err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
    err = thrift.WrapTException(err2)
  }
  if err != nil {
    return
  }
  return true, err
}


// HELPER FUNCTIONS AND STRUCTURES

// Attributes:
//  - ChannelId
type ChannelServiceApproveChannelAndIssueChannelTokenArgs struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
}

func NewChannelServiceApproveChannelAndIssueChannelTokenArgs() *ChannelServiceApproveChannelAndIssueChannelTokenArgs {
  return &ChannelServiceApproveChannelAndIssueChannelTokenArgs{}
}


func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs) GetChannelId() string {
  return p.ChannelId
}
func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "approveChannelAndIssueChannelToken_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceApproveChannelAndIssueChannelTokenArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceApproveChannelAndIssueChannelTokenResult struct {
  Success *ChannelToken `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceApproveChannelAndIssueChannelTokenResult() *ChannelServiceApproveChannelAndIssueChannelTokenResult {
  return &ChannelServiceApproveChannelAndIssueChannelTokenResult{}
}

var ChannelServiceApproveChannelAndIssueChannelTokenResult_Success_DEFAULT *ChannelToken
func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) GetSuccess() *ChannelToken {
  if !p.IsSetSuccess() {
    return ChannelServiceApproveChannelAndIssueChannelTokenResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceApproveChannelAndIssueChannelTokenResult_E_DEFAULT *ChannelException
func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceApproveChannelAndIssueChannelTokenResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelToken{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "approveChannelAndIssueChannelToken_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceApproveChannelAndIssueChannelTokenResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceApproveChannelAndIssueChannelTokenResult(%+v)", *p)
}

// Attributes:
//  - LastSynced
//  - Locale
type ChannelServiceGetApprovedChannelsArgs struct {
  // unused field # 1
  LastSynced int64 `thrift:"lastSynced,2" db:"lastSynced" json:"lastSynced"`
  Locale string `thrift:"locale,3" db:"locale" json:"locale"`
}

func NewChannelServiceGetApprovedChannelsArgs() *ChannelServiceGetApprovedChannelsArgs {
  return &ChannelServiceGetApprovedChannelsArgs{}
}


func (p *ChannelServiceGetApprovedChannelsArgs) GetLastSynced() int64 {
  return p.LastSynced
}

func (p *ChannelServiceGetApprovedChannelsArgs) GetLocale() string {
  return p.Locale
}
func (p *ChannelServiceGetApprovedChannelsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.LastSynced = v
}
  return nil
}

func (p *ChannelServiceGetApprovedChannelsArgs)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Locale = v
}
  return nil
}

func (p *ChannelServiceGetApprovedChannelsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getApprovedChannels_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "lastSynced", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:lastSynced: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.LastSynced)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.lastSynced (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:lastSynced: ", p), err) }
  return err
}

func (p *ChannelServiceGetApprovedChannelsArgs) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "locale", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:locale: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Locale)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.locale (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:locale: ", p), err) }
  return err
}

func (p *ChannelServiceGetApprovedChannelsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetApprovedChannelsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetApprovedChannelsResult struct {
  Success *ApprovedChannelInfos `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetApprovedChannelsResult() *ChannelServiceGetApprovedChannelsResult {
  return &ChannelServiceGetApprovedChannelsResult{}
}

var ChannelServiceGetApprovedChannelsResult_Success_DEFAULT *ApprovedChannelInfos
func (p *ChannelServiceGetApprovedChannelsResult) GetSuccess() *ApprovedChannelInfos {
  if !p.IsSetSuccess() {
    return ChannelServiceGetApprovedChannelsResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetApprovedChannelsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetApprovedChannelsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetApprovedChannelsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetApprovedChannelsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetApprovedChannelsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetApprovedChannelsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ApprovedChannelInfos{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getApprovedChannels_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetApprovedChannelsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetApprovedChannelsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetApprovedChannelsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetApprovedChannelsResult(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - Locale
type ChannelServiceGetChannelInfoArgs struct {
  // unused field # 1
  ChannelId string `thrift:"channelId,2" db:"channelId" json:"channelId"`
  Locale string `thrift:"locale,3" db:"locale" json:"locale"`
}

func NewChannelServiceGetChannelInfoArgs() *ChannelServiceGetChannelInfoArgs {
  return &ChannelServiceGetChannelInfoArgs{}
}


func (p *ChannelServiceGetChannelInfoArgs) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelServiceGetChannelInfoArgs) GetLocale() string {
  return p.Locale
}
func (p *ChannelServiceGetChannelInfoArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelInfoArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceGetChannelInfoArgs)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Locale = v
}
  return nil
}

func (p *ChannelServiceGetChannelInfoArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelInfo_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelInfoArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceGetChannelInfoArgs) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "locale", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:locale: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Locale)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.locale (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:locale: ", p), err) }
  return err
}

func (p *ChannelServiceGetChannelInfoArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelInfoArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetChannelInfoResult struct {
  Success *ChannelInfo `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetChannelInfoResult() *ChannelServiceGetChannelInfoResult {
  return &ChannelServiceGetChannelInfoResult{}
}

var ChannelServiceGetChannelInfoResult_Success_DEFAULT *ChannelInfo
func (p *ChannelServiceGetChannelInfoResult) GetSuccess() *ChannelInfo {
  if !p.IsSetSuccess() {
    return ChannelServiceGetChannelInfoResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetChannelInfoResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetChannelInfoResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetChannelInfoResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetChannelInfoResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetChannelInfoResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetChannelInfoResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelInfoResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelInfo{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelInfoResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelInfoResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelInfo_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelInfoResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelInfoResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelInfoResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelInfoResult(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - Locale
type ChannelServiceGetChannelNotificationSettingArgs struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  Locale string `thrift:"locale,2" db:"locale" json:"locale"`
}

func NewChannelServiceGetChannelNotificationSettingArgs() *ChannelServiceGetChannelNotificationSettingArgs {
  return &ChannelServiceGetChannelNotificationSettingArgs{}
}


func (p *ChannelServiceGetChannelNotificationSettingArgs) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelServiceGetChannelNotificationSettingArgs) GetLocale() string {
  return p.Locale
}
func (p *ChannelServiceGetChannelNotificationSettingArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Locale = v
}
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelNotificationSetting_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "locale", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:locale: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Locale)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.locale (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:locale: ", p), err) }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelNotificationSettingArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetChannelNotificationSettingResult struct {
  Success *ChannelNotificationSetting `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetChannelNotificationSettingResult() *ChannelServiceGetChannelNotificationSettingResult {
  return &ChannelServiceGetChannelNotificationSettingResult{}
}

var ChannelServiceGetChannelNotificationSettingResult_Success_DEFAULT *ChannelNotificationSetting
func (p *ChannelServiceGetChannelNotificationSettingResult) GetSuccess() *ChannelNotificationSetting {
  if !p.IsSetSuccess() {
    return ChannelServiceGetChannelNotificationSettingResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetChannelNotificationSettingResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetChannelNotificationSettingResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetChannelNotificationSettingResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetChannelNotificationSettingResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelNotificationSetting{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelNotificationSetting_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelNotificationSettingResult(%+v)", *p)
}

// Attributes:
//  - Locale
type ChannelServiceGetChannelNotificationSettingsArgs struct {
  Locale string `thrift:"locale,1" db:"locale" json:"locale"`
}

func NewChannelServiceGetChannelNotificationSettingsArgs() *ChannelServiceGetChannelNotificationSettingsArgs {
  return &ChannelServiceGetChannelNotificationSettingsArgs{}
}


func (p *ChannelServiceGetChannelNotificationSettingsArgs) GetLocale() string {
  return p.Locale
}
func (p *ChannelServiceGetChannelNotificationSettingsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Locale = v
}
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelNotificationSettings_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "locale", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:locale: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Locale)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.locale (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:locale: ", p), err) }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelNotificationSettingsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetChannelNotificationSettingsResult struct {
  Success []*ChannelNotificationSetting `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetChannelNotificationSettingsResult() *ChannelServiceGetChannelNotificationSettingsResult {
  return &ChannelServiceGetChannelNotificationSettingsResult{}
}

var ChannelServiceGetChannelNotificationSettingsResult_Success_DEFAULT []*ChannelNotificationSetting

func (p *ChannelServiceGetChannelNotificationSettingsResult) GetSuccess() []*ChannelNotificationSetting {
  return p.Success
}
var ChannelServiceGetChannelNotificationSettingsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetChannelNotificationSettingsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetChannelNotificationSettingsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetChannelNotificationSettingsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ChannelNotificationSetting, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
    _elem79 := &ChannelNotificationSetting{}
    if err := _elem79.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem79), err)
    }
    p.Success = append(p.Success, _elem79)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelNotificationSettings_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := v.Write(ctx, oprot); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
      }
    }
    if err := oprot.WriteListEnd(ctx); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelNotificationSettingsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelNotificationSettingsResult(%+v)", *p)
}

type ChannelServiceGetChannelSettingsArgs struct {
}

func NewChannelServiceGetChannelSettingsArgs() *ChannelServiceGetChannelSettingsArgs {
  return &ChannelServiceGetChannelSettingsArgs{}
}

func (p *ChannelServiceGetChannelSettingsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    if err := iprot.Skip(ctx, fieldTypeId); err != nil {
      return err
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelSettingsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelSettings_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelSettingsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelSettingsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetChannelSettingsResult struct {
  Success *ChannelSettings `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetChannelSettingsResult() *ChannelServiceGetChannelSettingsResult {
  return &ChannelServiceGetChannelSettingsResult{}
}

var ChannelServiceGetChannelSettingsResult_Success_DEFAULT *ChannelSettings
func (p *ChannelServiceGetChannelSettingsResult) GetSuccess() *ChannelSettings {
  if !p.IsSetSuccess() {
    return ChannelServiceGetChannelSettingsResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetChannelSettingsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetChannelSettingsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetChannelSettingsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetChannelSettingsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetChannelSettingsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetChannelSettingsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelSettingsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelSettings{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelSettingsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetChannelSettingsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getChannelSettings_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetChannelSettingsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelSettingsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetChannelSettingsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetChannelSettingsResult(%+v)", *p)
}

// Attributes:
//  - LastSynced
type ChannelServiceGetCommonDomainsArgs struct {
  LastSynced int64 `thrift:"lastSynced,1" db:"lastSynced" json:"lastSynced"`
}

func NewChannelServiceGetCommonDomainsArgs() *ChannelServiceGetCommonDomainsArgs {
  return &ChannelServiceGetCommonDomainsArgs{}
}


func (p *ChannelServiceGetCommonDomainsArgs) GetLastSynced() int64 {
  return p.LastSynced
}
func (p *ChannelServiceGetCommonDomainsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetCommonDomainsArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.LastSynced = v
}
  return nil
}

func (p *ChannelServiceGetCommonDomainsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getCommonDomains_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetCommonDomainsArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "lastSynced", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:lastSynced: ", p), err) }
  if err := oprot.WriteI64(ctx, int64(p.LastSynced)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.lastSynced (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:lastSynced: ", p), err) }
  return err
}

func (p *ChannelServiceGetCommonDomainsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetCommonDomainsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetCommonDomainsResult struct {
  Success *ChannelDomains `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetCommonDomainsResult() *ChannelServiceGetCommonDomainsResult {
  return &ChannelServiceGetCommonDomainsResult{}
}

var ChannelServiceGetCommonDomainsResult_Success_DEFAULT *ChannelDomains
func (p *ChannelServiceGetCommonDomainsResult) GetSuccess() *ChannelDomains {
  if !p.IsSetSuccess() {
    return ChannelServiceGetCommonDomainsResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetCommonDomainsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetCommonDomainsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetCommonDomainsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetCommonDomainsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetCommonDomainsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetCommonDomainsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetCommonDomainsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelDomains{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetCommonDomainsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetCommonDomainsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getCommonDomains_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetCommonDomainsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetCommonDomainsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetCommonDomainsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetCommonDomainsResult(%+v)", *p)
}

// Attributes:
//  - WebLoginRequest
type ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs struct {
  // unused field # 1
  WebLoginRequest *WebLoginRequest `thrift:"webLoginRequest,2" db:"webLoginRequest" json:"webLoginRequest"`
}

func NewChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs() *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs {
  return &ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs{}
}

var ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs_WebLoginRequest_DEFAULT *WebLoginRequest
func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) GetWebLoginRequest() *WebLoginRequest {
  if !p.IsSetWebLoginRequest() {
    return ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs_WebLoginRequest_DEFAULT
  }
return p.WebLoginRequest
}
func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) IsSetWebLoginRequest() bool {
  return p.WebLoginRequest != nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 2:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  p.WebLoginRequest = &WebLoginRequest{}
  if err := p.WebLoginRequest.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.WebLoginRequest), err)
  }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getReturnUrlWithRequestTokenForAutoLogin_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "webLoginRequest", thrift.STRUCT, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:webLoginRequest: ", p), err) }
  if err := p.WebLoginRequest.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.WebLoginRequest), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:webLoginRequest: ", p), err) }
  return err
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult struct {
  Success *WebLoginResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult() *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult {
  return &ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult{}
}

var ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult_Success_DEFAULT *WebLoginResponse
func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) GetSuccess() *WebLoginResponse {
  if !p.IsSetSuccess() {
    return ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &WebLoginResponse{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getReturnUrlWithRequestTokenForAutoLogin_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetReturnUrlWithRequestTokenForAutoLoginResult(%+v)", *p)
}

// Attributes:
//  - ChannelIds
type ChannelServiceGetUpdatedChannelIdsArgs struct {
  ChannelIds []*ChannelIdWithLastUpdated `thrift:"channelIds,1" db:"channelIds" json:"channelIds"`
}

func NewChannelServiceGetUpdatedChannelIdsArgs() *ChannelServiceGetUpdatedChannelIdsArgs {
  return &ChannelServiceGetUpdatedChannelIdsArgs{}
}


func (p *ChannelServiceGetUpdatedChannelIdsArgs) GetChannelIds() []*ChannelIdWithLastUpdated {
  return p.ChannelIds
}
func (p *ChannelServiceGetUpdatedChannelIdsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ChannelIdWithLastUpdated, 0, size)
  p.ChannelIds =  tSlice
  for i := 0; i < size; i ++ {
    _elem80 := &ChannelIdWithLastUpdated{}
    if err := _elem80.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem80), err)
    }
    p.ChannelIds = append(p.ChannelIds, _elem80)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getUpdatedChannelIds_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelIds", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelIds: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.ChannelIds)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.ChannelIds {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelIds: ", p), err) }
  return err
}

func (p *ChannelServiceGetUpdatedChannelIdsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetUpdatedChannelIdsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetUpdatedChannelIdsResult struct {
  Success []string `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetUpdatedChannelIdsResult() *ChannelServiceGetUpdatedChannelIdsResult {
  return &ChannelServiceGetUpdatedChannelIdsResult{}
}

var ChannelServiceGetUpdatedChannelIdsResult_Success_DEFAULT []string

func (p *ChannelServiceGetUpdatedChannelIdsResult) GetSuccess() []string {
  return p.Success
}
var ChannelServiceGetUpdatedChannelIdsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetUpdatedChannelIdsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetUpdatedChannelIdsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetUpdatedChannelIdsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]string, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem81 string
    if v, err := iprot.ReadString(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _elem81 = v
}
    p.Success = append(p.Success, _elem81)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getUpdatedChannelIds_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteString(ctx, string(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(ctx); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetUpdatedChannelIdsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetUpdatedChannelIdsResult(%+v)", *p)
}

// Attributes:
//  - WebLoginRequest
type ChannelServiceGetWebLoginDisallowedUrlArgs struct {
  // unused field # 1
  WebLoginRequest *WebLoginRequest `thrift:"webLoginRequest,2" db:"webLoginRequest" json:"webLoginRequest"`
}

func NewChannelServiceGetWebLoginDisallowedUrlArgs() *ChannelServiceGetWebLoginDisallowedUrlArgs {
  return &ChannelServiceGetWebLoginDisallowedUrlArgs{}
}

var ChannelServiceGetWebLoginDisallowedUrlArgs_WebLoginRequest_DEFAULT *WebLoginRequest
func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) GetWebLoginRequest() *WebLoginRequest {
  if !p.IsSetWebLoginRequest() {
    return ChannelServiceGetWebLoginDisallowedUrlArgs_WebLoginRequest_DEFAULT
  }
return p.WebLoginRequest
}
func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) IsSetWebLoginRequest() bool {
  return p.WebLoginRequest != nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 2:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  p.WebLoginRequest = &WebLoginRequest{}
  if err := p.WebLoginRequest.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.WebLoginRequest), err)
  }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getWebLoginDisallowedUrl_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField2(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "webLoginRequest", thrift.STRUCT, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:webLoginRequest: ", p), err) }
  if err := p.WebLoginRequest.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.WebLoginRequest), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:webLoginRequest: ", p), err) }
  return err
}

func (p *ChannelServiceGetWebLoginDisallowedUrlArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetWebLoginDisallowedUrlArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceGetWebLoginDisallowedUrlResult struct {
  Success *WebLoginResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceGetWebLoginDisallowedUrlResult() *ChannelServiceGetWebLoginDisallowedUrlResult {
  return &ChannelServiceGetWebLoginDisallowedUrlResult{}
}

var ChannelServiceGetWebLoginDisallowedUrlResult_Success_DEFAULT *WebLoginResponse
func (p *ChannelServiceGetWebLoginDisallowedUrlResult) GetSuccess() *WebLoginResponse {
  if !p.IsSetSuccess() {
    return ChannelServiceGetWebLoginDisallowedUrlResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceGetWebLoginDisallowedUrlResult_E_DEFAULT *ChannelException
func (p *ChannelServiceGetWebLoginDisallowedUrlResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceGetWebLoginDisallowedUrlResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceGetWebLoginDisallowedUrlResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &WebLoginResponse{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "getWebLoginDisallowedUrl_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceGetWebLoginDisallowedUrlResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceGetWebLoginDisallowedUrlResult(%+v)", *p)
}

// Attributes:
//  - ChannelId
type ChannelServiceIssueChannelTokenArgs struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
}

func NewChannelServiceIssueChannelTokenArgs() *ChannelServiceIssueChannelTokenArgs {
  return &ChannelServiceIssueChannelTokenArgs{}
}


func (p *ChannelServiceIssueChannelTokenArgs) GetChannelId() string {
  return p.ChannelId
}
func (p *ChannelServiceIssueChannelTokenArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceIssueChannelTokenArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceIssueChannelTokenArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "issueChannelToken_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceIssueChannelTokenArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceIssueChannelTokenArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceIssueChannelTokenArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceIssueChannelTokenResult struct {
  Success *ChannelToken `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceIssueChannelTokenResult() *ChannelServiceIssueChannelTokenResult {
  return &ChannelServiceIssueChannelTokenResult{}
}

var ChannelServiceIssueChannelTokenResult_Success_DEFAULT *ChannelToken
func (p *ChannelServiceIssueChannelTokenResult) GetSuccess() *ChannelToken {
  if !p.IsSetSuccess() {
    return ChannelServiceIssueChannelTokenResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceIssueChannelTokenResult_E_DEFAULT *ChannelException
func (p *ChannelServiceIssueChannelTokenResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceIssueChannelTokenResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceIssueChannelTokenResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceIssueChannelTokenResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceIssueChannelTokenResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceIssueChannelTokenResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &ChannelToken{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceIssueChannelTokenResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceIssueChannelTokenResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "issueChannelToken_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceIssueChannelTokenResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceIssueChannelTokenResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceIssueChannelTokenResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceIssueChannelTokenResult(%+v)", *p)
}

// Attributes:
//  - ChannelId
//  - OtpId
//  - AuthScheme
//  - ReturnUrl
type ChannelServiceIssueRequestTokenWithAuthSchemeArgs struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
  OtpId string `thrift:"otpId,2" db:"otpId" json:"otpId"`
  AuthScheme []string `thrift:"authScheme,3" db:"authScheme" json:"authScheme"`
  ReturnUrl string `thrift:"returnUrl,4" db:"returnUrl" json:"returnUrl"`
}

func NewChannelServiceIssueRequestTokenWithAuthSchemeArgs() *ChannelServiceIssueRequestTokenWithAuthSchemeArgs {
  return &ChannelServiceIssueRequestTokenWithAuthSchemeArgs{}
}


func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) GetChannelId() string {
  return p.ChannelId
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) GetOtpId() string {
  return p.OtpId
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) GetAuthScheme() []string {
  return p.AuthScheme
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) GetReturnUrl() string {
  return p.ReturnUrl
}
func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 4:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField4(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.OtpId = v
}
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]string, 0, size)
  p.AuthScheme =  tSlice
  for i := 0; i < size; i ++ {
var _elem82 string
    if v, err := iprot.ReadString(ctx); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _elem82 = v
}
    p.AuthScheme = append(p.AuthScheme, _elem82)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs)  ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.ReturnUrl = v
}
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "issueRequestTokenWithAuthScheme_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
    if err := p.writeField4(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "otpId", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:otpId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.OtpId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.otpId (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:otpId: ", p), err) }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "authScheme", thrift.LIST, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:authScheme: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.AuthScheme)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.AuthScheme {
    if err := oprot.WriteString(ctx, string(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:authScheme: ", p), err) }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "returnUrl", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:returnUrl: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ReturnUrl)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.returnUrl (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:returnUrl: ", p), err) }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceIssueRequestTokenWithAuthSchemeArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceIssueRequestTokenWithAuthSchemeResult struct {
  Success *RequestTokenResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceIssueRequestTokenWithAuthSchemeResult() *ChannelServiceIssueRequestTokenWithAuthSchemeResult {
  return &ChannelServiceIssueRequestTokenWithAuthSchemeResult{}
}

var ChannelServiceIssueRequestTokenWithAuthSchemeResult_Success_DEFAULT *RequestTokenResponse
func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) GetSuccess() *RequestTokenResponse {
  if !p.IsSetSuccess() {
    return ChannelServiceIssueRequestTokenWithAuthSchemeResult_Success_DEFAULT
  }
return p.Success
}
var ChannelServiceIssueRequestTokenWithAuthSchemeResult_E_DEFAULT *ChannelException
func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceIssueRequestTokenWithAuthSchemeResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  p.Success = &RequestTokenResponse{}
  if err := p.Success.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "issueRequestTokenWithAuthScheme_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceIssueRequestTokenWithAuthSchemeResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceIssueRequestTokenWithAuthSchemeResult(%+v)", *p)
}

// Attributes:
//  - Request
//  - Locale
type ChannelServiceReserveCoinUseArgs struct {
  // unused field # 1
  Request *CoinUseReservation `thrift:"request,2" db:"request" json:"request"`
  Locale string `thrift:"locale,3" db:"locale" json:"locale"`
}

func NewChannelServiceReserveCoinUseArgs() *ChannelServiceReserveCoinUseArgs {
  return &ChannelServiceReserveCoinUseArgs{}
}

var ChannelServiceReserveCoinUseArgs_Request_DEFAULT *CoinUseReservation
func (p *ChannelServiceReserveCoinUseArgs) GetRequest() *CoinUseReservation {
  if !p.IsSetRequest() {
    return ChannelServiceReserveCoinUseArgs_Request_DEFAULT
  }
return p.Request
}

func (p *ChannelServiceReserveCoinUseArgs) GetLocale() string {
  return p.Locale
}
func (p *ChannelServiceReserveCoinUseArgs) IsSetRequest() bool {
  return p.Request != nil
}

func (p *ChannelServiceReserveCoinUseArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 2:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField2(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField3(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceReserveCoinUseArgs)  ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
  p.Request = &CoinUseReservation{}
  if err := p.Request.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Request), err)
  }
  return nil
}

func (p *ChannelServiceReserveCoinUseArgs)  ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Locale = v
}
  return nil
}

func (p *ChannelServiceReserveCoinUseArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "reserveCoinUse_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField2(ctx, oprot); err != nil { return err }
    if err := p.writeField3(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceReserveCoinUseArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "request", thrift.STRUCT, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:request: ", p), err) }
  if err := p.Request.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Request), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:request: ", p), err) }
  return err
}

func (p *ChannelServiceReserveCoinUseArgs) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "locale", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:locale: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.Locale)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.locale (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:locale: ", p), err) }
  return err
}

func (p *ChannelServiceReserveCoinUseArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceReserveCoinUseArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceReserveCoinUseResult struct {
  Success *string `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceReserveCoinUseResult() *ChannelServiceReserveCoinUseResult {
  return &ChannelServiceReserveCoinUseResult{}
}

var ChannelServiceReserveCoinUseResult_Success_DEFAULT string
func (p *ChannelServiceReserveCoinUseResult) GetSuccess() string {
  if !p.IsSetSuccess() {
    return ChannelServiceReserveCoinUseResult_Success_DEFAULT
  }
return *p.Success
}
var ChannelServiceReserveCoinUseResult_E_DEFAULT *ChannelException
func (p *ChannelServiceReserveCoinUseResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceReserveCoinUseResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceReserveCoinUseResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceReserveCoinUseResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceReserveCoinUseResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceReserveCoinUseResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *ChannelServiceReserveCoinUseResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceReserveCoinUseResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "reserveCoinUse_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceReserveCoinUseResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRING, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteString(ctx, string(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceReserveCoinUseResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceReserveCoinUseResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceReserveCoinUseResult(%+v)", *p)
}

// Attributes:
//  - ChannelId
type ChannelServiceRevokeChannelArgs struct {
  ChannelId string `thrift:"channelId,1" db:"channelId" json:"channelId"`
}

func NewChannelServiceRevokeChannelArgs() *ChannelServiceRevokeChannelArgs {
  return &ChannelServiceRevokeChannelArgs{}
}


func (p *ChannelServiceRevokeChannelArgs) GetChannelId() string {
  return p.ChannelId
}
func (p *ChannelServiceRevokeChannelArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRING {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceRevokeChannelArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(ctx); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ChannelId = v
}
  return nil
}

func (p *ChannelServiceRevokeChannelArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "revokeChannel_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceRevokeChannelArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelId: ", p), err) }
  if err := oprot.WriteString(ctx, string(p.ChannelId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.channelId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelId: ", p), err) }
  return err
}

func (p *ChannelServiceRevokeChannelArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceRevokeChannelArgs(%+v)", *p)
}

// Attributes:
//  - E
type ChannelServiceRevokeChannelResult struct {
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceRevokeChannelResult() *ChannelServiceRevokeChannelResult {
  return &ChannelServiceRevokeChannelResult{}
}

var ChannelServiceRevokeChannelResult_E_DEFAULT *ChannelException
func (p *ChannelServiceRevokeChannelResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceRevokeChannelResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceRevokeChannelResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceRevokeChannelResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceRevokeChannelResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceRevokeChannelResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "revokeChannel_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceRevokeChannelResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceRevokeChannelResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceRevokeChannelResult(%+v)", *p)
}

// Attributes:
//  - Setting
type ChannelServiceUpdateChannelNotificationSettingArgs struct {
  Setting []*ChannelNotificationSetting `thrift:"setting,1" db:"setting" json:"setting"`
}

func NewChannelServiceUpdateChannelNotificationSettingArgs() *ChannelServiceUpdateChannelNotificationSettingArgs {
  return &ChannelServiceUpdateChannelNotificationSettingArgs{}
}


func (p *ChannelServiceUpdateChannelNotificationSettingArgs) GetSetting() []*ChannelNotificationSetting {
  return p.Setting
}
func (p *ChannelServiceUpdateChannelNotificationSettingArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin(ctx)
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*ChannelNotificationSetting, 0, size)
  p.Setting =  tSlice
  for i := 0; i < size; i ++ {
    _elem83 := &ChannelNotificationSetting{}
    if err := _elem83.Read(ctx, iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem83), err)
    }
    p.Setting = append(p.Setting, _elem83)
  }
  if err := iprot.ReadListEnd(ctx); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "updateChannelNotificationSetting_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "setting", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:setting: ", p), err) }
  if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.Setting)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Setting {
    if err := v.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(ctx); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:setting: ", p), err) }
  return err
}

func (p *ChannelServiceUpdateChannelNotificationSettingArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceUpdateChannelNotificationSettingArgs(%+v)", *p)
}

// Attributes:
//  - E
type ChannelServiceUpdateChannelNotificationSettingResult struct {
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceUpdateChannelNotificationSettingResult() *ChannelServiceUpdateChannelNotificationSettingResult {
  return &ChannelServiceUpdateChannelNotificationSettingResult{}
}

var ChannelServiceUpdateChannelNotificationSettingResult_E_DEFAULT *ChannelException
func (p *ChannelServiceUpdateChannelNotificationSettingResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceUpdateChannelNotificationSettingResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceUpdateChannelNotificationSettingResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "updateChannelNotificationSetting_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceUpdateChannelNotificationSettingResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceUpdateChannelNotificationSettingResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceUpdateChannelNotificationSettingResult(%+v)", *p)
}

// Attributes:
//  - ChannelSettings
type ChannelServiceUpdateChannelSettingsArgs struct {
  ChannelSettings *ChannelSettings `thrift:"channelSettings,1" db:"channelSettings" json:"channelSettings"`
}

func NewChannelServiceUpdateChannelSettingsArgs() *ChannelServiceUpdateChannelSettingsArgs {
  return &ChannelServiceUpdateChannelSettingsArgs{}
}

var ChannelServiceUpdateChannelSettingsArgs_ChannelSettings_DEFAULT *ChannelSettings
func (p *ChannelServiceUpdateChannelSettingsArgs) GetChannelSettings() *ChannelSettings {
  if !p.IsSetChannelSettings() {
    return ChannelServiceUpdateChannelSettingsArgs_ChannelSettings_DEFAULT
  }
return p.ChannelSettings
}
func (p *ChannelServiceUpdateChannelSettingsArgs) IsSetChannelSettings() bool {
  return p.ChannelSettings != nil
}

func (p *ChannelServiceUpdateChannelSettingsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsArgs)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.ChannelSettings = &ChannelSettings{}
  if err := p.ChannelSettings.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ChannelSettings), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "updateChannelSettings_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin(ctx, "channelSettings", thrift.STRUCT, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:channelSettings: ", p), err) }
  if err := p.ChannelSettings.Write(ctx, oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ChannelSettings), err)
  }
  if err := oprot.WriteFieldEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:channelSettings: ", p), err) }
  return err
}

func (p *ChannelServiceUpdateChannelSettingsArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceUpdateChannelSettingsArgs(%+v)", *p)
}

// Attributes:
//  - Success
//  - E
type ChannelServiceUpdateChannelSettingsResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
  E *ChannelException `thrift:"e,1" db:"e" json:"e,omitempty"`
}

func NewChannelServiceUpdateChannelSettingsResult() *ChannelServiceUpdateChannelSettingsResult {
  return &ChannelServiceUpdateChannelSettingsResult{}
}

var ChannelServiceUpdateChannelSettingsResult_Success_DEFAULT bool
func (p *ChannelServiceUpdateChannelSettingsResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return ChannelServiceUpdateChannelSettingsResult_Success_DEFAULT
  }
return *p.Success
}
var ChannelServiceUpdateChannelSettingsResult_E_DEFAULT *ChannelException
func (p *ChannelServiceUpdateChannelSettingsResult) GetE() *ChannelException {
  if !p.IsSetE() {
    return ChannelServiceUpdateChannelSettingsResult_E_DEFAULT
  }
return p.E
}
func (p *ChannelServiceUpdateChannelSettingsResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *ChannelServiceUpdateChannelSettingsResult) IsSetE() bool {
  return p.E != nil
}

func (p *ChannelServiceUpdateChannelSettingsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    case 1:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField1(ctx, iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(ctx, fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(ctx); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(ctx); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsResult)  ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(ctx); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsResult)  ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
  p.E = &ChannelException{}
  if err := p.E.Read(ctx, iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.E), err)
  }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin(ctx, "updateChannelSettings_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(ctx, oprot); err != nil { return err }
    if err := p.writeField1(ctx, oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(ctx); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(ctx); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ChannelServiceUpdateChannelSettingsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin(ctx, "success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(ctx, bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *ChannelServiceUpdateChannelSettingsResult) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
  if p.IsSetE() {
    if err := oprot.WriteFieldBegin(ctx, "e", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:e: ", p), err) }
    if err := p.E.Write(ctx, oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.E), err)
    }
    if err := oprot.WriteFieldEnd(ctx); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:e: ", p), err) }
  }
  return err
}

func (p *ChannelServiceUpdateChannelSettingsResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ChannelServiceUpdateChannelSettingsResult(%+v)", *p)
}