generated

type Constraint[T Number | string | bool] func(actual T) error

type ContextArea struct {

	// The elements to be incorporated into the context area.  These elements will be rendered in the sequence they appear in the array.
	Elements []ElementSpec `json:"elements"`

	// The microfrontends referenced by any of the elements. The browser triggers the loading of microfrontend resources when the element is rendered.
	Microfrontends map[string]MicrofrontendSpec `json:"microfrontends,omitempty"`
}

type ElementSpec struct {

	// The name of the microfrontend to which the element belongs. The browser  loads the microfrontend before rendering the element.  If this property is not provided, it's assumed that the browser has already  loaded all necessary resources for the element prior to rendering.
	Microfrontend string `json:"microfrontend,omitempty"`

	// The name of the element, which corresponds to its tag name used in the document flow.
	TagName string `json:"tagName"`

	// Attributes to be assigned to the element during rendering.
	Attributes map[string]string `json:"attributes,omitempty"`

	// The styles of the element. Primarily intended as a fallback for specific cases,  such as setting CSS variables.
	Style map[string]string `json:"style,omitempty"`
}

type ErrorHandler func(w http.ResponseWriter, r *http.Request, err error, result *ImplResponse)

type ImplResponse struct {
	Code    int
	Headers map[string][]string
	Body    interface{}
}

type MicrofrontendResource struct {

	// The type of the resource. This could be a script, stylesheet, or any other `link` element.
	Kind string `json:"kind,omitempty"`

	// The URL of the resource. This URL is usually relative to the application's base URL  and is typically served as a subpath  of `<base_href>/polyfea/webcomponent/<microfrontend-name>/<resource-path...>`.
	Href string `json:"href,omitempty"`

	// Additional attributes to be assigned to the `link` or `script` element,  alongside the `rel` and `href` attributes.
	Attributes map[string]string `json:"attributes,omitempty"`

	// If set to `true`, the browser will complete loading the resource before it finishes  loading the microfrontend. If set to `false`, the browser will load the resource  asynchronously, allowing for continued loading and rendering in the meantime.
	WaitOnLoad bool `json:"waitOnLoad,omitempty"`
}

type MicrofrontendSpec struct {

	// The microfrontends that this microfrontend depends on.  The specification of these dependencies is provided in the context area information.
	DependsOn []string `json:"dependsOn,omitempty"`

	// A shorthand for the microfrontend script module resource. The browser loads this module before rendering the elements. If the module has dependencies on other resources, it may load them itself, provided their references are given as a relative path to the module.
	Module string `json:"module,omitempty"`

	// The resources that the browser should load. Only resources that need to be directly  loaded into the document's `head` element should be specified here. Typical examples  include fonts and stylesheets that must be globally available.
	Resources []MicrofrontendResource `json:"resources,omitempty"`
}

type Number interface {
	~int32 | ~int64 | ~float32 | ~float64
}

type Operation[T Number | string | bool] func(actual string) (T, bool, error)

type ParseString[T Number | string | bool] func(v string) (T, error)

type ParsingError struct {
	Err error
}

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

type PolyfeaAPIOption func(*PolyfeaAPIController)

type PolyfeaAPIRouter interface {
	GetContextArea(http.ResponseWriter, *http.Request, http.Header)
	GetStaticConfig(http.ResponseWriter, *http.Request, http.Header)
}

type PolyfeaAPIServicer interface {
	GetContextArea(context.Context, string, string, int32, http.Header) (ImplResponse, error)
	GetStaticConfig(context.Context, http.Header) (ImplResponse, error)
}

type RequiredError struct {
	Field string
}

type Route struct {
	Method      string
	Pattern     string
	HandlerFunc http.HandlerFunc
}

type Router interface {
	Routes() Routes
}

type Routes map[string]Route

type StaticConfig struct {

	// A list of context areas along with their elements. Each context area is identified by its  name and the regex path where it's rendered. In the event of a conflict, the first matching  context area is selected.
	ContextAreas []StaticConfigArea `json:"contextAreas,omitempty"`

	// A dictionary of microfrontends, each identified by its unique name.
	Microfrontends map[string]MicrofrontendSpec `json:"microfrontends"`
}

type StaticConfigArea struct {

	// Name of the context area.
	Name string `json:"name"`

	// The regular expression used to match the path relative to the base href  where this context area should be applied. If no path is provided, the  context area specification applies to all paths. In the event of conflicts,  the first matching context area is used.
	Path string `json:"path,omitempty"`

	ContextArea ContextArea `json:"contextArea,omitempty"`
}