schema

package
v3.0.0-...-a5432f4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 13, 2025 License: Apache-2.0 Imports: 50 Imported by: 1

README

(schema)=

Codeinfra Schema

This package defines Codeinfra Schema, a language-neutral specification for cloud resource models. Codeinfra Schema is the interface definition language for all Codeinfra Packages, and is used as the input to SDK code generation for each supported Codeinfra language.

Documentation

Index

Constants

View Source 
const (
	// ExamplesShortcode is the name for the `{{% examples %}}` shortcode, which demarcates a set of example sections.
	ExamplesShortcode = "examples"

	// ExampleShortcode is the name for the `{{% example %}}` shortcode, which demarcates the content for a single
	// example.
	ExampleShortcode = "example"
)

Variables

View Source 
var DefaultCodeinfraPackage = newCodeinfraPackage()
View Source 
var ErrGetSchemaNotImplemented = getSchemaNotImplemented{}
View Source 
var KindShortcode = ast.NewNodeKind("Shortcode")

KindShortcode is an ast.NodeKind for the Shortcode node.

View Source 
var MetaSchema *jsonschema.Schema

Functions

func IsPrimitiveType 

func IsPrimitiveType(t Type) bool

IsPrimitiveType returns true if the given Type is a primitive type. The primitive types are bool, int, number, string, archive, asset, and any.

func LoaderRegistration 

func LoaderRegistration(l codegenrpc.LoaderServer) func(*grpc.Server)

func NewLoaderServer 

func NewLoaderServer(loader ReferenceLoader) codegenrpc.LoaderServer

func NewShortcodeParser 

func NewShortcodeParser() parser.BlockParser

NewShortcodeParser returns a BlockParser that parses shortcode (e.g. `{{% examples %}}`).

func ParseDocs 

func ParseDocs(docs []byte) ast.Node

ParseDocs parses the given documentation text as Markdown with shortcodes and returns the AST.

func PropertyListJoinToString 

func PropertyListJoinToString(propertyList [][]*Property, nameConverter func(string) string) []string

Joins the output of `ReplaceOnChanges` into property path names.

For example, given an input [[B, D], [C]] where each property has a name equivalent to it's variable, this function should yield: ["B.D", "C"]

func RenderDocs 

func RenderDocs(w io.Writer, source []byte, node ast.Node, options ...RendererOption) error

RenderDocs renders parsed documentation to the given Writer. The source that was used to parse the documentation must be provided.

func RenderDocsToString 

func RenderDocsToString(source []byte, node ast.Node, options ...RendererOption) string

RenderDocsToString is like RenderDocs, but renders to a string instead of a Writer.

func TokenToRuntimeModule 

func TokenToRuntimeModule(tok string) string

Types

type Alias 

type Alias struct {
	// Name is the "name" portion of the alias, if any.
	Name *string
	// Project is the "project" portion of the alias, if any.
	Project *string
	// Type is the "type" portion of the alias, if any.
	Type *string
}

Alias describes an alias for a Codeinfra resource.

type AliasSpec 

type AliasSpec struct {
	// Name is the name portion of the alias, if any.
	Name *string `json:"name,omitempty" yaml:"name,omitempty"`
	// Project is the project portion of the alias, if any.
	Project *string `json:"project,omitempty" yaml:"project,omitempty"`
	// Type is the type portion of the alias, if any.
	Type *string `json:"type,omitempty" yaml:"type,omitempty"`
}

AliasSpec is the serializable form of an alias description.

type ArrayType 

type ArrayType struct {
	// ElementType is the element type of the array.
	ElementType Type
}

ArrayType represents arrays of particular element types.

func (*ArrayType) String 

func (t *ArrayType) String() string

type BaseProvider 

type BaseProvider struct {
	// Name is the name of the provider.
	Name string
	// Version is the version of the provider.
	Version semver.Version
}

BaseProvider

type BaseProviderSpec 

type BaseProviderSpec struct {
	// The name of the base provider.
	Name string `json:"name" yaml:"name"`
	// The version of the base provider.
	Version string `json:"version" yaml:"version"`
}

BaseProviderSpec is the serializable description of a Codeinfra base provider.

type ComplexTypeSpec 

type ComplexTypeSpec struct {
	ObjectTypeSpec `yaml:",inline"`

	// Enum, if present, is the list of possible values for an enum type.
	Enum []EnumValueSpec `json:"enum,omitempty" yaml:"enum,omitempty"`
}

ComplexTypeSpec is the serializable form of an object or enum type.

type ConfigSpec 

type ConfigSpec struct {
	// Variables is a map from variable name to PropertySpec that describes a package's configuration variables.
	Variables map[string]PropertySpec `json:"variables,omitempty" yaml:"variables,omitempty"`
	// Required is a list of the names of the package's required configuration variables.
	Required []string `json:"defaults,omitempty" yaml:"defaults,omitempty"`
}

ConfigSpec is the serializable description of a package's configuration variables.

type Decoder 

type Decoder func([]byte, interface{}) error

Deprecated.

type DefaultSpec 

type DefaultSpec struct {
	// Environment specifies a set of environment variables to probe for a default value.
	Environment []string `json:"environment,omitempty" yaml:"environment,omitempty"`
	// Language specifies additional language-specific data about the default value.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`
}

DefaultSpec is the serializable form of extra information about the default value for a property.

type DefaultValue 

type DefaultValue struct {
	// Value specifies a static default value, if any. This value must be representable in the Codeinfra schema type
	// system, and its type must be assignable to that of the property to which the default applies.
	Value interface{}
	// Environment specifies a set of environment variables to probe for a default value.
	Environment []string
	// Language specifies additional language-specific data about the default value.
	Language map[string]interface{}
}

DefaultValue describes a default value for a property.

type DiscriminatorSpec 

type DiscriminatorSpec struct {
	// PropertyName is the name of the property in the payload that will hold the discriminator value.
	PropertyName string `json:"propertyName" yaml:"propertyName"`
	// Mapping is an optional object to hold mappings between payload values and schema names or references.
	Mapping map[string]string `json:"mapping,omitempty" yaml:"mapping,omitempty"`
}

DiscriminatorSpec informs the consumer of an alternative schema based on the value associated with it.

type Enum 

type Enum struct {
	// Value is the value of the enum.
	Value interface{}
	// Comment is the description for the enum value.
	Comment string
	// Name for the enum.
	Name string
	// DeprecationMessage indicates whether or not the value is deprecated.
	DeprecationMessage string
}

Enum contains information about an enum.

type EnumType 

type EnumType struct {
	// PackageReference is the PackageReference that defines the resource.
	PackageReference PackageReference
	// Token is the type's Codeinfra type token.
	Token string
	// Comment is the description of the type, if any.
	Comment string
	// Elements are the predefined enum values.
	Elements []*Enum
	// ElementType is the underlying type for the enum.
	ElementType Type

	// IsOverlay indicates whether the type is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool
}

EnumType represents an enum.

func (*EnumType) String 

func (t *EnumType) String() string

type EnumValueSpec 

type EnumValueSpec struct {
	// Name, if present, overrides the name of the enum value that would usually be derived from the value.
	Name string `json:"name,omitempty" yaml:"name,omitempty"`
	// Description of the enum value.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Value is the enum value itself.
	Value interface{} `json:"value" yaml:"value"`
	// DeprecationMessage indicates whether or not the value is deprecated.
	DeprecationMessage string `json:"deprecationMessage,omitempty" yaml:"deprecationMessage,omitempty"`
}

EnumValueSpec is the serializable form of the values metadata associated with an enum type.

type Function 

type Function struct {
	// PackageReference is the PackageReference that defines the function.
	PackageReference PackageReference
	// Token is the function's Codeinfra type token.
	Token string
	// Comment is the description of the function, if any.
	Comment string
	// Inputs is the bag of input values for the function, if any.
	Inputs *ObjectType
	// Determines whether the input bag should be treated as a single argument or as multiple arguments.
	MultiArgumentInputs bool
	// Outputs is the bag of output values for the function, if any.
	Outputs *ObjectType
	// The return type of the function, if any.
	ReturnType Type
	// The return type is plain and not wrapped in an Output.
	ReturnTypePlain bool
	// When InlineObjectAsReturnType is true, it means that the return type definition is defined inline
	// as an object type that should be generated as a separate type and it is not
	// a reference to a existing type in the schema.
	InlineObjectAsReturnType bool
	// DeprecationMessage indicates whether or not the function is deprecated.
	DeprecationMessage string
	// Language specifies additional language-specific data about the function.
	Language map[string]interface{}
	// IsMethod indicates whether the function is a method of a resource.
	IsMethod bool
	// IsOverlay indicates whether the function is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool
	// OverlaySupportedLanguages indicates what languages the overlay supports. This only has an effect if
	// the Resource is an Overlay (IsOverlay == true).
	// Supported values are "nodejs", "python", "go", "csharp", "java", "yaml"
	OverlaySupportedLanguages []string
}

Function describes a Codeinfra function.

func (*Function) NeedsOutputVersion 

func (fun *Function) NeedsOutputVersion() bool

NeedsOutputVersion determines if codegen should emit a ${fn}Output version that automatically accepts Inputs and returns ReturnType.

type FunctionSpec 

type FunctionSpec struct {
	// Description is the description of the function, if any.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Inputs is the bag of input values for the function, if any.
	Inputs *ObjectTypeSpec `json:"inputs,omitempty" yaml:"inputs,omitempty"`
	// Determines whether the input bag should be treated as a single argument or as multiple arguments.
	// When MultiArgumentInputs is non-empty, it must match up 1:1 with the property names in of the Inputs object.
	// The order in which the properties are listed in MultiArgumentInputs determines the order in which the
	// arguments are passed to the function.
	MultiArgumentInputs []string `json:"multiArgumentInputs,omitempty" yaml:"multiArgumentInputs,omitempty"`
	// Outputs is the bag of output values for the function, if any.
	// This field is DEPRECATED. Use ReturnType instead where it allows for more flexible types
	// to describe the outputs of the function definition. It is invalid to specify both Outputs and ReturnType.
	Outputs *ObjectTypeSpec `json:"outputs,omitempty" yaml:"outputs,omitempty"`
	// Specified the return type of the function definition
	ReturnType *ReturnTypeSpec
	// DeprecationMessage indicates whether the function is deprecated.
	DeprecationMessage string `json:"deprecationMessage,omitempty" yaml:"deprecationMessage,omitempty"`
	// Language specifies additional language-specific data about the function.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`
	// IsOverlay indicates whether the function is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool `json:"isOverlay,omitempty" yaml:"isOverlay,omitempty"`
	// OverlaySupportedLanguages indicates what languages the overlay supports. This only has an effect if
	// the Resource is an Overlay (IsOverlay == true).
	// Supported values are "nodejs", "python", "go", "csharp", "java", "yaml"
	OverlaySupportedLanguages []string `json:"overlaySupportedLanguages,omitempty" yaml:"overlaySupportedLanguages,omitempty"` //nolint:lll
}

FunctionSpec is the serializable form of a function description.

func (FunctionSpec) MarshalJSON 

func (funcSpec FunctionSpec) MarshalJSON() ([]byte, error)

func (FunctionSpec) MarshalYAML 

func (funcSpec FunctionSpec) MarshalYAML() (interface{}, error)

func (*FunctionSpec) UnmarshalJSON 

func (funcSpec *FunctionSpec) UnmarshalJSON(inputJSON []byte) error

UnmarshalJSON is custom unmarshalling logic for FunctionSpec so that we can derive Outputs from ReturnType which otherwise isn't possible when both are retrieved from the same JSON field

func (*FunctionSpec) UnmarshalYAML 

func (funcSpec *FunctionSpec) UnmarshalYAML(node *yaml.Node) error

UnmarshalYAML is custom unmarshalling logic for FunctionSpec so that we can derive Outputs from ReturnType which otherwise isn't possible when both are retrieved from the same JSON field

type FunctionsIter 

type FunctionsIter interface {
	Token() string
	Function() (*Function, error)
	Next() bool
}

FunctionsIter is an iterator for ranging over a package's functions. See PackageFunctions.Range.

type InputType 

type InputType struct {
	// ElementType is the element type of the input.
	ElementType Type
}

InputType represents a type that accepts either a prompt value or an output value.

func (*InputType) String 

func (t *InputType) String() string

type InvalidType 

type InvalidType struct {
	Diagnostics hcl.Diagnostics
}

An InvalidType represents an invalid type with associated diagnostics.

func (*InvalidType) String 

func (t *InvalidType) String() string

type Language 

type Language interface {
	// ImportDefaultSpec decodes language-specific metadata associated with a DefaultValue.
	ImportDefaultSpec(def *DefaultValue, bytes json.RawMessage) (interface{}, error)
	// ImportPropertySpec decodes language-specific metadata associated with a Property.
	ImportPropertySpec(property *Property, bytes json.RawMessage) (interface{}, error)
	// ImportObjectTypeSpec decodes language-specific metadata associated with a ObjectType.
	ImportObjectTypeSpec(object *ObjectType, bytes json.RawMessage) (interface{}, error)
	// ImportResourceSpec decodes language-specific metadata associated with a Resource.
	ImportResourceSpec(resource *Resource, bytes json.RawMessage) (interface{}, error)
	// ImportFunctionSpec decodes language-specific metadata associated with a Function.
	ImportFunctionSpec(function *Function, bytes json.RawMessage) (interface{}, error)
	// ImportPackageSpec decodes language-specific metadata associated with a Package.
	ImportPackageSpec(pkg *Package, bytes json.RawMessage) (interface{}, error)
}

Language provides hooks for importing language-specific metadata in a package.

type Loader 

type Loader interface {
	// deprecated: use LoadPackageV2
	LoadPackage(pkg string, version *semver.Version) (*Package, error)

	LoadPackageV2(ctx context.Context, descriptor *PackageDescriptor) (*Package, error)
}

type LoaderClient 

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

LoaderClient reflects a loader service, loaded dynamically from the engine process over gRPC.

func NewLoaderClient 

func NewLoaderClient(target string) (*LoaderClient, error)

func (*LoaderClient) Close 

func (l *LoaderClient) Close() error

func (*LoaderClient) LoadPackage 

func (l *LoaderClient) LoadPackage(pkg string, version *semver.Version) (*Package, error)

func (*LoaderClient) LoadPackageReference 

func (l *LoaderClient) LoadPackageReference(pkg string, version *semver.Version) (PackageReference, error)

func (*LoaderClient) LoadPackageReferenceV2 

func (l *LoaderClient) LoadPackageReferenceV2(
	ctx context.Context, descriptor *PackageDescriptor,
) (PackageReference, error)

func (*LoaderClient) LoadPackageV2 

func (l *LoaderClient) LoadPackageV2(ctx context.Context, descriptor *PackageDescriptor) (*Package, error)

type MapType 

type MapType struct {
	// ElementType is the element type of the map.
	ElementType Type
}

MapType represents maps from strings to particular element types.

func (*MapType) String 

func (t *MapType) String() string

type MetadataSpec 

type MetadataSpec struct {
	// ModuleFormat is a regex that is used by the importer to extract a module name from the module portion of a
	// type token. Packages that use the module format "namespace1/namespace2/.../namespaceN" do not need to specify
	// a format. The regex must define one capturing group that contains the module name, which must be formatted as
	// "namespace1/namespace2/...namespaceN".
	ModuleFormat string `json:"moduleFormat,omitempty" yaml:"moduleFormat,omitempty"`

	// SupportPack indicates whether or not the package is written to support the pack command. This causes versions to
	// be written out, plugin.json files to be filled in, and package metadata to be written to the directory.
	// This defaults to false currently, but conformance testing _always_ turns it on.
	SupportPack bool `json:"supportPack,omitempty" yaml:"supportPack,omitempty"`
}

MetadataSpec contains information for the importer about this package.

type Method 

type Method struct {
	// Name is the name of the method.
	Name string
	// Function is the function definition for the method.
	Function *Function
}

type ObjectType 

type ObjectType struct {
	// PackageReference is the PackageReference that defines the resource.
	PackageReference PackageReference
	// Token is the type's Codeinfra type token.
	Token string
	// Comment is the description of the type, if any.
	Comment string
	// Properties is the list of the type's properties.
	Properties []*Property
	// Language specifies additional language-specific data about the object type.
	Language map[string]interface{}
	// IsOverlay indicates whether the type is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool
	// OverlaySupportedLanguages indicates what languages the overlay supports. This only has an effect if
	// the Resource is an Overlay (IsOverlay == true).
	// Supported values are "nodejs", "python", "go", "csharp", "java", "yaml"
	OverlaySupportedLanguages []string

	// InputShape is the input shape for this object. Only valid if IsPlainShape returns true.
	InputShape *ObjectType
	// PlainShape is the plain shape for this object. Only valid if IsInputShape returns true.
	PlainShape *ObjectType
	// contains filtered or unexported fields
}

ObjectType represents schematized maps from strings to particular types.

func (*ObjectType) IsInputShape 

func (t *ObjectType) IsInputShape() bool

IsInputShape returns true if this object type is the input shape of a (plain, input) pair. The input shape of an object may contain *InputType values and may reference other input shapes.

func (*ObjectType) IsPlainShape 

func (t *ObjectType) IsPlainShape() bool

IsPlainShape returns true if this object type is the plain shape of a (plain, input) pair. The plain shape of an object does not contain *InputType values and only references other plain shapes.

func (*ObjectType) Property 

func (t *ObjectType) Property(name string) (*Property, bool)

func (*ObjectType) String 

func (t *ObjectType) String() string

type ObjectTypeSpec 

type ObjectTypeSpec struct {
	// Description is the description of the type, if any.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Properties, if present, is a map from property name to PropertySpec that describes the type's properties.
	Properties map[string]PropertySpec `json:"properties,omitempty" yaml:"properties,omitempty"`
	// Type must be "object" if this is an object type, or the underlying type for an enum.
	Type string `json:"type,omitempty" yaml:"type,omitempty"`
	// Required, if present, is a list of the names of an object type's required properties. These properties must be set
	// for inputs and will always be set for outputs.
	Required []string `json:"required,omitempty" yaml:"required,omitempty"`
	// Plain, was a list of the names of an object type's plain properties. This property is ignored: instead, property
	// types should be marked as plain where necessary.
	Plain []string `json:"plain,omitempty" yaml:"plain,omitempty"`
	// Language specifies additional language-specific data about the type.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`
	// IsOverlay indicates whether the type is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool `json:"isOverlay,omitempty" yaml:"isOverlay,omitempty"`
	// OverlaySupportedLanguages indicates what languages the overlay supports. This only has an effect if
	// the Resource is an Overlay (IsOverlay == true).
	// Supported values are "nodejs", "python", "go", "csharp", "java", "yaml"
	OverlaySupportedLanguages []string `json:"overlaySupportedLanguages,omitempty" yaml:"overlaySupportedLanguages,omitempty"` //nolint:lll
}

ObjectTypeSpec is the serializable form of an object type.

type OptionalType 

type OptionalType struct {
	// ElementType is the element type of the input.
	ElementType Type
}

OptionalType represents a type that accepts an optional value.

func (*OptionalType) String 

func (t *OptionalType) String() string

type Package 

type Package struct {
	// True if this package should be written in the new style to support pack and conformance testing.
	SupportPack bool

	// Name is the unqualified name of the package (e.g. "aws", "azure", "gcp", "kubernetes". "random")
	Name string
	// DisplayName is the human-friendly name of the package.
	DisplayName string
	// Version is the version of the package.
	Version *semver.Version
	// Description is the description of the package.
	Description string
	// Keywords is the list of keywords that are associated with the package, if any.
	// Some reserved keywords can be specified as well that help with categorizing the
	// package in the Codeinfra registry. `category/<name>` and `kind/<type>` are the only
	// reserved keywords at this time, where `<name>` can be one of:
	// `cloud`, `database`, `infrastructure`, `monitoring`, `network`, `utility`, `vcs`
	// and `<type>` is either `native` or `component`. If the package is a bridged Terraform
	// provider, then don't include the `kind/` label.
	Keywords []string
	// Homepage is the package's homepage.
	Homepage string
	// License indicates which license is used for the package's contents.
	License string
	// Attribution allows freeform text attribution of derived work, if needed.
	Attribution string
	// Repository is the URL at which the source for the package can be found.
	Repository string
	// LogoURL is the URL for the package's logo, if any.
	LogoURL string
	// PluginDownloadURL is the URL to use to acquire the provider plugin binary, if any.
	PluginDownloadURL string
	// Publisher is the name of the person or organization that authored and published the package.
	Publisher string
	// A list of allowed package name in addition to the Name property.
	AllowedPackageNames []string

	// Types is the list of non-resource types defined by the package.
	Types []Type
	// Config is the set of configuration properties defined by the package.
	Config []*Property
	// Provider is the resource provider for the package, if any.
	Provider *Resource
	// Resources is the list of resource types defined by the package.
	Resources []*Resource
	// Functions is the list of functions defined by the package.
	Functions []*Function
	// Language specifies additional language-specific data about the package.
	Language map[string]interface{}

	// Parameterization is the optional parameterization for the package, if any.
	Parameterization *Parameterization
	// contains filtered or unexported fields
}

Package describes a Codeinfra package.

func BindSpec 

func BindSpec(spec PackageSpec, loader Loader) (*Package, hcl.Diagnostics, error)

BindSpec converts a serializable PackageSpec into a Package. Any semantic errors encountered during binding are contained in the returned diagnostics. The returned error is only non-nil if a fatal error was encountered.

func ImportSpec 

func ImportSpec(spec PackageSpec, languages map[string]Language) (*Package, error)

ImportSpec converts a serializable PackageSpec into a Package. Unlike BindSpec, ImportSpec does not validate its input against the Codeinfra package metaschema. ImportSpec should only be used to load packages that are assumed to be well-formed (e.g. packages referenced for program code generation or by a root package being used for SDK generation). BindSpec should be used to load and validate a package spec prior to generating its SDKs.

func (*Package) Equals 

func (pkg *Package) Equals(other *Package) bool

func (*Package) GetFunction 

func (pkg *Package) GetFunction(token string) (*Function, bool)

func (*Package) GetResource 

func (pkg *Package) GetResource(token string) (*Resource, bool)

func (*Package) GetResourceType 

func (pkg *Package) GetResourceType(token string) (*ResourceType, bool)

func (*Package) GetType 

func (pkg *Package) GetType(token string) (Type, bool)

func (*Package) Identity 

func (pkg *Package) Identity() string

func (*Package) ImportLanguages 

func (pkg *Package) ImportLanguages(languages map[string]Language) error

func (*Package) MarshalJSON 

func (pkg *Package) MarshalJSON() ([]byte, error)

func (*Package) MarshalSpec 

func (pkg *Package) MarshalSpec() (spec *PackageSpec, err error)

func (*Package) MarshalYAML 

func (pkg *Package) MarshalYAML() ([]byte, error)

func (*Package) Reference 

func (pkg *Package) Reference() PackageReference

func (*Package) TokenToModule 

func (pkg *Package) TokenToModule(tok string) string

func (*Package) TokenToRuntimeModule 

func (pkg *Package) TokenToRuntimeModule(tok string) string

type PackageDescriptor 

type PackageDescriptor struct {
	Name             string                      // the simple name of the plugin.
	Version          *semver.Version             // the plugin's semantic version, if present.
	DownloadURL      string                      // an optional server to use when downloading this plugin.
	Parameterization *ParameterizationDescriptor // the optional parameterization of the package.
}

PackageDescriptor is a descriptor for a package, this is similar to a plugin spec but also contains parameterization info.

type PackageFunctions 

type PackageFunctions interface {
	// Range returns a range iterator for the package's functions. Call Next to
	// advance the iterator, and Token/Function to access each entry. Function definitions
	// are loaded on demand. Iteration order is undefined.
	//
	// Example:
	//
	//     for it := pkg.Functions().Range(); it.Next(); {
	//         token := it.Token()
	//         fn, err := it.Function()
	//         ...
	//     }
	//
	Range() FunctionsIter

	// Get finds and loads the function with the given token. If the function is not found,
	// this function returns (nil, false, nil).
	Get(token string) (*Function, bool, error)
}

PackageFunctions provides random and sequential access to a package's functions.

type PackageInfoSpec 

type PackageInfoSpec struct {
	// Name is the unqualified name of the package (e.g. "aws", "azure", "gcp", "kubernetes", "random")
	Name string `json:"name" yaml:"name"`
	// DisplayName is the human-friendly name of the package.
	DisplayName string `json:"displayName,omitempty" yaml:"displayName,omitempty"`
	// Version is the version of the package. The version must be valid semver.
	Version string `json:"version,omitempty" yaml:"version,omitempty"`
	// Description is the description of the package.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Keywords is the list of keywords that are associated with the package, if any.
	// Some reserved keywords can be specified as well that help with categorizing the
	// package in the Codeinfra registry. `category/<name>` and `kind/<type>` are the only
	// reserved keywords at this time, where `<name>` can be one of:
	// `cloud`, `database`, `infrastructure`, `monitoring`, `network`, `utility`, `vcs`
	// and `<type>` is either `native` or `component`. If the package is a bridged Terraform
	// provider, then don't include the `kind/` label.
	Keywords []string `json:"keywords,omitempty" yaml:"keywords,omitempty"`
	// Homepage is the package's homepage.
	Homepage string `json:"homepage,omitempty" yaml:"homepage,omitempty"`
	// License indicates which license is used for the package's contents.
	License string `json:"license,omitempty" yaml:"license,omitempty"`
	// Attribution allows freeform text attribution of derived work, if needed.
	Attribution string `json:"attribution,omitempty" yaml:"attribution,omitempty"`
	// Repository is the URL at which the source for the package can be found.
	Repository string `json:"repository,omitempty" yaml:"repository,omitempty"`
	// LogoURL is the URL for the package's logo, if any.
	LogoURL string `json:"logoUrl,omitempty" yaml:"logoUrl,omitempty"`
	// PluginDownloadURL is the URL to use to acquire the provider plugin binary, if any.
	PluginDownloadURL string `json:"pluginDownloadURL,omitempty" yaml:"pluginDownloadURL,omitempty"`
	// Publisher is the name of the person or organization that authored and published the package.
	Publisher string `json:"publisher,omitempty" yaml:"publisher,omitempty"`

	// Meta contains information for the importer about this package.
	Meta *MetadataSpec `json:"meta,omitempty" yaml:"meta,omitempty"`

	// A list of allowed package name in addition to the Name property.
	AllowedPackageNames []string `json:"allowedPackageNames,omitempty" yaml:"allowedPackageNames,omitempty"`

	// Language specifies additional language-specific data about the package.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`

	// Parameterization is the optional parameterization for this package.
	Parameterization *ParameterizationSpec `json:"parameterization,omitempty" yaml:"parameterization,omitempty"`
}

PackageInfoSpec is the serializable description of a Codeinfra package's metadata.

type PackageReference 

type PackageReference interface {
	// Name returns the package name.
	Name() string
	// Version returns the package version.
	Version() *semver.Version

	// Description returns the packages description.
	Description() string

	// Publisher returns the package publisher.
	Publisher() string
	// Repository returns the package repository.
	Repository() string

	// SupportPack specifies the package definition can be packed by language plugins, this is always true for
	// parameterized packages.
	SupportPack() bool

	// Types returns the package's types.
	Types() PackageTypes
	// Config returns the package's configuration variables, if any.
	Config() ([]*Property, error)
	// Provider returns the package's provider.
	Provider() (*Resource, error)
	// Resources returns the package's resources.
	Resources() PackageResources
	// Functions returns the package's functions.
	Functions() PackageFunctions

	// TokenToModule extracts a package member's module name from its token.
	TokenToModule(token string) string

	// Definition fully loads the referenced package and returns the result.
	Definition() (*Package, error)
}

A PackageReference represents a references Codeinfra Package. Applications that do not need access to the entire definition of a Codeinfra Package should use PackageReference rather than Package, as the former uses memory more efficiently than the latter by binding package members on-demand.

func LoadPackageReference 

func LoadPackageReference(loader Loader, pkg string, version *semver.Version) (PackageReference, error)

deprecated: use LoadPackageReferenceV2

func LoadPackageReferenceV2 

func LoadPackageReferenceV2(
	ctx context.Context, loader Loader, descriptor *PackageDescriptor,
) (PackageReference, error)

type PackageResources 

type PackageResources interface {
	// Range returns a range iterator for the package's resources. Call Next to
	// advance the iterator, and Token/Resource to access each entry. Resource definitions
	// are loaded on demand. Iteration order is undefined.
	//
	// Example:
	//
	//     for it := pkg.Resources().Range(); it.Next(); {
	//         token := it.Token()
	//         res, err := it.Resource()
	//         ...
	//     }
	//
	Range() ResourcesIter

	// Get finds and loads the resource with the given token. If the resource is not found,
	// this function returns (nil, false, nil).
	Get(token string) (*Resource, bool, error)

	// GetType loads the *ResourceType that corresponds to a given resource definition.
	GetType(token string) (*ResourceType, bool, error)
}

PackageResources provides random and sequential access to a package's resources.

type PackageSpec 

type PackageSpec struct {
	// Name is the unqualified name of the package (e.g. "aws", "azure", "gcp", "kubernetes", "random")
	Name string `json:"name" yaml:"name"`
	// DisplayName is the human-friendly name of the package.
	DisplayName string `json:"displayName,omitempty" yaml:"displayName,omitempty"`
	// Version is the version of the package. The version must be valid semver.
	Version string `json:"version,omitempty" yaml:"version,omitempty"`
	// Description is the description of the package.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Keywords is the list of keywords that are associated with the package, if any.
	// Some reserved keywords can be specified as well that help with categorizing the
	// package in the Codeinfra registry. `category/<name>` and `kind/<type>` are the only
	// reserved keywords at this time, where `<name>` can be one of:
	// `cloud`, `database`, `infrastructure`, `monitoring`, `network`, `utility`, `vcs`
	// and `<type>` is either `native` or `component`. If the package is a bridged Terraform
	// provider, then don't include the `kind/` label.
	Keywords []string `json:"keywords,omitempty" yaml:"keywords,omitempty"`
	// Homepage is the package's homepage.
	Homepage string `json:"homepage,omitempty" yaml:"homepage,omitempty"`
	// License indicates which license is used for the package's contents.
	License string `json:"license,omitempty" yaml:"license,omitempty"`
	// Attribution allows freeform text attribution of derived work, if needed.
	Attribution string `json:"attribution,omitempty" yaml:"attribution,omitempty"`
	// Repository is the URL at which the source for the package can be found.
	Repository string `json:"repository,omitempty" yaml:"repository,omitempty"`
	// LogoURL is the URL for the package's logo, if any.
	LogoURL string `json:"logoUrl,omitempty" yaml:"logoUrl,omitempty"`
	// PluginDownloadURL is the URL to use to acquire the provider plugin binary, if any.
	PluginDownloadURL string `json:"pluginDownloadURL,omitempty" yaml:"pluginDownloadURL,omitempty"`
	// Publisher is the name of the person or organization that authored and published the package.
	Publisher string `json:"publisher,omitempty" yaml:"publisher,omitempty"`

	// Meta contains information for the importer about this package.
	Meta *MetadataSpec `json:"meta,omitempty" yaml:"meta,omitempty"`

	// A list of allowed package name in addition to the Name property.
	AllowedPackageNames []string `json:"allowedPackageNames,omitempty" yaml:"allowedPackageNames,omitempty"`

	// Language specifies additional language-specific data about the package.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`

	// Config describes the set of configuration variables defined by this package.
	Config ConfigSpec `json:"config,omitempty" yaml:"config"`
	// Types is a map from type token to ComplexTypeSpec that describes the set of complex types (ie. object, enum)
	// defined by this package.
	Types map[string]ComplexTypeSpec `json:"types,omitempty" yaml:"types,omitempty"`
	// Provider describes the provider type for this package.
	Provider ResourceSpec `json:"provider,omitempty" yaml:"provider"`
	// Resources is a map from type token to ResourceSpec that describes the set of resources defined by this package.
	Resources map[string]ResourceSpec `json:"resources,omitempty" yaml:"resources,omitempty"`
	// Functions is a map from token to FunctionSpec that describes the set of functions defined by this package.
	Functions map[string]FunctionSpec `json:"functions,omitempty" yaml:"functions,omitempty"`

	// Parameterization is the optional parameterization for this package.
	Parameterization *ParameterizationSpec `json:"parameterization,omitempty" yaml:"parameterization,omitempty"`
}

PackageSpec is the serializable description of a Codeinfra package.

func (*PackageSpec) Info 

func (p *PackageSpec) Info() PackageInfoSpec

type PackageTypes 

type PackageTypes interface {
	// Range returns a range iterator for the package's types. Call Next to
	// advance the iterator, and Token/Type to access each entry. Type definitions
	// are loaded on demand. Iteration order is undefined.
	//
	// Example:
	//
	//     for it := pkg.Types().Range(); it.Next(); {
	//         token := it.Token()
	//         typ, err := it.Type()
	//         ...
	//     }
	//
	Range() TypesIter

	// Get finds and loads the type with the given token. If the type is not found,
	// this function returns (nil, false, nil).
	Get(token string) (Type, bool, error)
}

PackageTypes provides random and sequential access to a package's types.

type Parameterization 

type Parameterization struct {
	BaseProvider BaseProvider
	// Parameter is the parameter for the provider.
	Parameter []byte
}

type ParameterizationDescriptor 

type ParameterizationDescriptor struct {
	Name    string         // the name of the package.
	Version semver.Version // the version of the package.
	Value   []byte         // the parameter value of the package.
}

type ParameterizationSpec 

type ParameterizationSpec struct {
	// The base provider to parameterize.
	BaseProvider BaseProviderSpec `json:"baseProvider" yaml:"baseProvider"`
	// The parameter to apply to the base provider.
	Parameter []byte `json:"parameter" yaml:"parameter"`
}

ParameterizationSpec is the serializable description of a provider parameterization.

type PartialPackage 

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

PartialPackage is an implementation of PackageReference that loads and binds package members on demand. A PartialPackage is backed by a PartialPackageSpec, which leaves package members in their JSON-encoded form until they are required. PartialPackages are created using ImportPartialSpec.

func ImportPartialSpec 

func ImportPartialSpec(spec PartialPackageSpec, languages map[string]Language, loader Loader) (*PartialPackage, error)

ImportPartialSpec converts a serializable PartialPackageSpec into a PartialPackage. Unlike a typical Package, a PartialPackage loads and binds its members on-demand rather than at import time. This is useful when the entire contents of a package are not needed (e.g. for referenced packages).

func (*PartialPackage) Config 

func (p *PartialPackage) Config() ([]*Property, error)

func (*PartialPackage) Definition 

func (p *PartialPackage) Definition() (*Package, error)

func (*PartialPackage) Description 

func (p *PartialPackage) Description() string

func (*PartialPackage) Functions 

func (p *PartialPackage) Functions() PackageFunctions

func (*PartialPackage) Name 

func (p *PartialPackage) Name() string

func (*PartialPackage) Provider 

func (p *PartialPackage) Provider() (*Resource, error)

func (*PartialPackage) Publisher 

func (p *PartialPackage) Publisher() string

func (*PartialPackage) Repository 

func (p *PartialPackage) Repository() string

func (*PartialPackage) Resources 

func (p *PartialPackage) Resources() PackageResources

func (*PartialPackage) Snapshot 

func (p *PartialPackage) Snapshot() (*Package, error)

Snapshot returns a definition for the package that contains only the members that have been accessed thus far. If Definition has been called, the returned definition will include all of the package's members. It is safe to call Snapshot multiple times.

func (*PartialPackage) SupportPack 

func (p *PartialPackage) SupportPack() bool

func (*PartialPackage) TokenToModule 

func (p *PartialPackage) TokenToModule(token string) string

func (*PartialPackage) Types 

func (p *PartialPackage) Types() PackageTypes

func (*PartialPackage) Version 

func (p *PartialPackage) Version() *semver.Version

type PartialPackageSpec 

type PartialPackageSpec struct {
	PackageInfoSpec `yaml:",inline"`

	// Config describes the set of configuration variables defined by this package.
	Config json.RawMessage `json:"config" yaml:"config"`
	// Types is a map from type token to ComplexTypeSpec that describes the set of complex types (ie. object, enum)
	// defined by this package.
	Types map[string]json.RawMessage `json:"types,omitempty" yaml:"types,omitempty"`
	// Provider describes the provider type for this package.
	Provider json.RawMessage `json:"provider" yaml:"provider"`
	// Resources is a map from type token to ResourceSpec that describes the set of resources defined by this package.
	Resources map[string]json.RawMessage `json:"resources,omitempty" yaml:"resources,omitempty"`
	// Functions is a map from token to FunctionSpec that describes the set of functions defined by this package.
	Functions map[string]json.RawMessage `json:"functions,omitempty" yaml:"functions,omitempty"`
}

PartialPackageSpec is a serializable description of a Codeinfra package that defers the deserialization of most package members until they are needed. Used to support PartialPackage and PackageReferences.

type Property 

type Property struct {
	// Name is the name of the property.
	Name string
	// Comment is the description of the property, if any.
	Comment string
	// Type is the type of the property.
	Type Type
	// ConstValue is the constant value for the property, if any.
	ConstValue interface{}
	// DefaultValue is the default value for the property, if any.
	DefaultValue *DefaultValue
	// DeprecationMessage indicates whether or not the property is deprecated.
	DeprecationMessage string
	// Language specifies additional language-specific data about the property.
	Language map[string]interface{}
	// Secret is true if the property is secret (default false).
	Secret bool
	// ReplaceOnChanges specifies if the property is to be replaced instead of updated (default false).
	ReplaceOnChanges bool
	// WillReplaceOnChanges indicates that the provider will replace the resource when
	// this property is changed. This property is used exclusively for docs.
	WillReplaceOnChanges bool
	Plain                bool
}

Property describes an object or resource property.

func (*Property) IsRequired 

func (p *Property) IsRequired() bool

IsRequired returns true if this property is required (i.e. its type is not Optional).

type PropertySpec 

type PropertySpec struct {
	TypeSpec `yaml:",inline"`

	// Description is the description of the property, if any.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Const is the constant value for the property, if any. The type of the value must be assignable to the type of
	// the property.
	Const interface{} `json:"const,omitempty" yaml:"const,omitempty"`
	// Default is the default value for the property, if any. The type of the value must be assignable to the type of
	// the property.
	Default interface{} `json:"default,omitempty" yaml:"default,omitempty"`
	// DefaultInfo contains additional information about the property's default value, if any.
	DefaultInfo *DefaultSpec `json:"defaultInfo,omitempty" yaml:"defaultInfo,omitempty"`
	// DeprecationMessage indicates whether or not the property is deprecated.
	DeprecationMessage string `json:"deprecationMessage,omitempty" yaml:"deprecationMessage,omitempty"`
	// Language specifies additional language-specific data about the property.
	Language map[string]RawMessage `json:"language,omitempty" yaml:"language,omitempty"`
	// Secret specifies if the property is secret (default false).
	Secret bool `json:"secret,omitempty" yaml:"secret,omitempty"`
	// ReplaceOnChanges specifies if the property is to be replaced instead of updated (default false).
	ReplaceOnChanges bool `json:"replaceOnChanges,omitempty" yaml:"replaceOnChanges,omitempty"`
	// WillReplaceOnChanges indicates that the provider will replace the resource when
	// this property is changed. This property is used exclusively for docs.
	WillReplaceOnChanges bool `json:"willReplaceOnChanges,omitempty" yaml:"willReplaceOnChanges,omitempty"`
}

PropertySpec is the serializable form of an object or resource property.

type RawMessage 

type RawMessage []byte

func (RawMessage) MarshalJSON 

func (m RawMessage) MarshalJSON() ([]byte, error)

func (RawMessage) MarshalYAML 

func (m RawMessage) MarshalYAML() ([]byte, error)

func (*RawMessage) UnmarshalJSON 

func (m *RawMessage) UnmarshalJSON(bytes []byte) error

func (*RawMessage) UnmarshalYAML 

func (m *RawMessage) UnmarshalYAML(node *yaml.Node) error

type ReferenceLoader 

type ReferenceLoader interface {
	Loader

	// deprecated: use LoadPackageReferenceV2
	LoadPackageReference(pkg string, version *semver.Version) (PackageReference, error)

	LoadPackageReferenceV2(ctx context.Context, descriptor *PackageDescriptor) (PackageReference, error)
}

func NewCachedLoader 

func NewCachedLoader(loader ReferenceLoader) ReferenceLoader

func NewPluginLoader 

func NewPluginLoader(host plugin.Host) ReferenceLoader

type ReferenceRenderer 

type ReferenceRenderer func(r *Renderer, w io.Writer, source []byte, link *ast.Link, enter bool) (ast.WalkStatus, error)

A ReferenceRenderer is responsible for rendering references to entities in a schema.

type Renderer 

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

A Renderer provides the ability to render parsed documentation back to Markdown source.

func (*Renderer) MarkdownRenderer 

func (r *Renderer) MarkdownRenderer() *markdown.Renderer

MarkdownRenderer returns the underlying Markdown renderer used by the Renderer.

func (*Renderer) RegisterFuncs 

func (r *Renderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer)

type RendererOption 

type RendererOption func(*Renderer)

A RendererOption controls the behavior of a Renderer.

func WithReferenceRenderer 

func WithReferenceRenderer(refRenderer ReferenceRenderer) RendererOption

WithReferenceRenderer sets the reference renderer for a renderer.

type Resource 

type Resource struct {
	// PackageReference is the PackageReference that defines the resource.
	PackageReference PackageReference
	// Token is the resource's Codeinfra type token.
	Token string
	// Comment is the description of the resource, if any.
	Comment string
	// IsProvider is true if the resource is a provider resource.
	IsProvider bool
	// InputProperties is the list of the resource's input properties.
	InputProperties []*Property
	// Properties is the list of the resource's output properties. This should be a superset of the input properties.
	Properties []*Property
	// StateInputs is the set of inputs used to get an existing resource, if any.
	StateInputs *ObjectType
	// Aliases is the list of aliases for the resource.
	Aliases []*Alias
	// DeprecationMessage indicates whether or not the resource is deprecated.
	DeprecationMessage string
	// Language specifies additional language-specific data about the resource.
	Language map[string]interface{}
	// IsComponent indicates whether the resource is a ComponentResource.
	IsComponent bool
	// Methods is the list of methods for the resource.
	Methods []*Method
	// IsOverlay indicates whether the type is an overlay provided by the package. Overlay code is generated by the
	// package rather than using the core Codeinfra codegen libraries.
	IsOverlay bool
	// OverlaySupportedLanguages indicates what languages the overlay supports. This only has an effect if
	// the Resource is an Overlay (IsOverlay == true).
	// Supported values are "nodejs", "python", "go", "csharp", "java", "yaml"
	OverlaySupportedLanguages []string
}

Resource describes a Codeinfra resource.

func (*Resource) ReplaceOnChanges 

func (r *Resource) ReplaceOnChanges() (changes [][]*Property, err []error)

The set of resource paths where ReplaceOnChanges is true.

For example, if you have the following resource struct:

Resource A { 

Properties: {
	 Object B {
	   Object D: {
	     ReplaceOnChanges: true
	     }
	   Object F: {}
    }
	 Object C {
	   ReplaceOnChanges: true
	   }
  }
}

A.ReplaceOnChanges() == [[B, D], [C]]

type ResourceSpec 

type ResourceSpec struct {
	ObjectTypeSpec `yaml:",inline"`

	// InputProperties is a map from property name to PropertySpec that describes the resource's input properties.
	InputProperties map[string]PropertySpec `json:"inputProperties,omitempty" yaml:"inputProperties,omitempty"`
	// RequiredInputs is a list of the names of the resource's required input properties.
	RequiredInputs []string `json:"requiredInputs,omitempty" yaml:"requiredInputs,omitempty"`
	// PlainInputs was a list of the names of the resource's plain input properties. This property is ignored:
	// instead, property types should be marked as plain where necessary.
	PlainInputs []string `json:"plainInputs,omitempty" yaml:"plainInputs,omitempty"`
	// StateInputs is an optional ObjectTypeSpec that describes additional inputs that may be necessary to get an
	// existing resource. If this is unset, only an ID is necessary.
	StateInputs *ObjectTypeSpec `json:"stateInputs,omitempty" yaml:"stateInputs,omitempty"`
	// Aliases is the list of aliases for the resource.
	Aliases []AliasSpec `json:"aliases,omitempty" yaml:"aliases,omitempty"`
	// DeprecationMessage indicates whether or not the resource is deprecated.
	DeprecationMessage string `json:"deprecationMessage,omitempty" yaml:"deprecationMessage,omitempty"`
	// IsComponent indicates whether the resource is a ComponentResource.
	IsComponent bool `json:"isComponent,omitempty" yaml:"isComponent,omitempty"`
	// Methods maps method names to functions in this schema.
	Methods map[string]string `json:"methods,omitempty" yaml:"methods,omitempty"`
}

ResourceSpec is the serializable form of a resource description.

type ResourceType 

type ResourceType struct {
	// Token is the type's Codeinfra type token.
	Token string
	// Resource is the type's underlying resource.
	Resource *Resource
}

func (*ResourceType) String 

func (t *ResourceType) String() string

type ResourcesIter 

type ResourcesIter interface {
	Token() string
	Resource() (*Resource, error)
	Next() bool
}

ResourcesIter is an iterator for ranging over a package's resources. See PackageResources.Range.

type ReturnTypeSpec 

type ReturnTypeSpec struct {
	ObjectTypeSpec *ObjectTypeSpec

	// If ObjectTypeSpec is non-nil, it can also be marked with ObjectTypeSpecIsPlain: true
	// indicating that the generated code should not wrap in the result in an Output but return
	// it directly. This option is incompatible with marking individual properties with
	// ObjectTypSpec.Plain.
	ObjectTypeSpecIsPlain bool

	TypeSpec *TypeSpec
}

ReturnTypeSpec is either ObjectTypeSpec or TypeSpec.

func (*ReturnTypeSpec) MarshalJSON 

func (returnTypeSpec *ReturnTypeSpec) MarshalJSON() ([]byte, error)

func (*ReturnTypeSpec) UnmarshalJSON 

func (returnTypeSpec *ReturnTypeSpec) UnmarshalJSON(inputJSON []byte) error

func (*ReturnTypeSpec) UnmarshalReturnTypeSpec 

func (returnTypeSpec *ReturnTypeSpec) UnmarshalReturnTypeSpec(data []byte, decode Decoder) error

Deprecated.

func (*ReturnTypeSpec) UnmarshalYAML 

func (returnTypeSpec *ReturnTypeSpec) UnmarshalYAML(inputYAML []byte) error

Deprecated.

type Shortcode 

type Shortcode struct {
	ast.BaseBlock

	// Name is the name of the shortcode.
	Name []byte
}

Shortcode represents a shortcode element and its contents, e.g. `{{% examples %}}`.

func NewShortcode 

func NewShortcode(name []byte) *Shortcode

NewShortcode creates a new shortcode with the given name.

func (*Shortcode) Dump 

func (s *Shortcode) Dump(w io.Writer, source []byte, level int)

func (*Shortcode) Kind 

func (*Shortcode) Kind() ast.NodeKind

Kind implements ast.Node.Kind.

type TokenType 

type TokenType struct {
	// Token is the type's Codeinfra type token.
	Token string
	// Underlying type is the type's underlying type, if any.
	UnderlyingType Type
}

TokenType represents an opaque type that is referred to only by its token. A TokenType may have an underlying type that can be used in place of the token.

func (*TokenType) String 

func (t *TokenType) String() string

type Type 

type Type interface {
	String() string
	// contains filtered or unexported methods
}

Type represents a datatype in the Codeinfra Schema. Types created by this package are identical if they are equal values. 

var (
	// BoolType represents the set of boolean values.
	BoolType Type = boolType
	// IntType represents the set of 32-bit integer values.
	IntType Type = intType
	// NumberType represents the set of IEEE754 double-precision values.
	NumberType Type = numberType
	// StringType represents the set of UTF-8 string values.
	StringType Type = stringType
	// ArchiveType represents the set of Codeinfra Archive values.
	ArchiveType Type = archiveType
	// AssetType represents the set of Codeinfra Asset values.
	AssetType Type = assetType
	// JSONType represents the set of JSON-encoded values.
	JSONType Type = jsonType
	// AnyType represents the complete set of values.
	AnyType Type = anyType
	// AnyResourceType represents any Codeinfra resource - custom or component
	AnyResourceType Type = anyResourceType
)

type TypeSpec 

type TypeSpec struct {
	// Type is the primitive or composite type, if any. May be "boolean", "string", "integer", "number", "array", or
	// "object".
	Type string `json:"type,omitempty" yaml:"type,omitempty"`
	// Ref is a reference to a type in this or another document. For example, the built-in Archive, Asset, and Any
	// types are referenced as "codeinfra.json#/Archive", "codeinfra.json#/Asset", and "codeinfra.json#/Any", respectively.
	// A type from this document is referenced as "#/types/codeinfra:type:token".
	// A type from another document is referenced as "path#/types/codeinfra:type:token", where path is of the form:
	//   "/provider/vX.Y.Z/schema.json" or "codeinfra.json" or "http[s]://example.com/provider/vX.Y.Z/schema.json"
	// A resource from this document is referenced as "#/resources/codeinfra:type:token".
	// A resource from another document is referenced as "path#/resources/codeinfra:type:token", where path is of the form:
	//   "/provider/vX.Y.Z/schema.json" or "codeinfra.json" or "http[s]://example.com/provider/vX.Y.Z/schema.json"
	Ref string `json:"$ref,omitempty" yaml:"$ref,omitempty"`
	// AdditionalProperties, if set, describes the element type of an "object" (i.e. a string -> value map).
	AdditionalProperties *TypeSpec `json:"additionalProperties,omitempty" yaml:"additionalProperties,omitempty"`
	// Items, if set, describes the element type of an array.
	Items *TypeSpec `json:"items,omitempty" yaml:"items,omitempty"`
	// OneOf indicates that values of the type may be one of any of the listed types.
	OneOf []TypeSpec `json:"oneOf,omitempty" yaml:"oneOf,omitempty"`
	// Discriminator informs the consumer of an alternative schema based on the value associated with it.
	Discriminator *DiscriminatorSpec `json:"discriminator,omitempty" yaml:"discriminator,omitempty"`
	// Plain indicates that when used as an input, this type does not accept eventual values.
	Plain bool `json:"plain,omitempty" yaml:"plain,omitempty"`
}

TypeSpec is the serializable form of a reference to a type.

type TypesIter 

type TypesIter interface {
	Token() string
	Type() (Type, error)
	Next() bool
}

TypesIter is an iterator for ranging over a package's types. See PackageTypes.Range.

type UnionType 

type UnionType struct {
	// ElementTypes are the allowable types for the union type.
	ElementTypes []Type
	// DefaultType is the default type, if any, for the union type. This can be used by targets that do not support
	// unions, or in positions where unions are not appropriate.
	DefaultType Type
	// Discriminator informs the consumer of an alternative schema based on the value associated with it.
	Discriminator string
	// Mapping is an optional object to hold mappings between payload values and schema names or references.
	Mapping map[string]string
}

UnionType represents values that may be any one of a specified set of types.

func (*UnionType) String 

func (t *UnionType) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.