codegen

type AssetProvider interface {
	// AssetNames returns a list of named assets available
	AssetNames() []string
	// Asset returns the bytes for a provided asset name
	Asset(string) ([]byte, error)
}

type BodyType string

type BuildGenerator interface {
	Generate(
		instance *ModuleInstance,
	) (*BuildResult, error)
}

type BuildResult struct {
	// Files contains a map of file names to file bytes to be written to the
	// module build directory
	Files map[string][]byte
	// Spec is an arbitrary type that can be used to share computed data
	// between dependencies
	Spec interface{}
}

type ClassConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	// Dependencies is a map of class name to a list of instance names. This
	// infers the dependencies struct generated for the initializer
	Dependencies map[string][]string `yaml:"dependencies" json:"dependencies"`
	// The configuration map for this class instance. This depends on the
	// class name and class type, and is interpreted by each module generator.
	Config map[string]interface{} `yaml:"config" json:"config"`
}

type ClassConfigBase struct {
	// Name is the class instance name used to identify the module as a
	// dependency. The combination of the class Name and this instance name
	// is unique.
	Name string `yaml:"name" json:"name"`
	// Type refers to the class type used to generate the dependency
	Type string `yaml:"type" json:"type"`
	// IsExportGenerated determines whether or not the export lives in
	// IsExportGenerated defaults to true if not set.
	IsExportGenerated *bool `yaml:"IsExportGenerated,omitempty" json:"IsExportGenerated"`
	// CustomInitialisation defaults to false if not set.
	CustomInitialisation *bool `yaml:"CustomInitialisation,omitempty" json:"CustomInitialisation"`
	// Owner is the Name of the class instance owner
	Owner string `yaml:"owner,omitempty"`
	// SelectiveBuilding allows the module to be built with subset of dependencies
	SelectiveBuilding bool `yaml:"selectiveBuilding,omitempty" json:"selectiveBuilding"`
}

type ClientIDLConfig struct {
	ExposedMethods  map[string]string `yaml:"exposedMethods" json:"exposedMethods" validate:"exposedMethods"`
	IDLFile         string            `yaml:"idlFile" json:"idlFile" validate:"nonzero"`
	IDLFileSha      string            `yaml:"idlFileSha,omitempty" json:"idlFileSha"`
	SidecarRouter   string            `yaml:"sidecarRouter" json:"sidecarRouter"`
	Fixture         *Fixture          `yaml:"fixture,omitempty" json:"fixture"`
	CustomInterface string            `yaml:"customInterface,omitempty" json:"customInterface,omitempty"`
}

type ClientMeta struct {
	Instance         *ModuleInstance
	ExportName       string
	ExportType       string
	ClientID         string
	IncludedPackages []GoPackageImport
	Services         []*ServiceSpec
	ProtoServices    []*ProtoService
	ExposedMethods   map[string]string
	// client-method name to qps level (string)
	// if not qps level for method value is "default"
	QPSLevels       map[string]string
	SidecarRouter   string
	Fixture         *Fixture
	DeputyReqHeader string
}

type ClientSpec struct {
	// ModuleSpec holds the thrift module information
	ModuleSpec *ModuleSpec
	// JSONFile for this spec
	JSONFile string // Deprecated
	// YAMLFile for this spec
	YAMLFile string
	// ClientType, currently "http", "tchannel" and "custom" are supported
	ClientType string
	// If "custom" then where to import custom code from
	CustomImportPath string
	// If "custom" then this is where the interface to mock comes from
	CustomInterface string
	// The path to the client package import
	ImportPackagePath string
	// The globally unique package alias for the import
	ImportPackageAlias string
	// ExportName is the name that should be used when initializing the module
	// on a dependency struct.
	ExportName string
	// ExportType refers to the type returned by the module initializer
	ExportType string
	// ThriftFile, absolute path to thrift file
	ThriftFile string
	// ClientID, used for logging and metrics, must be lowercase
	// and use dashes.
	ClientID string
	// ClientName, PascalCase name of the client, the generated
	// `Clients` struct will contain a field of this name
	ClientName string
	// ExposedMethods is a map of exposed method name to thrift "$service::$method"
	// only the method values in this map are generated for the client
	ExposedMethods map[string]string
	// SidecarRouter indicates the client uses the given sidecar router to
	// to communicate with downstream service, it's not relevant to custom clients.
	SidecarRouter string
}

type ClientTestFixture struct {
	ClientID         string          `yaml:"clientId" json:"clientId"`
	ClientMethod     string          `yaml:"clientMethod" json:"clientMethod"`
	ClientRequest    FixtureRequest  `yaml:"clientRequest" json:"clientRequest"` // there's no difference between http or tchannel request
	ClientReqHeaders FixtureHeaders  `yaml:"clientReqHeaders" json:"clientReqHeaders"`
	ClientResponse   FixtureResponse `yaml:"clientResponse" json:"clientResponse"`
	ClientResHeaders FixtureHeaders  `yaml:"clientResHeaders" json:"clientResHeaders"`
}

type CustomClientConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    Dependencies `yaml:"dependencies" json:"dependencies"`
	Config          *struct {
		Fixture          *Fixture `yaml:"fixture" json:"fixture"`
		CustomImportPath string   `yaml:"customImportPath" json:"customImportPath" validate:"nonzero"`
		CustomInterface  string   `yaml:"customInterface,omitempty" json:"customInterface,omitempty"`
	} `yaml:"config" json:"config" validate:"nonzero"`
}

type Dependencies struct {
	Client []string `yaml:"client" json:"client"`
}

type EndpointClassConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    map[string][]string `yaml:"dependencies" json:"dependencies"`
	Config          *EndpointConfig     `yaml:"config" json:"config" validate:"nonzero"`
}

type EndpointCollectionMeta struct {
	Instance     *ModuleInstance
	EndpointMeta []*EndpointMeta
}

type EndpointConfig struct {
	Ratelimit int32    `yaml:"rateLimit,omitempty" json:"rateLimit"`
	Endpoints []string `yaml:"endpoints" json:"endpoints"`
}

type EndpointGenerator struct {
	// contains filtered or unexported fields
}

type EndpointMeta struct {
	Instance               *ModuleInstance
	Spec                   *EndpointSpec
	GatewayPackageName     string
	IncludedPackages       []GoPackageImport
	Method                 *MethodSpec
	ClientName             string
	ClientID               string
	ClientType             string
	ClientMethodName       string
	WorkflowPkg            string
	ReqHeaders             map[string]*TypedHeader
	IsClientlessEndpoint   bool
	ReqHeadersKeys         []string
	ReqRequiredHeadersKeys []string
	ResHeaders             map[string]*TypedHeader
	ResHeadersKeys         []string
	ResRequiredHeadersKeys []string
	TraceKey               string
	DeputyReqHeader        string
	DefaultHeaders         []string
}

type EndpointSpec struct {
	// ModuleSpec holds the thrift module info
	ModuleSpec *ModuleSpec `yaml:"-"`
	// YAMLFile for this endpoint spec
	YAMLFile string `yaml:"-"`
	// GoStructsFileName is where structs are generated
	GoStructsFileName string `yaml:"-"`
	// GoFolderName is the folder where all the endpoints
	// are generated.
	GoFolderName string `yaml:"-"`
	// GoPackageName is the package import path.
	GoPackageName string `yaml:"-"`

	// EndpointType, currently only "http"
	EndpointType string `yaml:"endpointType" validate:"nonzero"`
	// EndpointID, used in metrics and logging, lower case.
	EndpointID string `yaml:"endpointId" validate:"nonzero"`
	// HandleID, used in metrics and logging, lowercase.
	HandleID string `yaml:"handleId" validate:"nonzero"`
	// ThriftFile, the thrift file for this endpoint
	ThriftFile string `yaml:"thriftFile" validate:"nonzero"`
	// ThriftFileSha, the SHA of the thrift file for this endpoint
	ThriftFileSha string `yaml:"thriftFileSha,omitempty"`
	// ThriftMethodName, which thrift method to use.
	ThriftMethodName string `yaml:"thriftMethodName" validate:"nonzero"`
	// ThriftServiceName, which thrift service to use.
	ThriftServiceName string `yaml:"-"`
	// TestFixtures, meta data to generate tests,
	TestFixtures map[string]*EndpointTestFixture `yaml:"testFixtures,omitempty"`
	// Middlewares, meta data to add middlewares,
	Middlewares []MiddlewareSpec `yaml:"middlewares,omitempty"`
	// HeadersPropagate, a map from endpoint request headers to
	// client request fields.
	HeadersPropagate map[string]FieldMapperEntry `yaml:"-"`
	// ReqTransforms, a map from client request fields to endpoint
	// request fields that should override their values.
	ReqTransforms map[string]FieldMapperEntry `yaml:"-"`
	// RespTransforms, a map from endpoint response fields to client
	// response fields that should override their values.
	RespTransforms map[string]FieldMapperEntry `yaml:"-"`
	// DummyReqTransforms is used to transform a clientless request to response mapping
	DummyReqTransforms map[string]FieldMapperEntry `yaml:"-"`
	// ErrTransforms is a map from endpoint exception fields to client exception fields
	// that should override their values
	// Note that this feature is not yet fully implemented in the stand-alone Zanzibar codebase
	ErrTransforms map[string]FieldMapperEntry `yaml:"-"`
	// ReqHeaders maps headers from server to client
	ReqHeaders map[string]*TypedHeader `yaml:"reqHeaderMap,omitempty"`
	// ResHeaders maps headers from client to server
	ResHeaders map[string]*TypedHeader `yaml:"resHeaderMap,omitempty"`
	// DefaultHeaders a slice of headers that are forwarded to downstream when available
	DefaultHeaders []string `yaml:"-"`
	// WorkflowType, either "httpClient" or "custom".
	// A httpClient workflow generates a http client Caller
	// A custom workflow just imports the custom code
	WorkflowType string `yaml:"workflowType" validate:"nonzero"`
	// If "custom" then where to import custom code from
	WorkflowImportPath string `yaml:"workflowImportPath"`
	// if "httpClient", which client to call.
	ClientID string `yaml:"clientId,omitempty"`
	// if "httpClient", which client method to call.
	ClientMethod string `yaml:"clientMethod,omitempty"`
	// The client for this endpoint if httpClient or tchannelClient
	ClientSpec *ClientSpec `yaml:"-"`
	// IsClientlessEndpoint checks if the endpoint is clientless
	IsClientlessEndpoint bool `yaml:"-"`
}

type EndpointTestFixture struct {
	TestName           string                        `yaml:"testName" json:"testName"`
	EndpointID         string                        `yaml:"endpointId" json:"endpointId"`
	HandleID           string                        `yaml:"handleId" json:"handleId"`
	EndpointRequest    FixtureRequest                `yaml:"endpointRequest" json:"endpointRequest"` // there's no difference between http or tchannel request
	EndpointReqHeaders FixtureHeaders                `yaml:"endpointReqHeaders" json:"endpointReqHeaders"`
	EndpointResponse   FixtureResponse               `yaml:"endpointResponse" json:"endpointResponse"`
	EndpointResHeaders FixtureHeaders                `yaml:"endpointResHeaders" json:"endpointResHeaders"`
	ClientTestFixtures map[string]*ClientTestFixture `yaml:"clientTestFixtures" json:"clientTestFixtures"`
	TestServiceName    string                        `yaml:"testServiceName" json:"testServiceName"` // The service module that mounts the endpoint
}

type EndpointTestMeta struct {
	Instance           *ModuleInstance
	Method             *MethodSpec
	TestFixtures       map[string]*EndpointTestFixture `yaml:"testFixtures" json:"testFixtures"`
	ReqHeaders         map[string]*TypedHeader
	ResHeaders         map[string]*TypedHeader
	ClientName         string
	ClientID           string
	RelativePathToRoot string
	IncludedPackages   []GoPackageImport
}

type ErrorSkipCodeGen struct {
	IDLFile string
}

type ExceptionSpec struct {
	StructSpec

	StatusCode       StatusCode
	IsBodyDisallowed bool
}

type FieldAssignment struct {
	From           *compile.FieldSpec
	FromIdentifier string
	To             *compile.FieldSpec
	ToIdentifier   string
	TypeCast       string
	ExtraNilCheck  bool
}

type FieldMapperEntry struct {
	QualifiedName string //
	Field         *compile.FieldSpec

	Override bool
	// contains filtered or unexported fields
}

type Fixture struct {
	// ImportPath is the package where the user-defined Fixture global variable is contained.
	// The Fixture object defines, for a given client, the standardized list of fixture scenarios for that client
	ImportPath string `yaml:"importPath" json:"importPath" validate:"nonzero"`
	// Scenarios is a map from zanzibar's exposed method name to a list of user-defined fixture scenarios for a client
	Scenarios map[string][]string `yaml:"scenarios" json:"scenarios"`
}

type FixtureBlob map[string]interface{}

type FixtureBody struct {
	BodyType   BodyType     `yaml:"bodyType,omitempty" json:"bodyType,omitempty"`
	BodyString string       `yaml:"bodyString,omitempty" json:"bodyString,omitempty"` // set BodyString if response body is string
	BodyJSON   *FixtureBlob `yaml:"bodyJson,omitempty" json:"bodyJson,omitempty"`     // set Body if response body is object
}

type FixtureHTTPRequest struct {
	Method HTTPMethodType `yaml:"method,omitempty" json:"method,omitempty"`
	Body   *FixtureBody   `yaml:"body,omitempty" json:"body,omitempty"`
}

type FixtureHTTPResponse struct {
	StatusCode int          `yaml:"statusCode" json:"statusCode"`
	Body       *FixtureBody `yaml:"body,omitempty" json:"body,omitempty"`
}

type FixtureHeaders map[string]interface{}

type FixtureRequest struct {
	RequestType     ProtocalType        `yaml:"requestType" json:"requestType"`
	HTTPRequest     *FixtureHTTPRequest `yaml:"httpRequest,omitempty" json:"httpRequest,omitempty"`
	TChannelRequest FixtureBlob         `yaml:"tchannelRequest,omitempty" json:"tchannelRequest,omitempty"`
}

type FixtureResponse struct {
	ResponseType     ProtocalType         `yaml:"responseType" json:"responseType"`
	HTTPResponse     *FixtureHTTPResponse `yaml:"httpResponse,omitempty" json:"httpResponse,omitempty"`
	TChannelResponse FixtureBlob          `yaml:"tchannelResponse,omitempty" json:"tchannelResponse,omitempty"`
}

type GRPCClientConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    Dependencies     `yaml:"dependencies,omitempty" json:"dependencies"`
	Config          *ClientIDLConfig `yaml:"config" json:"config" validate:"nonzero"`
}

type GatewayServiceGenerator struct {
	// contains filtered or unexported fields
}

type GoPackageImport struct {
	PackageName string
	AliasName   string
}

type HTTPClientConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    Dependencies     `yaml:"dependencies,omitempty" json:"dependencies"`
	Config          *ClientIDLConfig `yaml:"config" json:"config" validate:"nonzero"`
}

type HTTPMethodType string

type HeaderFieldInfo struct {
	FieldIdentifier string
	IsPointer       bool
}

type HeaderPropagator struct {
	LineBuilder
	Helper PackageNameResolver
}

type IgnorePopulateSpecStageErr struct {
	Err error
}

type LineBuilder struct {
	// contains filtered or unexported fields
}

type MethodSpec struct {
	Name       string
	HTTPMethod string
	// Used by edge gateway to generate endpoint.
	EndpointName string
	HTTPPath     string
	PathSegments []PathSegment

	IsEndpoint bool

	// Statements for reading query parameters.
	ParseQueryParamGoStatements []string

	// Statements for writing query parameters
	WriteQueryParamGoStatements []string

	// Statements for reading request headers
	ReqHeaderGoStatements []string

	// Statements for reading request headers for clients
	ReqClientHeaderGoStatements []string

	// ResHeaderFields is a map of header name to a golang
	// field accessor expression used to read fields out
	// of the response body and place them into response headers
	ResHeaderFields map[string]HeaderFieldInfo

	// ReqHeaders needed, generated from "zanzibar.http.reqHeaders"
	ReqHeaders []string
	// ResHeaders needed, generated from "zanzibar.http.resHeaders"
	ResHeaders []string

	RequestType            string
	ShortRequestType       string
	ResponseType           string
	ShortResponseType      string
	OKStatusCode           StatusCode
	Exceptions             []ExceptionSpec
	ExceptionsByStatusCode map[int][]ExceptionSpec
	ExceptionsIndex        map[string]ExceptionSpec
	ValidStatusCodes       []int

	// Fully qualified field type of the unboxed field
	BoxedRequestType string
	// Unboxed field name
	BoxedRequestName string
	// Additional struct generated from the bundle of request args.
	RequestBoxed bool
	// Thrift service name the method belongs to.
	ThriftService string
	// The thriftrw-generated go package name
	GenCodePkgName string
	// Whether the method needs annotation or not.
	WantAnnot bool
	// The thriftrw compiled spec, used to extract type information
	CompiledThriftSpec *compile.FunctionSpec
	// The downstream service method set by endpoint config
	Downstream *ModuleSpec
	// the downstream service name
	DownstreamService string
	// The downstream method spec for the endpoint
	DownstreamMethod *MethodSpec

	// Statements for converting request types
	ConvertRequestGoStatements []string

	// Statements for converting response types
	ConvertResponseGoStatements []string

	// Statements for converting Clientless request types
	ConvertClientlessRequestGoStatements []string

	// Statements for propagating headers to client requests
	PropagateHeadersGoStatements []string

	// Statements for reading data out of url params (server)
	RequestParamGoStatements []string
	// contains filtered or unexported fields
}

type MiddlewareConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    *Dependencies           `yaml:"dependencies,omitempty" json:"dependencies,omitempty"`
	Config          *MiddlewareConfigConfig `yaml:"config" json:"config"`
}

type MiddlewareConfigConfig struct {
	OptionsSchemaFile string `yaml:"schema" json:"schema"`
	ImportPath        string `yaml:"path" json:"path"`
}

type MiddlewareGenerator struct {
	// contains filtered or unexported fields
}

type MiddlewareSpec struct {
	// The middleware package name.
	Name string `yaml:"name"`
	// Middleware specific configuration options.
	Options map[string]interface{} `yaml:"options"`
	// Options pretty printed for template initialization
	PrettyOptions map[string]string
	// Module Dependencies,  clients etc.
	Dependencies *Dependencies
	// Go Import Path for MiddlewareHandle implementation
	ImportPath string
	// Location of yaml Schema file for the configured endpoint options
	OptionsSchemaFile string
}

type MockgenBin struct {
	// contains filtered or unexported fields
}

type ModuleClass struct {
	Name       string
	NamePlural string
	ClassType  moduleClassType

	DependsOn  []string
	DependedBy []string
	// contains filtered or unexported fields
}

type ModuleClassConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Config          interface{} `yaml:"config" json:"config"`
}

type ModuleDependency struct {
	// ClassName is the name of the class as defined in the module system
	ClassName string
	// InstanceName is the name of the dependency instance as configu
	InstanceName string
}

type ModuleInstance struct {

	// PackageInfo is the name for the generated module instance
	PackageInfo *PackageInfo
	// ClassName is the name of the class as defined in the module system
	ClassName string
	// ClassType is the type of the class as defined in the module system
	ClassType string
	// BaseDirectory is the absolute path to module system system top level
	// directory
	BaseDirectory string
	// Directory is the relative instance directory
	Directory string
	// InstanceName is the name of the instance as configured in the instance's
	// YAML/JSON file
	InstanceName string
	// Config is a reference to the instance "config" key in the instances YAML
	// file.
	Config map[string]interface{}
	// Dependencies is a list of dependent modules as defined in the instances
	// YAML file
	Dependencies []ModuleDependency
	// Resolved dependencies is a list of direct dependent modules after processing
	// (fully resolved)
	ResolvedDependencies map[string][]*ModuleInstance
	// Recursive dependencies is a list of dependent modules and all of their
	// dependencies, i.e. the full tree of dependencies for this module. Each
	// class list is sorted for initialization order
	RecursiveDependencies map[string][]*ModuleInstance
	// DependencyOrder is the bottom to top order in which the recursively
	// resolved dependency class names can depend on each other
	DependencyOrder []string
	// The JSONFileName is file name of the instance JSON file
	JSONFileName string // Deprecated
	// The YAMLFileName is file name of the instance YAML file
	YAMLFileName string
	// JSONFileRaw is the raw JSON file read as bytes used for future parsing
	JSONFileRaw []byte // Deprecated
	// YAMLFileRaw is the raw YAML file read as bytes used for future parsing
	YAMLFileRaw []byte
	// SelectiveBuilding allows the module to be built with subset of dependencies
	SelectiveBuilding bool

	// QPSLevels is map of circuit breaker name to qps level for all circuit breakers
	QPSLevels map[string]int
	// contains filtered or unexported fields
}

type ModuleSpec struct {
	// CompiledModule is the resolved module from thrift file
	// that will contain modules and typedefs not directly mounted on AST
	CompiledModule *compile.Module `json:"omitempty"`
	// Source thrift file to generate the code.
	ThriftFile string
	// Whether the ThriftFile should have annotations or not
	WantAnnot bool
	// Whether the module is for an endpoint vs downstream client
	IsEndpoint bool
	// Go package name, generated base on module name.
	PackageName string
	// Go client types file path, generated from thrift file.
	GoThriftTypesFilePath string
	// Generated imports
	IncludedPackages []GoPackageImport
	Services         ServiceSpecs
	ProtoServices    []*ProtoService
}

type ModuleSystem struct {
	// contains filtered or unexported fields
}

type Options struct {
	EnableCustomInitialisation bool
	CommitChange               bool
	QPSLevelsEnabled           bool
}

type PackageHelper struct {
	// contains filtered or unexported fields
}

type PackageHelperOptions struct {
	// relative path to the idl dir, defaults to "./idl"
	RelIdlRootDir string
	// relative path to the proto idl dir, defaults to RelIdlRootDir, if neither of them is set, defaults to "./idl"
	ProtoRelIdlRootDir string
	// subdir for idl per module
	ModuleIdlSubDir map[string]string
	// relative path to the target dir that will contain generated code, defaults to "./build"
	RelTargetGenDir string
	// relative path to the middleware config dir, defaults to ""
	RelMiddlewareConfigDir string
	// relative path to the default middleware config dir, defaults to ""
	RelDefaultMiddlewareConfigDir string

	// map of idl type to package path of the generated code
	// map should be keyed with idl file extension, e.g., .thrift, .proto
	GenCodePackage map[string]string

	// thrift http annotation prefix, defaults to "zanzibar"
	AnnotationPrefix string

	// copyright header in generated code, defaults to ""
	CopyrightHeader string
	// header key to redirect client requests to staging environment, defaults to "X-Zanzibar-Use-Staging"
	StagingReqHeader string
	// The default headers to forward with all requests when present
	DefaultHeaders []string
	// header key to redirect client requests to local environment, defaults to "x-deputy-forwarded"
	DeputyReqHeader string
	// header key to uniquely identifies request/response pair, defaults to "x-trace-id"
	TraceKey string
	// ModuleSearchPaths is a dictionary of glob patterns for folders that contain *-config.yaml files
	ModuleSearchPaths map[string][]string
	// DefaultDependencies is a dictionary of glob patterns for folders that contain default dependencies
	DefaultDependencies map[string][]string

	// key to read qps levels or not in the endpoint levels
	QPSLevelsEnabled bool

	// key to enable custom initialisation
	CustomInitialisationEnabled bool
}

type PackageInfo struct {
	// PackageName is the name of the generated package, and should be the same
	// as the package name used by any custom code in the config directory
	PackageName string
	// PackageAlias is the unique import alias for non-generated packages
	PackageAlias string
	// PackageRoot is the unique import root for non-generated packages
	PackageRoot string
	// GeneratedPackageAlias is the unique import alias for generated packages
	GeneratedPackageAlias string
	// GeneratedModulePackageAlias is the unique import alias for the module system's,
	// generated subpackage
	GeneratedModulePackageAlias string
	// PackagePath is the full package path for the non-generated code
	PackagePath string
	// GeneratedPackagePath is the full package path for the generated code
	GeneratedPackagePath string
	// GeneratedModulePackagePath is the full package path for the generated dependency
	// structs and initializers
	GeneratedModulePackagePath string
	// QualifiedInstanceName for this package. Pascal case name for this module.
	QualifiedInstanceName string
	// ExportName is the name on the module initializer function
	ExportName string
	// ExportType refers to the type returned by the module initializer
	ExportType string
	// InitializerName is the name of function that can fully initialize the
	// module and its dependencies
	InitializerName string
	// IsExportGenerated is true if the export type is provided by the
	// generated package, otherwise it is assumed that the export type resides
	// in the non-generated package
	IsExportGenerated bool
	// CustomInitialisation if CustomInitialisation is true it basically changes the
	// import path of the module. For e.g. if the import path of a module is
	//   package import path: "github.com/uber/zanzibar/examples/example-gateway/build/clients/echo"
	//   module import path: "github.com/uber/zanzibar/examples/example-gateway/build/clients/echo/module"
	// then with CustomInitialisation=true the new import path are
	//   package import path: "github.com/uber/zanzibar/examples/example-gateway/clients/echo"
	//   module import path: "github.com/uber/zanzibar/examples/example-gateway/clients/echo"
	// hence the new import path are outside of the build folder or generated code, giving developer control over
	// the constructors of the module.
	CustomInitialisation bool
}

type PackageNameResolver interface {
	TypePackageName(thriftFile string) (string, error)
}

type PathSegment struct {
	Type           string
	Text           string
	BodyIdentifier string
	ParamName      string
	Required       bool
}

type PostGenHook func(map[string][]*ModuleInstance) error

type ProtoMessage struct {
	Name string
}

type ProtoModule struct {
	PackageName string
	FilePath    string
	Imports     []string
	Services    Services
}

type ProtoRPC struct {
	Name     string
	Request  *ProtoMessage
	Response *ProtoMessage
}

type ProtoService struct {
	Name string
	RPC  []*ProtoRPC
}

type ProtocalType string

type ServiceSpec struct {
	// Service name
	Name string
	// Source thrift file to generate the code.
	ThriftFile string
	// Whether the service should have annotations or not
	WantAnnot bool
	// Whether the service is for an endpoint vs downstream client
	IsEndpoint bool
	// List of methods/endpoints of the service
	Methods []*MethodSpec
	// thriftrw compile spec.
	CompileSpec *compile.ServiceSpec
}

type ServiceSpecs []*ServiceSpec

type Services []*ProtoService

type SpecProvider interface {
	ComputeSpec(
		instance *ModuleInstance,
	) (interface{}, error)
}

type StatusCode struct {
	Code    int
	Message string
}

type StructMeta struct {
	Instance *ModuleInstance
	Spec     *ModuleSpec
}

type StructSpec struct {
	Type        string
	Name        string
	Annotations map[string]string
}

type TChannelClientConfig struct {
	ClassConfigBase `yaml:",inline" json:",inline"`
	Dependencies    Dependencies     `yaml:"dependencies,omitempty" json:"dependencies"`
	Config          *ClientIDLConfig `yaml:"config" json:"config" validate:"nonzero"`
}

type Template struct {
	// contains filtered or unexported fields
}

type TypeConverter struct {
	LineBuilder
	Helper PackageNameResolver
	// contains filtered or unexported fields
}

type TypedHeader struct {
	Name        string
	TransformTo string
	Field       *compile.FieldSpec
}