
---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.5.0
  creationTimestamp: null
  name: httproutes.networking.x-k8s.io
spec:
  group: networking.x-k8s.io
  names:
    categories:
    - gateway-api
    kind: HTTPRoute
    listKind: HTTPRouteList
    plural: httproutes
    singular: httproute
  scope: Namespaced
  versions:
  - additionalPrinterColumns:
    - jsonPath: .spec.hostnames
      name: Hostnames
      type: string
    - jsonPath: .metadata.creationTimestamp
      name: Age
      type: date
    name: v1alpha1
    schema:
      openAPIV3Schema:
        description: HTTPRoute is the Schema for the HTTPRoute resource.
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
              of an object. Servers should convert recognized schemas to the latest
              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
              object represents. Servers may infer this from the endpoint the client
              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: Spec defines the desired state of HTTPRoute.
            properties:
              gateways:
                default:
                  allow: SameNamespace
                description: Gateways defines which Gateways can use this Route.
                properties:
                  allow:
                    default: SameNamespace
                    description: 'Allow indicates which Gateways will be allowed to
                      use this route. Possible values are: * All: Gateways in any
                      namespace can use this route. * FromList: Only Gateways specified
                      in GatewayRefs may use this route. * SameNamespace: Only Gateways
                      in the same namespace may use this route.'
                    enum:
                    - All
                    - FromList
                    - SameNamespace
                    type: string
                  gatewayRefs:
                    description: GatewayRefs must be specified when Allow is set to
                      "FromList". In that case, only Gateways referenced in this list
                      will be allowed to use this route. This field is ignored for
                      other values of "Allow".
                    items:
                      description: GatewayReference identifies a Gateway in a specified
                        namespace.
                      properties:
                        name:
                          description: Name is the name of the referent.
                          maxLength: 253
                          minLength: 1
                          type: string
                        namespace:
                          description: Namespace is the namespace of the referent.
                          maxLength: 253
                          minLength: 1
                          type: string
                      required:
                      - name
                      - namespace
                      type: object
                    type: array
                type: object
              hostnames:
                description: "Hostnames defines a set of hostname that should match
                  against the HTTP Host header to select a HTTPRoute to process the
                  request. Hostname is the fully qualified domain name of a network
                  host, as defined by RFC 3986. Note the following deviations from
                  the \"host\" part of the URI as defined in the RFC: \n 1. IPs are
                  not allowed. 2. The `:` delimiter is not respected because ports
                  are not allowed. \n Incoming requests are matched against the hostnames
                  before the HTTPRoute rules. If no hostname is specified, traffic
                  is routed based on the HTTPRouteRules. \n Hostname can be \"precise\"
                  which is a domain name without the terminating dot of a network
                  host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
                  name prefixed with a single wildcard label (e.g. `*.example.com`).
                  The wildcard character `*` must appear by itself as the first DNS
                  label and matches only a single label. You cannot have a wildcard
                  label by itself (e.g. Host == `*`). Requests will be matched against
                  the Host field in the following order: \n 1. If Host is precise,
                  the request matches this rule if    the HTTP Host header is equal
                  to Host. 2. If Host is a wildcard, then the request matches this
                  rule if    the HTTP Host header is to equal to the suffix    (removing
                  the first label) of the wildcard rule. \n Support: Core"
                items:
                  description: Hostname is used to specify a hostname that should
                    be matched.
                  maxLength: 253
                  minLength: 1
                  type: string
                maxItems: 16
                type: array
              rules:
                default:
                - matches:
                  - path:
                      type: Prefix
                      value: /
                description: Rules are a list of HTTP matchers, filters and actions.
                items:
                  description: HTTPRouteRule defines semantics for matching an HTTP
                    request based on conditions, optionally executing additional processing
                    steps, and forwarding the request to an API object.
                  properties:
                    filters:
                      description: "Filters define the filters that are applied to
                        requests that match this rule. \n The effects of ordering
                        of multiple behaviors are currently unspecified. This can
                        change in the future based on feedback during the alpha stage.
                        \n Conformance-levels at this level are defined based on the
                        type of filter: \n - ALL core filters MUST be supported by
                        all implementations. - Implementers are encouraged to support
                        extended filters. - Implementation-specific custom filters
                        have no API guarantees across   implementations. \n Specifying
                        a core filter multiple times has unspecified or custom conformance.
                        \n Support: Core"
                      items:
                        description: 'HTTPRouteFilter defines additional processing
                          steps that must be completed during the request or response
                          lifecycle. HTTPRouteFilters are meant as an extension point
                          to express additional processing that may be done in Gateway
                          implementations. Some examples include request or response
                          modification, implementing authentication strategies, rate-limiting,
                          and traffic shaping. API guarantee/conformance is defined
                          based on the type of the filter. TODO(hbagdi): re-render
                          CRDs once controller-tools supports union tags: - https://github.com/kubernetes-sigs/controller-tools/pull/298
                          - https://github.com/kubernetes-sigs/controller-tools/issues/461'
                        properties:
                          extensionRef:
                            description: "ExtensionRef is an optional, implementation-specific
                              extension to the \"filter\" behavior.  For example,
                              resource \"myroutefilter\" in group \"networking.acme.io\").
                              ExtensionRef MUST NOT be used for core and extended
                              filters. \n Support: Implementation-specific"
                            properties:
                              group:
                                description: Group is the group of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              kind:
                                description: Kind is kind of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              name:
                                description: Name is the name of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                            required:
                            - group
                            - kind
                            - name
                            type: object
                          requestHeaderModifier:
                            description: "RequestHeaderModifier defines a schema for
                              a filter that modifies request headers. \n Support:
                              Core"
                            properties:
                              add:
                                additionalProperties:
                                  type: string
                                description: "Add adds the given header (name, value)
                                  to the request before the action. It appends to
                                  any existing values associated with the header name.
                                  \n Input:   GET /foo HTTP/1.1   my-header: foo \n
                                  Config:   add: {\"my-header\": \"bar\"} \n Output:
                                  \  GET /foo HTTP/1.1   my-header: foo   my-header:
                                  bar \n Support: Extended"
                                type: object
                              remove:
                                description: "Remove the given header(s) from the
                                  HTTP request before the action. The value of RemoveHeader
                                  is a list of HTTP header names. Note that the header
                                  names are case-insensitive [RFC-2616 4.2]. \n Input:
                                  \  GET /foo HTTP/1.1   my-header1: foo   my-header2:
                                  bar   my-header3: baz \n Config:   remove: [\"my-header1\",
                                  \"my-header3\"] \n Output:   GET /foo HTTP/1.1   my-header2:
                                  bar \n Support: Extended"
                                items:
                                  type: string
                                maxItems: 16
                                type: array
                              set:
                                additionalProperties:
                                  type: string
                                description: "Set overwrites the request with the
                                  given header (name, value) before the action. \n
                                  Input:   GET /foo HTTP/1.1   my-header: foo \n Config:
                                  \  set: {\"my-header\": \"bar\"} \n Output:   GET
                                  /foo HTTP/1.1   my-header: bar \n Support: Extended"
                                type: object
                            type: object
                          requestMirror:
                            description: "RequestMirror defines a schema for a filter
                              that mirrors requests. \n Support: Extended"
                            properties:
                              backendRef:
                                description: "BackendRef is a local object reference
                                  to mirror matched requests to. If both BackendRef
                                  and ServiceName are specified, ServiceName will
                                  be given precedence. \n If the referent cannot be
                                  found, the rule is not included in the route. The
                                  controller should raise the \"ResolvedRefs\" condition
                                  on the Gateway with the \"DegradedRoutes\" reason.
                                  The gateway status for this route should be updated
                                  with a condition that describes the error more specifically.
                                  \n Support: Custom"
                                properties:
                                  group:
                                    description: Group is the group of the referent.
                                    maxLength: 253
                                    minLength: 1
                                    type: string
                                  kind:
                                    description: Kind is kind of the referent.
                                    maxLength: 253
                                    minLength: 1
                                    type: string
                                  name:
                                    description: Name is the name of the referent.
                                    maxLength: 253
                                    minLength: 1
                                    type: string
                                required:
                                - group
                                - kind
                                - name
                                type: object
                              port:
                                description: "Port specifies the destination port
                                  number to use for the backend referenced by the
                                  ServiceName or BackendRef field. \n If unspecified,
                                  the destination port in the request is used when
                                  forwarding to a backendRef or serviceName."
                                format: int32
                                maximum: 65535
                                minimum: 1
                                type: integer
                              serviceName:
                                description: "ServiceName refers to the name of the
                                  Service to mirror matched requests to. When specified,
                                  this takes the place of BackendRef. If both BackendRef
                                  and ServiceName are specified, ServiceName will
                                  be given precedence. \n If the referent cannot be
                                  found, the rule is not included in the route. The
                                  controller should raise the \"ResolvedRefs\" condition
                                  on the Gateway with the \"DegradedRoutes\" reason.
                                  The gateway status for this route should be updated
                                  with a condition that describes the error more specifically.
                                  \n Support: Core"
                                maxLength: 253
                                type: string
                            type: object
                          type:
                            description: "Type identifies the type of filter to apply.
                              As with other API fields, types are classified into
                              three conformance levels: \n - Core: Filter types and
                              their corresponding configuration defined by   \"Support:
                              Core\" in this package, e.g. \"RequestHeaderModifier\".
                              All   implementations must support core filters. \n
                              - Extended: Filter types and their corresponding configuration
                              defined by   \"Support: Extended\" in this package,
                              e.g. \"RequestMirror\". Implementers   are encouraged
                              to support extended filters. \n - Custom: Filters that
                              are defined and supported by specific vendors.   In
                              the future, filters showing convergence in behavior
                              across multiple   implementations will be considered
                              for inclusion in extended or core   conformance levels.
                              Filter-specific configuration for such filters   is
                              specified using the ExtensionRef field. `Type` should
                              be set to   \"ExtensionRef\" for custom filters. \n
                              Implementers are encouraged to define custom implementation
                              types to extend the core API with implementation-specific
                              behavior."
                            enum:
                            - RequestHeaderModifier
                            - RequestMirror
                            - ExtensionRef
                            type: string
                        required:
                        - type
                        type: object
                      maxItems: 16
                      type: array
                    forwardTo:
                      description: ForwardTo defines the backend(s) where matching
                        requests should be sent. If unspecified, the rule performs
                        no forwarding. If unspecified and no filters are specified
                        that would result in a response being sent, a 503 error code
                        is returned.
                      items:
                        description: HTTPRouteForwardTo defines how a HTTPRoute should
                          forward a request.
                        properties:
                          backendRef:
                            description: "BackendRef is a reference to a backend to
                              forward matched requests to. If both BackendRef and
                              ServiceName are specified, ServiceName will be given
                              precedence. \n If the referent cannot be found, the
                              route must be dropped from the Gateway. The controller
                              should raise the \"ResolvedRefs\" condition on the Gateway
                              with the \"DegradedRoutes\" reason. The gateway status
                              for this route should be updated with a condition that
                              describes the error more specifically. \n Support: Custom"
                            properties:
                              group:
                                description: Group is the group of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              kind:
                                description: Kind is kind of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              name:
                                description: Name is the name of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                            required:
                            - group
                            - kind
                            - name
                            type: object
                          filters:
                            description: "Filters defined at this-level should be
                              executed if and only if the request is being forwarded
                              to the backend defined here. \n Support: Custom (For
                              broader support of filters, use the Filters field in
                              HTTPRouteRule.)"
                            items:
                              description: 'HTTPRouteFilter defines additional processing
                                steps that must be completed during the request or
                                response lifecycle. HTTPRouteFilters are meant as
                                an extension point to express additional processing
                                that may be done in Gateway implementations. Some
                                examples include request or response modification,
                                implementing authentication strategies, rate-limiting,
                                and traffic shaping. API guarantee/conformance is
                                defined based on the type of the filter. TODO(hbagdi):
                                re-render CRDs once controller-tools supports union
                                tags: - https://github.com/kubernetes-sigs/controller-tools/pull/298
                                - https://github.com/kubernetes-sigs/controller-tools/issues/461'
                              properties:
                                extensionRef:
                                  description: "ExtensionRef is an optional, implementation-specific
                                    extension to the \"filter\" behavior.  For example,
                                    resource \"myroutefilter\" in group \"networking.acme.io\").
                                    ExtensionRef MUST NOT be used for core and extended
                                    filters. \n Support: Implementation-specific"
                                  properties:
                                    group:
                                      description: Group is the group of the referent.
                                      maxLength: 253
                                      minLength: 1
                                      type: string
                                    kind:
                                      description: Kind is kind of the referent.
                                      maxLength: 253
                                      minLength: 1
                                      type: string
                                    name:
                                      description: Name is the name of the referent.
                                      maxLength: 253
                                      minLength: 1
                                      type: string
                                  required:
                                  - group
                                  - kind
                                  - name
                                  type: object
                                requestHeaderModifier:
                                  description: "RequestHeaderModifier defines a schema
                                    for a filter that modifies request headers. \n
                                    Support: Core"
                                  properties:
                                    add:
                                      additionalProperties:
                                        type: string
                                      description: "Add adds the given header (name,
                                        value) to the request before the action. It
                                        appends to any existing values associated
                                        with the header name. \n Input:   GET /foo
                                        HTTP/1.1   my-header: foo \n Config:   add:
                                        {\"my-header\": \"bar\"} \n Output:   GET
                                        /foo HTTP/1.1   my-header: foo   my-header:
                                        bar \n Support: Extended"
                                      type: object
                                    remove:
                                      description: "Remove the given header(s) from
                                        the HTTP request before the action. The value
                                        of RemoveHeader is a list of HTTP header names.
                                        Note that the header names are case-insensitive
                                        [RFC-2616 4.2]. \n Input:   GET /foo HTTP/1.1
                                        \  my-header1: foo   my-header2: bar   my-header3:
                                        baz \n Config:   remove: [\"my-header1\",
                                        \"my-header3\"] \n Output:   GET /foo HTTP/1.1
                                        \  my-header2: bar \n Support: Extended"
                                      items:
                                        type: string
                                      maxItems: 16
                                      type: array
                                    set:
                                      additionalProperties:
                                        type: string
                                      description: "Set overwrites the request with
                                        the given header (name, value) before the
                                        action. \n Input:   GET /foo HTTP/1.1   my-header:
                                        foo \n Config:   set: {\"my-header\": \"bar\"}
                                        \n Output:   GET /foo HTTP/1.1   my-header:
                                        bar \n Support: Extended"
                                      type: object
                                  type: object
                                requestMirror:
                                  description: "RequestMirror defines a schema for
                                    a filter that mirrors requests. \n Support: Extended"
                                  properties:
                                    backendRef:
                                      description: "BackendRef is a local object reference
                                        to mirror matched requests to. If both BackendRef
                                        and ServiceName are specified, ServiceName
                                        will be given precedence. \n If the referent
                                        cannot be found, the rule is not included
                                        in the route. The controller should raise
                                        the \"ResolvedRefs\" condition on the Gateway
                                        with the \"DegradedRoutes\" reason. The gateway
                                        status for this route should be updated with
                                        a condition that describes the error more
                                        specifically. \n Support: Custom"
                                      properties:
                                        group:
                                          description: Group is the group of the referent.
                                          maxLength: 253
                                          minLength: 1
                                          type: string
                                        kind:
                                          description: Kind is kind of the referent.
                                          maxLength: 253
                                          minLength: 1
                                          type: string
                                        name:
                                          description: Name is the name of the referent.
                                          maxLength: 253
                                          minLength: 1
                                          type: string
                                      required:
                                      - group
                                      - kind
                                      - name
                                      type: object
                                    port:
                                      description: "Port specifies the destination
                                        port number to use for the backend referenced
                                        by the ServiceName or BackendRef field. \n
                                        If unspecified, the destination port in the
                                        request is used when forwarding to a backendRef
                                        or serviceName."
                                      format: int32
                                      maximum: 65535
                                      minimum: 1
                                      type: integer
                                    serviceName:
                                      description: "ServiceName refers to the name
                                        of the Service to mirror matched requests
                                        to. When specified, this takes the place of
                                        BackendRef. If both BackendRef and ServiceName
                                        are specified, ServiceName will be given precedence.
                                        \n If the referent cannot be found, the rule
                                        is not included in the route. The controller
                                        should raise the \"ResolvedRefs\" condition
                                        on the Gateway with the \"DegradedRoutes\"
                                        reason. The gateway status for this route
                                        should be updated with a condition that describes
                                        the error more specifically. \n Support: Core"
                                      maxLength: 253
                                      type: string
                                  type: object
                                type:
                                  description: "Type identifies the type of filter
                                    to apply. As with other API fields, types are
                                    classified into three conformance levels: \n -
                                    Core: Filter types and their corresponding configuration
                                    defined by   \"Support: Core\" in this package,
                                    e.g. \"RequestHeaderModifier\". All   implementations
                                    must support core filters. \n - Extended: Filter
                                    types and their corresponding configuration defined
                                    by   \"Support: Extended\" in this package, e.g.
                                    \"RequestMirror\". Implementers   are encouraged
                                    to support extended filters. \n - Custom: Filters
                                    that are defined and supported by specific vendors.
                                    \  In the future, filters showing convergence
                                    in behavior across multiple   implementations
                                    will be considered for inclusion in extended or
                                    core   conformance levels. Filter-specific configuration
                                    for such filters   is specified using the ExtensionRef
                                    field. `Type` should be set to   \"ExtensionRef\"
                                    for custom filters. \n Implementers are encouraged
                                    to define custom implementation types to extend
                                    the core API with implementation-specific behavior."
                                  enum:
                                  - RequestHeaderModifier
                                  - RequestMirror
                                  - ExtensionRef
                                  type: string
                              required:
                              - type
                              type: object
                            maxItems: 16
                            type: array
                          port:
                            description: "Port specifies the destination port number
                              to use for the backend referenced by the ServiceName
                              or BackendRef field. If unspecified, the destination
                              port in the request is used when forwarding to a backendRef
                              or serviceName. \n Support: Core"
                            format: int32
                            maximum: 65535
                            minimum: 1
                            type: integer
                          serviceName:
                            description: "ServiceName refers to the name of the Service
                              to forward matched requests to. When specified, this
                              takes the place of BackendRef. If both BackendRef and
                              ServiceName are specified, ServiceName will be given
                              precedence. \n If the referent cannot be found, the
                              route must be dropped from the Gateway. The controller
                              should raise the \"ResolvedRefs\" condition on the Gateway
                              with the \"DegradedRoutes\" reason. The gateway status
                              for this route should be updated with a condition that
                              describes the error more specifically. \n The protocol
                              to use should be specified with the AppProtocol field
                              on Service resources. This field was introduced in Kubernetes
                              1.18. If using an earlier version of Kubernetes, a `networking.x-k8s.io/app-protocol`
                              annotation on the BackendPolicy resource may be used
                              to define the protocol. If the AppProtocol field is
                              available, this annotation should not be used. The AppProtocol
                              field, when populated, takes precedence over the annotation
                              in the BackendPolicy resource. For custom backends,
                              it is encouraged to add a semantically-equivalent field
                              in the Custom Resource Definition. \n Support: Core"
                            maxLength: 253
                            type: string
                          weight:
                            default: 1
                            description: "Weight specifies the proportion of HTTP
                              requests forwarded to the backend referenced by the
                              ServiceName or BackendRef field. This is computed as
                              weight/(sum of all weights in this ForwardTo list).
                              For non-zero values, there may be some epsilon from
                              the exact proportion defined here depending on the precision
                              an implementation supports. Weight is not a percentage
                              and the sum of weights does not need to equal 100. \n
                              If only one backend is specified and it has a weight
                              greater than 0, 100% of the traffic is forwarded to
                              that backend. If weight is set to 0, no traffic should
                              be forwarded for this entry. If unspecified, weight
                              defaults to 1. \n Support: Core"
                            format: int32
                            maximum: 1000000
                            minimum: 0
                            type: integer
                        type: object
                      maxItems: 16
                      type: array
                    matches:
                      default:
                      - path:
                          type: Prefix
                          value: /
                      description: "Matches define conditions used for matching the
                        rule against incoming HTTP requests. Each match is independent,
                        i.e. this rule will be matched if **any** one of the matches
                        is satisfied. \n For example, take the following matches configuration:
                        \n ``` matches: - path:     value: \"/foo\"   headers:     values:
                        \      version: \"2\" - path:     value: \"/v2/foo\" ``` \n
                        For a request to match against this rule, a request should
                        satisfy EITHER of the two conditions: \n - path prefixed with
                        `/foo` AND contains the header `version: \"2\"` - path prefix
                        of `/v2/foo` \n See the documentation for HTTPRouteMatch on
                        how to specify multiple match conditions that should be ANDed
                        together. \n If no matches are specified, the default is a
                        prefix path match on \"/\", which has the effect of matching
                        every HTTP request. \n Each client request MUST map to a maximum
                        of one route rule. If a request matches multiple rules, matching
                        precedence MUST be determined in order of the following criteria,
                        continuing on ties: \n * The longest matching hostname. *
                        The longest matching path. * The largest number of header
                        matches. \n If ties still exist across multiple Routes, matching
                        precedence MUST be determined in order of the following criteria,
                        continuing on ties: \n * The oldest Route based on creation
                        timestamp. For example, a Route with   a creation timestamp
                        of \"2020-09-08 01:02:03\" is given precedence over   a Route
                        with a creation timestamp of \"2020-09-08 01:02:04\". * The
                        Route appearing first in alphabetical order by   \"<namespace>/<name>\".
                        For example, foo/bar is given precedence over   foo/baz. \n
                        If ties still exist within the Route that has been given precedence,
                        matching precedence MUST be granted to the first matching
                        rule meeting the above criteria."
                      items:
                        description: "HTTPRouteMatch defines the predicate used to
                          match requests to a given action. Multiple match types are
                          ANDed together, i.e. the match will evaluate to true only
                          if all conditions are satisfied. \n For example, the match
                          below will match a HTTP request only if its path starts
                          with `/foo` AND it contains the `version: \"1\"` header:
                          \n ``` match:   path:     value: \"/foo\"   headers:     values:
                          \      version: \"1\" ```"
                        properties:
                          extensionRef:
                            description: "ExtensionRef is an optional, implementation-specific
                              extension to the \"match\" behavior. For example, resource
                              \"myroutematcher\" in group \"networking.acme.io\".
                              If the referent cannot be found, the rule is not included
                              in the route. The controller should raise the \"ResolvedRefs\"
                              condition on the Gateway with the \"DegradedRoutes\"
                              reason. The gateway status for this route should be
                              updated with a condition that describes the error more
                              specifically. \n Support: Custom"
                            properties:
                              group:
                                description: Group is the group of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              kind:
                                description: Kind is kind of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                              name:
                                description: Name is the name of the referent.
                                maxLength: 253
                                minLength: 1
                                type: string
                            required:
                            - group
                            - kind
                            - name
                            type: object
                          headers:
                            description: Headers specifies a HTTP request header matcher.
                            properties:
                              type:
                                default: Exact
                                description: "Type specifies how to match against
                                  the value of the header. \n Support: Core (Exact)
                                  \n Support: Custom (RegularExpression, ImplementationSpecific)
                                  \n Since RegularExpression PathType has custom conformance,
                                  implementations can support POSIX, PCRE or any other
                                  dialects of regular expressions. Please read the
                                  implementation's documentation to determine the
                                  supported dialect. \n HTTP Header name matching
                                  MUST be case-insensitive (RFC 2616 - section 4.2)."
                                enum:
                                - Exact
                                - RegularExpression
                                - ImplementationSpecific
                                type: string
                              values:
                                additionalProperties:
                                  type: string
                                description: "Values is a map of HTTP Headers to be
                                  matched. It MUST contain at least one entry. \n
                                  The HTTP header field name to match is the map key,
                                  and the value of the HTTP header is the map value.
                                  HTTP header field name matching MUST be case-insensitive.
                                  \n Multiple match values are ANDed together, meaning,
                                  a request must match all the specified headers to
                                  select the route."
                                type: object
                            required:
                            - values
                            type: object
                          path:
                            default:
                              type: Prefix
                              value: /
                            description: Path specifies a HTTP request path matcher.
                              If this field is not specified, a default prefix match
                              on the "/" path is provided.
                            properties:
                              type:
                                default: Prefix
                                description: "Type specifies how to match against
                                  the path Value. \n Support: Core (Exact, Prefix)
                                  \n Support: Custom (RegularExpression, ImplementationSpecific)
                                  \n Since RegularExpression PathType has custom conformance,
                                  implementations can support POSIX, PCRE or any other
                                  dialects of regular expressions. Please read the
                                  implementation's documentation to determine the
                                  supported dialect."
                                enum:
                                - Exact
                                - Prefix
                                - RegularExpression
                                - ImplementationSpecific
                                type: string
                              value:
                                default: /
                                description: Value of the HTTP path to match against.
                                type: string
                            type: object
                          queryParams:
                            description: QueryParams specifies a HTTP query parameter
                              matcher.
                            properties:
                              type:
                                default: Exact
                                description: "Type specifies how to match against
                                  the value of the query parameter. \n Support: Extended
                                  (Exact) \n Support: Custom (RegularExpression, ImplementationSpecific)
                                  \n Since RegularExpression QueryParamMatchType has
                                  custom conformance, implementations can support
                                  POSIX, PCRE or any other dialects of regular expressions.
                                  Please read the implementation's documentation to
                                  determine the supported dialect."
                                enum:
                                - Exact
                                - RegularExpression
                                - ImplementationSpecific
                                type: string
                              values:
                                additionalProperties:
                                  type: string
                                description: "Values is a map of HTTP query parameters
                                  to be matched. It MUST contain at least one entry.
                                  \n The query parameter name to match is the map
                                  key, and the value of the query parameter is the
                                  map value. \n Multiple match values are ANDed together,
                                  meaning, a request must match all the specified
                                  query parameters to select the route. \n HTTP query
                                  parameter matching MUST be case-sensitive for both
                                  keys and values. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
                                  \n Note that the query parameter key MUST always
                                  be an exact match by string comparison."
                                type: object
                            required:
                            - values
                            type: object
                        type: object
                      maxItems: 8
                      type: array
                  type: object
                maxItems: 16
                type: array
              tls:
                description: "TLS defines the TLS certificate to use for Hostnames
                  defined in this Route. This configuration only takes effect if the
                  AllowRouteOverride field is set to true in the associated Gateway
                  resource. \n Collisions can happen if multiple HTTPRoutes define
                  a TLS certificate for the same hostname. In such a case, conflict
                  resolution guiding principles apply, specifically, if hostnames
                  are same and two different certificates are specified then the certificate
                  in the oldest resource wins. \n Please note that HTTP Route-selection
                  takes place after the TLS Handshake (ClientHello). Due to this,
                  TLS certificate defined here will take precedence even if the request
                  has the potential to match multiple routes (in case multiple HTTPRoutes
                  share the same hostname). \n Support: Core"
                properties:
                  certificateRef:
                    description: "CertificateRef is a reference to a Kubernetes object
                      that contains a TLS certificate and private key. This certificate
                      is used to establish a TLS handshake for requests that match
                      the hostname of the associated HTTPRoute. The referenced object
                      MUST reside in the same namespace as HTTPRoute. \n This field
                      is required when the TLS configuration mode of the associated
                      Gateway listener is set to \"Passthrough\". \n CertificateRef
                      can reference a standard Kubernetes resource, i.e. Secret, or
                      an implementation-specific custom resource. \n Support: Core
                      (Kubernetes Secrets) \n Support: Implementation-specific (Other
                      resource types)"
                    properties:
                      group:
                        description: Group is the group of the referent.
                        maxLength: 253
                        minLength: 1
                        type: string
                      kind:
                        description: Kind is kind of the referent.
                        maxLength: 253
                        minLength: 1
                        type: string
                      name:
                        description: Name is the name of the referent.
                        maxLength: 253
                        minLength: 1
                        type: string
                    required:
                    - group
                    - kind
                    - name
                    type: object
                required:
                - certificateRef
                type: object
            type: object
          status:
            description: Status defines the current state of HTTPRoute.
            properties:
              gateways:
                description: "Gateways is a list of Gateways that are associated with
                  the route, and the status of the route with respect to each Gateway.
                  When a Gateway selects this route, the controller that manages the
                  Gateway must add an entry to this list when the controller first
                  sees the route and should update the entry as appropriate when the
                  route is modified. \n A maximum of 100 Gateways will be represented
                  in this list. If this list is full, there may be additional Gateways
                  using this Route that are not included in the list. An empty list
                  means the route has not been admitted by any Gateway."
                items:
                  description: RouteGatewayStatus describes the status of a route
                    with respect to an associated Gateway.
                  properties:
                    conditions:
                      description: Conditions describes the status of the route with
                        respect to the Gateway. The "Admitted" condition must always
                        be specified by controllers to indicate whether the route
                        has been admitted or rejected by the Gateway, and why. Note
                        that the route's availability is also subject to the Gateway's
                        own status conditions and listener status.
                      items:
                        description: "Condition contains details for one aspect of
                          the current state of this API Resource. --- This struct
                          is intended for direct use as an array at the field path
                          .status.conditions.  For example, type FooStatus struct{
                          \    // Represents the observations of a foo's current state.
                          \    // Known .status.conditions.type are: \"Available\",
                          \"Progressing\", and \"Degraded\"     // +patchMergeKey=type
                          \    // +patchStrategy=merge     // +listType=map     //
                          +listMapKey=type     Conditions []metav1.Condition `json:\"conditions,omitempty\"
                          patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`
                          \n     // other fields }"
                        properties:
                          lastTransitionTime:
                            description: lastTransitionTime is the last time the condition
                              transitioned from one status to another. This should
                              be when the underlying condition changed.  If that is
                              not known, then using the time when the API field changed
                              is acceptable.
                            format: date-time
                            type: string
                          message:
                            description: message is a human readable message indicating
                              details about the transition. This may be an empty string.
                            maxLength: 32768
                            type: string
                          observedGeneration:
                            description: observedGeneration represents the .metadata.generation
                              that the condition was set based upon. For instance,
                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
                              is 9, the condition is out of date with respect to the
                              current state of the instance.
                            format: int64
                            minimum: 0
                            type: integer
                          reason:
                            description: reason contains a programmatic identifier
                              indicating the reason for the condition's last transition.
                              Producers of specific condition types may define expected
                              values and meanings for this field, and whether the
                              values are considered a guaranteed API. The value should
                              be a CamelCase string. This field may not be empty.
                            maxLength: 1024
                            minLength: 1
                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
                            type: string
                          status:
                            description: status of the condition, one of True, False,
                              Unknown.
                            enum:
                            - "True"
                            - "False"
                            - Unknown
                            type: string
                          type:
                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
                              --- Many .condition.type values are consistent across
                              resources like Available, but because arbitrary conditions
                              can be useful (see .node.status.conditions), the ability
                              to deconflict is important. The regex it matches is
                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
                            maxLength: 316
                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
                            type: string
                        required:
                        - lastTransitionTime
                        - message
                        - reason
                        - status
                        - type
                        type: object
                      maxItems: 8
                      type: array
                      x-kubernetes-list-map-keys:
                      - type
                      x-kubernetes-list-type: map
                    gatewayRef:
                      description: GatewayRef is a reference to a Gateway object that
                        is associated with the route.
                      properties:
                        controller:
                          description: "Controller is a domain/path string that indicates
                            the controller implementing the Gateway. This corresponds
                            with the controller field on GatewayClass. \n Example:
                            \"acme.io/gateway-controller\". \n The format of this
                            field is DOMAIN \"/\" PATH, where DOMAIN and PATH are
                            valid Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names)."
                          maxLength: 253
                          type: string
                        name:
                          description: Name is the name of the referent.
                          maxLength: 253
                          minLength: 1
                          type: string
                        namespace:
                          description: Namespace is the namespace of the referent.
                          maxLength: 253
                          minLength: 1
                          type: string
                      required:
                      - name
                      - namespace
                      type: object
                  required:
                  - gatewayRef
                  type: object
                maxItems: 100
                type: array
            required:
            - gateways
            type: object
        type: object
    served: true
    storage: true
    subresources:
      status: {}
status:
  acceptedNames:
    kind: ""
    plural: ""
  conditions: []
  storedVersions: []
