type (
	A  lA[A]            // ERROR "invalid recursive type"
	S  lS[S]            // ERROR "invalid recursive type"
	P  lP[P]            // ok (indirection through lP)
	M1 lM[int, M1]      // ok (indirection through lM)
	M2 lM[lA[byte], M2] // ok (indirection through lM)

	A2 lA[lS[lP[A2]]] // ok (indirection through lP)
	A3 lA[lS[lS[A3]]] // ERROR "invalid recursive type"
)

// cycles through imported types
type (

import org.codelibs.fess.mylasta.direction.sponsor.FessTimeResourceProvider;
import org.codelibs.fess.mylasta.direction.sponsor.FessUserLocaleProcessProvider;
import org.codelibs.fess.mylasta.direction.sponsor.FessUserTimeZoneProcessProvider;
import org.lastaflute.core.direction.CachedFwAssistantDirector;
import org.lastaflute.core.direction.FwAssistDirection;

    // source: 'classKinds.kt'
}

public final enum class Direction {
    // source: 'classKinds.kt'
    private synthetic final static field $ENTRIES: kotlin.enums.EnumEntries
    private synthetic final static field $VALUES: Direction[]
    public final enum static field EAST: Direction
    public final enum static field NORTH: Direction
    public final enum static field SOUTH: Direction
    public final enum static field WEST: Direction

                  (strdict "istio.io/rev" (.Revision | default "default"))
                  (strdict
                    "ambient.istio.io/redirection" "disabled"
                    "prometheus.io/path" "/stats/prometheus"
                    "prometheus.io/port" "15020"
                    "prometheus.io/scrape" "true"
                  ) | nindent 8 }}

        this.redirector = redirector;
        this.outForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdOut);
        this.errForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdErr);
    }

    public void startRedirecting() {
        assert outForwarder.outputOwner != null;
        assert errForwarder.outputOwner != null;

kind: Service
metadata:
  name: registry-redirector
  labels:
    app: registry-redirector
spec:
  type: LoadBalancer
  ports:
  - name: http
    port: 1338
  selector:
    app: registry-redirector
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: registry-redirector
spec:
  replicas: 1
  selector:
    matchLabels:
      app: registry-redirector
  template:
    metadata:
      labels:

      ENUM_ENTRY name:WEST
        init: EXPRESSION_BODY
          ENUM_CONSTRUCTOR_CALL 'private constructor <init> () [primary] declared in <root>.Direction'
      ENUM_ENTRY name:EAST
        init: EXPRESSION_BODY
          ENUM_CONSTRUCTOR_CALL 'private constructor <init> () [primary] declared in <root>.Direction'
      CONSTRUCTOR visibility:private <> () returnType:<root>.Direction [primary]

)

// Instance represents a deployed registry redirector app instance.
type Instance interface {
	// Address is the address of the service provided by the
	// registry redirector server.
	Address() string

	// SetupTagMap posts the tag map to the registryredirector.
	SetupTagMap(map[string]string) error
}

// Config defines the options for creating an registry redirector component.
type Config struct {

	testKube "istio.io/istio/pkg/test/kube"
	"istio.io/istio/pkg/test/scopes"
	"istio.io/istio/pkg/test/util/retry"
)

const (
	service     = "registry-redirector"
	ns          = "registry-redirector"
	podSelector = "app=registry-redirector"
)

var (
	_ Instance  = &kubeComponent{}
	_ io.Closer = &kubeComponent{}
)

type kubeComponent struct {
	id        resource.ID
	ns        namespace.Instance

}

// IsLeftToRight reports whether the principle direction of rendering for this
// paragraphs is left-to-right. If this returns false, the principle direction
// of rendering is right-to-left.
func (p *Paragraph) IsLeftToRight() bool {
	return p.Direction() == LeftToRight
}

// Direction returns the direction of the text of this paragraph.
//
// The direction may be LeftToRight, RightToLeft, Mixed, or Neutral.