MutableProgram

abstract def clear(): Unit

abstract def constants: Seq[Const]

abstract def constantsIsSet: Boolean

abstract def constantsOption: Option[Seq[Const]]

abstract def constantsOrDefault: Seq[Const]

abstract def constantsOrNull: Seq[Const]

abstract def constantsOrThrow: Seq[Const]

abstract def constantsUnset(): Unit

abstract def constants_=(x: Seq[Const]): Unit

abstract def copy(namespaces: Seq[Namespace] = namespacesOrNull, includes: Seq[Include] = includesOrNull, constants: Seq[Const] = constantsOrNull, enums: Seq[Enum] = enumsOrNull, typedefs: Seq[Typedef] = typedefsOrNull, structs: Seq[Struct] = structsOrNull, unions: Seq[Union] = unionsOrNull, exceptions: Seq[Exception] = exceptionsOrNull, services: Seq[Service] = servicesOrNull, typeRegistry: TypeRegistry = typeRegistryOrNull): Mutable

abstract def deepCopy(): Program

abstract def enums: Seq[Enum]

abstract def enumsIsSet: Boolean

abstract def enumsOption: Option[Seq[Enum]]

abstract def enumsOrDefault: Seq[Enum]

abstract def enumsOrNull: Seq[Enum]

abstract def enumsOrThrow: Seq[Enum]

abstract def enumsUnset(): Unit

abstract def enums_=(x: Seq[Enum]): Unit

abstract def exceptions: Seq[Exception]

abstract def exceptionsIsSet: Boolean

abstract def exceptionsOption: Option[Seq[Exception]]

abstract def exceptionsOrDefault: Seq[Exception]

abstract def exceptionsOrNull: Seq[Exception]

abstract def exceptionsOrThrow: Seq[Exception]

abstract def exceptionsUnset(): Unit

abstract def exceptions_=(x: Seq[Exception]): Unit

abstract def fieldForId(arg0: Int): _Fields

abstract def getFieldValue(arg0: _Fields): AnyRef

abstract def includes: Seq[Include]

abstract def includesIsSet: Boolean

abstract def includesOption: Option[Seq[Include]]

abstract def includesOrDefault: Seq[Include]

abstract def includesOrNull: Seq[Include]

abstract def includesOrThrow: Seq[Include]

abstract def includesUnset(): Unit

abstract def includes_=(x: Seq[Include]): Unit

abstract def isSet(arg0: _Fields): Boolean

abstract def merge(that: Program): Unit

abstract def mergeCopy(that: Program): Program

abstract def meta: MetaT

abstract def namespaces: Seq[Namespace]

abstract def namespacesIsSet: Boolean

abstract def namespacesOption: Option[Seq[Namespace]]

abstract def namespacesOrDefault: Seq[Namespace]

abstract def namespacesOrNull: Seq[Namespace]

abstract def namespacesOrThrow: Seq[Namespace]

abstract def namespacesUnset(): Unit

abstract def namespaces_=(x: Seq[Namespace]): Unit

abstract def read(arg0: TProtocol): Unit

abstract def services: Seq[Service]

abstract def servicesIsSet: Boolean

abstract def servicesOption: Option[Seq[Service]]

abstract def servicesOrDefault: Seq[Service]

abstract def servicesOrNull: Seq[Service]

abstract def servicesOrThrow: Seq[Service]

abstract def servicesUnset(): Unit

abstract def services_=(x: Seq[Service]): Unit

abstract def setFieldValue(arg0: _Fields, arg1: Any): Unit

abstract def structs: Seq[Struct]

abstract def structsIsSet: Boolean

abstract def structsOption: Option[Seq[Struct]]

abstract def structsOrDefault: Seq[Struct]

abstract def structsOrNull: Seq[Struct]

abstract def structsOrThrow: Seq[Struct]

abstract def structsUnset(): Unit

abstract def structs_=(x: Seq[Struct]): Unit

abstract def typeRegistry: TypeRegistry

abstract def typeRegistryIsSet: Boolean

abstract def typeRegistryOption: Option[TypeRegistry]

abstract def typeRegistryOrNull: TypeRegistry

abstract def typeRegistryOrThrow: TypeRegistry

abstract def typeRegistryUnset(): Unit

abstract def typeRegistry_=(x: TypeRegistry): Unit

abstract def typedefs: Seq[Typedef]

abstract def typedefsIsSet: Boolean

abstract def typedefsOption: Option[Seq[Typedef]]

abstract def typedefsOrDefault: Seq[Typedef]

abstract def typedefsOrNull: Seq[Typedef]

abstract def typedefsOrThrow: Seq[Typedef]

abstract def typedefsUnset(): Unit

abstract def typedefs_=(x: Seq[Typedef]): Unit

abstract def unions: Seq[Union]

abstract def unionsIsSet: Boolean

abstract def unionsOption: Option[Seq[Union]]

abstract def unionsOrDefault: Seq[Union]

abstract def unionsOrNull: Seq[Union]

abstract def unionsOrThrow: Seq[Union]

abstract def unionsUnset(): Unit

abstract def unions_=(x: Seq[Union]): Unit

abstract def write(oprot: TProtocol): Unit

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def <(that: Program): Boolean

def <=(that: Program): Boolean

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def >(that: Program): Boolean

def >=(that: Program): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compare(that: Program): Int

def compareTo(that: Program): Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mutable: Mutable

Returns a pointer to a Mutable version of this record.

def mutableCopy(): Mutable

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toBuilder(): AllSpecified

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit