ApplyFieldDocumentation takes the documentation comment block above your struct field declaration and applies them to the model snapshot, parsing all Doc Options in the process.

ApplyFunctionDocumentation takes the documentation comment block above your interface function declaration and applies them to the function snapshot, parsing all Doc Options in the process.

ApplyServiceDocumentation takes the documentation comment block above your interface type declaration and applies them to the service snapshot, parsing all Doc Options in the process.

ApplyTypeDocumentation takes the documentation comment block above your struct/alias type declaration and applies them to the model snapshot, parsing all Doc Options in the process.

FindGoDotMod starts in the current directory provided and recursively checks parent directories until it encounters a "go.mod" file.

NewTypeRegistry creates a new type registry that is pre-filled with all of the base types already registered.

ParseBindingOptions looks at the `json` tags of the given struct field and returns this field's binding configuration.

ParseDocumentation runs go/doc parsing on your input file to extract all of your documentation, comments, and struct field tags.

ParseFile parses a source code file containing a service interface declaration as well as the structs for the request/response inputs and outputs.

ParseModuleInfo cherry-picks a tiny bit of info from your "go.mod" file that we use in processing your services.

ParsePackageInfo overlays your project's "go.mod" file and your input file/path to figure out the fully qualified package info for the input service.

ParseService looks for 'type XxxService interface' declarations and extracts all service/operation info from it that we need to generate our artifacts.

ParseServiceFunction captures the information for a single function on a service.

ParseServiceFunctions creates function declarations for all methods on the service interface.

ParseTypes runs the syntax tree through the "go/types" processor so that we get detailed type information on all of the structs/types we defined, their fields, and the parameters/outputs of our service functions.

DefaultServiceVersion defines the version we'll assign to all parsed services if they do not have the VERSION doc option.

ErrMissingGoMod is the error returned when the project we're parsing does not have a 'go.mod' file in it.

ErrMultiplePackages is the error returned when you try to parse multiple packages for types at once.

ErrMultipleServices is the error returned when you define multiple "XyzService" interfaces in one file.

ErrNoServices is the error returned when your input file does not contain any "XyzService" interfaces.

ErrTypeNotContext is the error returned when the first param of an operation is not a context.Context.

ErrTypeNotError is the error returned when the second return value of an operation is not an error.

ErrTypeNotStructPointer is the error returned when the request/response value is not a struct pointer.

ErrTypeNotTwoParams is the error for when your function signature doesn't accept two parameters.

ErrTypeNotTwoReturns is the error for when your function signature doesn't return two values.

InvalidType is the type instance used by the AST parser to indicate types that the parser couldn't resolve.

Context wrangles all of the captured data about your input service declaration file.

FieldBindingOptions provides hints to the generation tools about how the runtime binder will map request parameters to an attribute of the request struct.

FieldDeclaration describes a single field in a request/response model.

GatewayParameter defines how a path/query parameter will be bound to a field in your request struct.

GatewayRoute contains the information required to register a method/endpoint with a specific gateway/listener.

GatewayServiceOptions contains all of the configurable HTTP-related options for a top-level service.

ModuleDeclaration contains information about the Go module that the service belongs to.

PackageDeclaration defines the subpackage that the service resides in.

ServiceDeclaration wrangles all of the information we could grab about the service from the interface that defined it.

ServiceFunctionDeclaration defines a single operation/function within a service (one of the interface functions).

TypeDeclaration is a snapshot of the type information for any type referenced, directly or indirectly, in your service declaration file.

Documentation is a lookup cache for all GoDoc comments on your services, functions, models, and fields.

DocumentationLines represents all of the 'go doc' lines above a type/function/field with all of the leading slashes removed.

FieldDeclarations collects the fields/attributes on a service model.

GatewayParameters is an overlay of a service function's path and request type/field info.

GatewayRoutes manages the collection of all possible routes that you can register to the runtime gateways serving up requests for this service.

ServiceFunctionDeclarations defines a collection of related service functions/operations.

Tags is a lookup for finding `json:"xxx"` tags defined on your request/response structs.

TypeRegistry is a quick lookup of all types we encountered when processing your declaration file.