...

Text file src/github.com/linkerd/linkerd2/charts/linkerd-crds/templates/gateway.networking.k8s.io_httproutes.yaml

Documentation: github.com/linkerd/linkerd2/charts/linkerd-crds/templates

     1{{- if .Values.enableHttpRoutes }}
     2---
     3apiVersion: apiextensions.k8s.io/v1
     4kind: CustomResourceDefinition
     5metadata:
     6  annotations:
     7    api-approved.kubernetes.io: https://github.com/kubernetes-sigs/gateway-api/pull/1923
     8    gateway.networking.k8s.io/bundle-version: v0.7.1
     9    gateway.networking.k8s.io/channel: experimental
    10    {{ include "partials.annotations.created-by" . }}
    11  labels:
    12    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
    13    linkerd.io/control-plane-ns: {{.Release.Namespace}}
    14  creationTimestamp: null
    15  name: httproutes.gateway.networking.k8s.io
    16spec:
    17  group: gateway.networking.k8s.io
    18  names:
    19    categories:
    20    - gateway-api
    21    kind: HTTPRoute
    22    listKind: HTTPRouteList
    23    plural: httproutes
    24    singular: httproute
    25  scope: Namespaced
    26  versions:
    27  - additionalPrinterColumns:
    28    - jsonPath: .spec.hostnames
    29      name: Hostnames
    30      type: string
    31    - jsonPath: .metadata.creationTimestamp
    32      name: Age
    33      type: date
    34    deprecated: true
    35    deprecationWarning: The v1alpha2 version of HTTPRoute has been deprecated and
    36      will be removed in a future release of the API. Please upgrade to v1beta1.
    37    name: v1alpha2
    38    schema:
    39      openAPIV3Schema:
    40        description: HTTPRoute provides a way to route HTTP requests. This includes
    41          the capability to match requests by hostname, path, header, or query param.
    42          Filters can be used to specify additional processing steps. Backends specify
    43          where matching requests should be routed.
    44        properties:
    45          apiVersion:
    46            description: 'APIVersion defines the versioned schema of this representation
    47              of an object. Servers should convert recognized schemas to the latest
    48              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
    49            type: string
    50          kind:
    51            description: 'Kind is a string value representing the REST resource this
    52              object represents. Servers may infer this from the endpoint the client
    53              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
    54            type: string
    55          metadata:
    56            type: object
    57          spec:
    58            description: Spec defines the desired state of HTTPRoute.
    59            properties:
    60              hostnames:
    61                description: "Hostnames defines a set of hostname that should match
    62                  against the HTTP Host header to select a HTTPRoute used to process
    63                  the request. Implementations MUST ignore any port value specified
    64                  in the HTTP Host header while performing a match. \n Valid values
    65                  for Hostnames are determined by RFC 1123 definition of a hostname
    66                  with 2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
    67                  may be prefixed with a wildcard label (`*.`). The wildcard label
    68                  must appear by itself as the first label. \n If a hostname is specified
    69                  by both the Listener and HTTPRoute, there must be at least one intersecting
    70                  hostname for the HTTPRoute to be attached to the Listener. For example:
    71                  \n * A Listener with `test.example.com` as the hostname matches
    72                  HTTPRoutes that have either not specified any hostnames, or have
    73                  specified at least one of `test.example.com` or `*.example.com`.
    74                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
    75                  that have either not specified any hostnames or have specified at
    76                  least one hostname that matches the Listener hostname. For example,
    77                  `*.example.com`, `test.example.com`, and `foo.test.example.com`
    78                  would all match. On the other hand, `example.com` and `test.example.net`
    79                  would not match. \n Hostnames that are prefixed with a wildcard
    80                  label (`*.`) are interpreted as a suffix match. That means that
    81                  a match for `*.example.com` would match both `test.example.com`,
    82                  and `foo.test.example.com`, but not `example.com`. \n If both the
    83                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
    84                  that do not match the Listener hostname MUST be ignored. For example,
    85                  if a Listener specified `*.example.com`, and the HTTPRoute specified
    86                  `test.example.com` and `test.example.net`, `test.example.net` must
    87                  not be considered for a match. \n If both the Listener and HTTPRoute
    88                  have specified hostnames, and none match with the criteria above,
    89                  then the HTTPRoute is not accepted. The implementation must raise
    90                  an 'Accepted' Condition with a status of `False` in the corresponding
    91                  RouteParentStatus. \n In the event that multiple HTTPRoutes specify
    92                  intersecting hostnames (e.g. overlapping wildcard matching and exact
    93                  matching hostnames), precedence must be given to rules from the
    94                  HTTPRoute with the largest number of: \n * Characters in a matching
    95                  non-wildcard hostname. * Characters in a matching hostname. \n If
    96                  ties exist across multiple Routes, the matching precedence rules
    97                  for HTTPRouteMatches takes over. \n Support: Core"
    98                items:
    99                  description: "Hostname is the fully qualified domain name of a network
   100                    host. This matches the RFC 1123 definition of a hostname with
   101                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
   102                    may be prefixed with a wildcard label (`*.`). The wildcard label
   103                    must appear by itself as the first label. \n Hostname can be \"precise\"
   104                    which is a domain name without the terminating dot of a network
   105                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
   106                    name prefixed with a single wildcard label (e.g. `*.example.com`).
   107                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
   108                    of lower case alphanumeric characters or '-', and must start and
   109                    end with an alphanumeric character. No other punctuation is allowed."
   110                  maxLength: 253
   111                  minLength: 1
   112                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   113                  type: string
   114                maxItems: 16
   115                type: array
   116              parentRefs:
   117                description: "ParentRefs references the resources (usually Gateways)
   118                  that a Route wants to be attached to. Note that the referenced parent
   119                  resource needs to allow this for the attachment to be complete.
   120                  For Gateways, that means the Gateway needs to allow attachment from
   121                  Routes of this kind and namespace. \n The only kind of parent resource
   122                  with \"Core\" support is Gateway. This API may be extended in the
   123                  future to support additional kinds of parent resources such as one
   124                  of the route kinds. \n It is invalid to reference an identical parent
   125                  more than once. It is valid to reference multiple distinct sections
   126                  within the same parent resource, such as 2 Listeners within a Gateway.
   127                  \n It is possible to separately reference multiple distinct objects
   128                  that may be collapsed by an implementation. For example, some implementations
   129                  may choose to merge compatible Gateway Listeners together. If that
   130                  is the case, the list of routes attached to those resources should
   131                  also be merged. \n Note that for ParentRefs that cross namespace
   132                  boundaries, there are specific rules. Cross-namespace references
   133                  are only valid if they are explicitly allowed by something in the
   134                  namespace they are referring to. For example, Gateway has the AllowedRoutes
   135                  field, and ReferenceGrant provides a generic way to enable any other
   136                  kind of cross-namespace reference."
   137                items:
   138                  description: "ParentReference identifies an API object (usually
   139                    a Gateway) that can be considered a parent of this resource (usually
   140                    a route). The only kind of parent resource with \"Core\" support
   141                    is Gateway. This API may be extended in the future to support
   142                    additional kinds of parent resources, such as HTTPRoute. \n The
   143                    API object must be valid in the cluster; the Group and Kind must
   144                    be registered in the cluster for this reference to be valid."
   145                  properties:
   146                    group:
   147                      default: gateway.networking.k8s.io
   148                      description: "Group is the group of the referent. When unspecified,
   149                        \"gateway.networking.k8s.io\" is inferred. To set the core
   150                        API group (such as for a \"Service\" kind referent), Group
   151                        must be explicitly set to \"\" (empty string). \n Support:
   152                        Core"
   153                      maxLength: 253
   154                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   155                      type: string
   156                    kind:
   157                      default: Gateway
   158                      description: "Kind is kind of the referent. \n Support: Core
   159                        (Gateway) \n Support: Implementation-specific (Other Resources)"
   160                      maxLength: 63
   161                      minLength: 1
   162                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   163                      type: string
   164                    name:
   165                      description: "Name is the name of the referent. \n Support:
   166                        Core"
   167                      maxLength: 253
   168                      minLength: 1
   169                      type: string
   170                    namespace:
   171                      description: "Namespace is the namespace of the referent. When
   172                        unspecified, this refers to the local namespace of the Route.
   173                        \n Note that there are specific rules for ParentRefs which
   174                        cross namespace boundaries. Cross-namespace references are
   175                        only valid if they are explicitly allowed by something in
   176                        the namespace they are referring to. For example: Gateway
   177                        has the AllowedRoutes field, and ReferenceGrant provides a
   178                        generic way to enable any other kind of cross-namespace reference.
   179                        \n Support: Core"
   180                      maxLength: 63
   181                      minLength: 1
   182                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   183                      type: string
   184                    port:
   185                      description: "Port is the network port this Route targets. It
   186                        can be interpreted differently based on the type of parent
   187                        resource. \n When the parent resource is a Gateway, this targets
   188                        all listeners listening on the specified port that also support
   189                        this kind of Route(and select this Route). It's not recommended
   190                        to set `Port` unless the networking behaviors specified in
   191                        a Route must apply to a specific port as opposed to a listener(s)
   192                        whose port(s) may be changed. When both Port and SectionName
   193                        are specified, the name and port of the selected listener
   194                        must match both specified values. \n Implementations MAY choose
   195                        to support other parent resources. Implementations supporting
   196                        other types of parent resources MUST clearly document how/if
   197                        Port is interpreted. \n For the purpose of status, an attachment
   198                        is considered successful as long as the parent resource accepts
   199                        it partially. For example, Gateway listeners can restrict
   200                        which Routes can attach to them by Route kind, namespace,
   201                        or hostname. If 1 of 2 Gateway listeners accept attachment
   202                        from the referencing Route, the Route MUST be considered successfully
   203                        attached. If no Gateway listeners accept attachment from this
   204                        Route, the Route MUST be considered detached from the Gateway.
   205                        \n Support: Extended \n <gateway:experimental>"
   206                      format: int32
   207                      maximum: 65535
   208                      minimum: 1
   209                      type: integer
   210                    sectionName:
   211                      description: "SectionName is the name of a section within the
   212                        target resource. In the following resources, SectionName is
   213                        interpreted as the following: \n * Gateway: Listener Name.
   214                        When both Port (experimental) and SectionName are specified,
   215                        the name and port of the selected listener must match both
   216                        specified values. \n Implementations MAY choose to support
   217                        attaching Routes to other resources. If that is the case,
   218                        they MUST clearly document how SectionName is interpreted.
   219                        \n When unspecified (empty string), this will reference the
   220                        entire resource. For the purpose of status, an attachment
   221                        is considered successful if at least one section in the parent
   222                        resource accepts it. For example, Gateway listeners can restrict
   223                        which Routes can attach to them by Route kind, namespace,
   224                        or hostname. If 1 of 2 Gateway listeners accept attachment
   225                        from the referencing Route, the Route MUST be considered successfully
   226                        attached. If no Gateway listeners accept attachment from this
   227                        Route, the Route MUST be considered detached from the Gateway.
   228                        \n Support: Core"
   229                      maxLength: 253
   230                      minLength: 1
   231                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   232                      type: string
   233                  required:
   234                  - name
   235                  type: object
   236                maxItems: 32
   237                type: array
   238              rules:
   239                default:
   240                - matches:
   241                  - path:
   242                      type: PathPrefix
   243                      value: /
   244                description: Rules are a list of HTTP matchers, filters and actions.
   245                items:
   246                  description: HTTPRouteRule defines semantics for matching an HTTP
   247                    request based on conditions (matches), processing it (filters),
   248                    and forwarding the request to an API object (backendRefs).
   249                  properties:
   250                    backendRefs:
   251                      description: "BackendRefs defines the backend(s) where matching
   252                        requests should be sent. \n Failure behavior here depends
   253                        on how many BackendRefs are specified and how many are invalid.
   254                        \n If *all* entries in BackendRefs are invalid, and there
   255                        are also no filters specified in this route rule, *all* traffic
   256                        which matches this rule MUST receive a 500 status code. \n
   257                        See the HTTPBackendRef definition for the rules about what
   258                        makes a single HTTPBackendRef invalid. \n When a HTTPBackendRef
   259                        is invalid, 500 status codes MUST be returned for requests
   260                        that would have otherwise been routed to an invalid backend.
   261                        If multiple backends are specified, and some are invalid,
   262                        the proportion of requests that would otherwise have been
   263                        routed to an invalid backend MUST receive a 500 status code.
   264                        \n For example, if two backends are specified with equal weights,
   265                        and one is invalid, 50 percent of traffic must receive a 500.
   266                        Implementations may choose how that 50 percent is determined.
   267                        \n Support: Core for Kubernetes Service \n Support: Extended
   268                        for Kubernetes ServiceImport \n Support: Implementation-specific
   269                        for any other resource \n Support for weight: Core"
   270                      items:
   271                        description: HTTPBackendRef defines how a HTTPRoute should
   272                          forward an HTTP request.
   273                        properties:
   274                          filters:
   275                            description: "Filters defined at this level should be
   276                              executed if and only if the request is being forwarded
   277                              to the backend defined here. \n Support: Implementation-specific
   278                              (For broader support of filters, use the Filters field
   279                              in HTTPRouteRule.)"
   280                            items:
   281                              description: HTTPRouteFilter defines processing steps
   282                                that must be completed during the request or response
   283                                lifecycle. HTTPRouteFilters are meant as an extension
   284                                point to express processing that may be done in Gateway
   285                                implementations. Some examples include request or
   286                                response modification, implementing authentication
   287                                strategies, rate-limiting, and traffic shaping. API
   288                                guarantee/conformance is defined based on the type
   289                                of the filter.
   290                              properties:
   291                                extensionRef:
   292                                  description: "ExtensionRef is an optional, implementation-specific
   293                                    extension to the \"filter\" behavior.  For example,
   294                                    resource \"myroutefilter\" in group \"networking.example.net\").
   295                                    ExtensionRef MUST NOT be used for core and extended
   296                                    filters. \n Support: Implementation-specific"
   297                                  properties:
   298                                    group:
   299                                      description: Group is the group of the referent.
   300                                        For example, "gateway.networking.k8s.io".
   301                                        When unspecified or empty string, core API
   302                                        group is inferred.
   303                                      maxLength: 253
   304                                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   305                                      type: string
   306                                    kind:
   307                                      description: Kind is kind of the referent. For
   308                                        example "HTTPRoute" or "Service".
   309                                      maxLength: 63
   310                                      minLength: 1
   311                                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   312                                      type: string
   313                                    name:
   314                                      description: Name is the name of the referent.
   315                                      maxLength: 253
   316                                      minLength: 1
   317                                      type: string
   318                                  required:
   319                                  - group
   320                                  - kind
   321                                  - name
   322                                  type: object
   323                                requestHeaderModifier:
   324                                  description: "RequestHeaderModifier defines a schema
   325                                    for a filter that modifies request headers. \n
   326                                    Support: Core"
   327                                  properties:
   328                                    add:
   329                                      description: "Add adds the given header(s) (name,
   330                                        value) to the request before the action. It
   331                                        appends to any existing values associated
   332                                        with the header name. \n Input: GET /foo HTTP/1.1
   333                                        my-header: foo \n Config: add: - name: \"my-header\"
   334                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   335                                        my-header: foo,bar,baz"
   336                                      items:
   337                                        description: HTTPHeader represents an HTTP
   338                                          Header name and value as defined by RFC
   339                                          7230.
   340                                        properties:
   341                                          name:
   342                                            description: "Name is the name of the
   343                                              HTTP Header to be matched. Name matching
   344                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   345                                              \n If multiple entries specify equivalent
   346                                              header names, the first entry with an
   347                                              equivalent name MUST be considered for
   348                                              a match. Subsequent entries with an
   349                                              equivalent header name MUST be ignored.
   350                                              Due to the case-insensitivity of header
   351                                              names, \"foo\" and \"Foo\" are considered
   352                                              equivalent."
   353                                            maxLength: 256
   354                                            minLength: 1
   355                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   356                                            type: string
   357                                          value:
   358                                            description: Value is the value of HTTP
   359                                              Header to be matched.
   360                                            maxLength: 4096
   361                                            minLength: 1
   362                                            type: string
   363                                        required:
   364                                        - name
   365                                        - value
   366                                        type: object
   367                                      maxItems: 16
   368                                      type: array
   369                                      x-kubernetes-list-map-keys:
   370                                      - name
   371                                      x-kubernetes-list-type: map
   372                                    remove:
   373                                      description: "Remove the given header(s) from
   374                                        the HTTP request before the action. The value
   375                                        of Remove is a list of HTTP header names.
   376                                        Note that the header names are case-insensitive
   377                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   378                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   379                                        my-header2: bar my-header3: baz \n Config:
   380                                        remove: [\"my-header1\", \"my-header3\"] \n
   381                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   382                                      items:
   383                                        type: string
   384                                      maxItems: 16
   385                                      type: array
   386                                    set:
   387                                      description: "Set overwrites the request with
   388                                        the given header (name, value) before the
   389                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   390                                        foo \n Config: set: - name: \"my-header\"
   391                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   392                                        my-header: bar"
   393                                      items:
   394                                        description: HTTPHeader represents an HTTP
   395                                          Header name and value as defined by RFC
   396                                          7230.
   397                                        properties:
   398                                          name:
   399                                            description: "Name is the name of the
   400                                              HTTP Header to be matched. Name matching
   401                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   402                                              \n If multiple entries specify equivalent
   403                                              header names, the first entry with an
   404                                              equivalent name MUST be considered for
   405                                              a match. Subsequent entries with an
   406                                              equivalent header name MUST be ignored.
   407                                              Due to the case-insensitivity of header
   408                                              names, \"foo\" and \"Foo\" are considered
   409                                              equivalent."
   410                                            maxLength: 256
   411                                            minLength: 1
   412                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   413                                            type: string
   414                                          value:
   415                                            description: Value is the value of HTTP
   416                                              Header to be matched.
   417                                            maxLength: 4096
   418                                            minLength: 1
   419                                            type: string
   420                                        required:
   421                                        - name
   422                                        - value
   423                                        type: object
   424                                      maxItems: 16
   425                                      type: array
   426                                      x-kubernetes-list-map-keys:
   427                                      - name
   428                                      x-kubernetes-list-type: map
   429                                  type: object
   430                                requestMirror:
   431                                  description: "RequestMirror defines a schema for
   432                                    a filter that mirrors requests. Requests are sent
   433                                    to the specified destination, but responses from
   434                                    that destination are ignored. \n Support: Extended"
   435                                  properties:
   436                                    backendRef:
   437                                      description: "BackendRef references a resource
   438                                        where mirrored requests are sent. \n If the
   439                                        referent cannot be found, this BackendRef
   440                                        is invalid and must be dropped from the Gateway.
   441                                        The controller must ensure the \"ResolvedRefs\"
   442                                        condition on the Route status is set to `status:
   443                                        False` and not configure this backend in the
   444                                        underlying implementation. \n If there is
   445                                        a cross-namespace reference to an *existing*
   446                                        object that is not allowed by a ReferenceGrant,
   447                                        the controller must ensure the \"ResolvedRefs\"
   448                                        \ condition on the Route is set to `status:
   449                                        False`, with the \"RefNotPermitted\" reason
   450                                        and not configure this backend in the underlying
   451                                        implementation. \n In either error case, the
   452                                        Message of the `ResolvedRefs` Condition should
   453                                        be used to provide more detail about the problem.
   454                                        \n Support: Extended for Kubernetes Service
   455                                        \n Support: Implementation-specific for any
   456                                        other resource"
   457                                      properties:
   458                                        group:
   459                                          default: ""
   460                                          description: Group is the group of the referent.
   461                                            For example, "gateway.networking.k8s.io".
   462                                            When unspecified or empty string, core
   463                                            API group is inferred.
   464                                          maxLength: 253
   465                                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   466                                          type: string
   467                                        kind:
   468                                          default: Service
   469                                          description: "Kind is the Kubernetes resource
   470                                            kind of the referent. For example \"Service\".
   471                                            \n Defaults to \"Service\" when not specified.
   472                                            \n ExternalName services can refer to
   473                                            CNAME DNS records that may live outside
   474                                            of the cluster and as such are difficult
   475                                            to reason about in terms of conformance.
   476                                            They also may not be safe to forward to
   477                                            (see CVE-2021-25740 for more information).
   478                                            Implementations SHOULD NOT support ExternalName
   479                                            Services. \n Support: Core (Services with
   480                                            a type other than ExternalName) \n Support:
   481                                            Implementation-specific (Services with
   482                                            type ExternalName)"
   483                                          maxLength: 63
   484                                          minLength: 1
   485                                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   486                                          type: string
   487                                        name:
   488                                          description: Name is the name of the referent.
   489                                          maxLength: 253
   490                                          minLength: 1
   491                                          type: string
   492                                        namespace:
   493                                          description: "Namespace is the namespace
   494                                            of the backend. When unspecified, the
   495                                            local namespace is inferred. \n Note that
   496                                            when a namespace different than the local
   497                                            namespace is specified, a ReferenceGrant
   498                                            object is required in the referent namespace
   499                                            to allow that namespace's owner to accept
   500                                            the reference. See the ReferenceGrant
   501                                            documentation for details. \n Support:
   502                                            Core"
   503                                          maxLength: 63
   504                                          minLength: 1
   505                                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   506                                          type: string
   507                                        port:
   508                                          description: Port specifies the destination
   509                                            port number to use for this resource.
   510                                            Port is required when the referent is
   511                                            a Kubernetes Service. In this case, the
   512                                            port number is the service port number,
   513                                            not the target port. For other resources,
   514                                            destination port might be derived from
   515                                            the referent resource or this field.
   516                                          format: int32
   517                                          maximum: 65535
   518                                          minimum: 1
   519                                          type: integer
   520                                      required:
   521                                      - name
   522                                      type: object
   523                                  required:
   524                                  - backendRef
   525                                  type: object
   526                                requestRedirect:
   527                                  description: "RequestRedirect defines a schema for
   528                                    a filter that responds to the request with an
   529                                    HTTP redirection. \n Support: Core"
   530                                  properties:
   531                                    hostname:
   532                                      description: "Hostname is the hostname to be
   533                                        used in the value of the `Location` header
   534                                        in the response. When empty, the hostname
   535                                        in the `Host` header of the request is used.
   536                                        \n Support: Core"
   537                                      maxLength: 253
   538                                      minLength: 1
   539                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   540                                      type: string
   541                                    path:
   542                                      description: "Path defines parameters used to
   543                                        modify the path of the incoming request. The
   544                                        modified path is then used to construct the
   545                                        `Location` header. When empty, the request
   546                                        path is used as-is. \n Support: Extended"
   547                                      properties:
   548                                        replaceFullPath:
   549                                          description: ReplaceFullPath specifies the
   550                                            value with which to replace the full path
   551                                            of a request during a rewrite or redirect.
   552                                          maxLength: 1024
   553                                          type: string
   554                                        replacePrefixMatch:
   555                                          description: "ReplacePrefixMatch specifies
   556                                            the value with which to replace the prefix
   557                                            match of a request during a rewrite or
   558                                            redirect. For example, a request to \"/foo/bar\"
   559                                            with a prefix match of \"/foo\" would
   560                                            be modified to \"/bar\". \n Note that
   561                                            this matches the behavior of the PathPrefix
   562                                            match type. This matches full path elements.
   563                                            A path element refers to the list of labels
   564                                            in the path split by the `/` separator.
   565                                            When specified, a trailing `/` is ignored.
   566                                            For example, the paths `/abc`, `/abc/`,
   567                                            and `/abc/def` would all match the prefix
   568                                            `/abc`, but the path `/abcd` would not."
   569                                          maxLength: 1024
   570                                          type: string
   571                                        type:
   572                                          description: "Type defines the type of path
   573                                            modifier. Additional types may be added
   574                                            in a future release of the API. \n Note
   575                                            that values may be added to this enum,
   576                                            implementations must ensure that unknown
   577                                            values will not cause a crash. \n Unknown
   578                                            values here must result in the implementation
   579                                            setting the Accepted Condition for the
   580                                            Route to `status: False`, with a Reason
   581                                            of `UnsupportedValue`."
   582                                          enum:
   583                                          - ReplaceFullPath
   584                                          - ReplacePrefixMatch
   585                                          type: string
   586                                      required:
   587                                      - type
   588                                      type: object
   589                                    port:
   590                                      description: "Port is the port to be used in
   591                                        the value of the `Location` header in the
   592                                        response. \n If no port is specified, the
   593                                        redirect port MUST be derived using the following
   594                                        rules: \n * If redirect scheme is not-empty,
   595                                        the redirect port MUST be the well-known port
   596                                        associated with the redirect scheme. Specifically
   597                                        \"http\" to port 80 and \"https\" to port
   598                                        443. If the redirect scheme does not have
   599                                        a well-known port, the listener port of the
   600                                        Gateway SHOULD be used. * If redirect scheme
   601                                        is empty, the redirect port MUST be the Gateway
   602                                        Listener port. \n Implementations SHOULD NOT
   603                                        add the port number in the 'Location' header
   604                                        in the following cases: \n * A Location header
   605                                        that will use HTTP (whether that is determined
   606                                        via the Listener protocol or the Scheme field)
   607                                        _and_ use port 80. * A Location header that
   608                                        will use HTTPS (whether that is determined
   609                                        via the Listener protocol or the Scheme field)
   610                                        _and_ use port 443. \n Support: Extended"
   611                                      format: int32
   612                                      maximum: 65535
   613                                      minimum: 1
   614                                      type: integer
   615                                    scheme:
   616                                      description: "Scheme is the scheme to be used
   617                                        in the value of the `Location` header in the
   618                                        response. When empty, the scheme of the request
   619                                        is used. \n Scheme redirects can affect the
   620                                        port of the redirect, for more information,
   621                                        refer to the documentation for the port field
   622                                        of this filter. \n Note that values may be
   623                                        added to this enum, implementations must ensure
   624                                        that unknown values will not cause a crash.
   625                                        \n Unknown values here must result in the
   626                                        implementation setting the Accepted Condition
   627                                        for the Route to `status: False`, with a Reason
   628                                        of `UnsupportedValue`. \n Support: Extended"
   629                                      enum:
   630                                      - http
   631                                      - https
   632                                      type: string
   633                                    statusCode:
   634                                      default: 302
   635                                      description: "StatusCode is the HTTP status
   636                                        code to be used in response. \n Note that
   637                                        values may be added to this enum, implementations
   638                                        must ensure that unknown values will not cause
   639                                        a crash. \n Unknown values here must result
   640                                        in the implementation setting the Accepted
   641                                        Condition for the Route to `status: False`,
   642                                        with a Reason of `UnsupportedValue`. \n Support:
   643                                        Core"
   644                                      enum:
   645                                      - 301
   646                                      - 302
   647                                      type: integer
   648                                  type: object
   649                                responseHeaderModifier:
   650                                  description: "ResponseHeaderModifier defines a schema
   651                                    for a filter that modifies response headers. \n
   652                                    Support: Extended"
   653                                  properties:
   654                                    add:
   655                                      description: "Add adds the given header(s) (name,
   656                                        value) to the request before the action. It
   657                                        appends to any existing values associated
   658                                        with the header name. \n Input: GET /foo HTTP/1.1
   659                                        my-header: foo \n Config: add: - name: \"my-header\"
   660                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   661                                        my-header: foo,bar,baz"
   662                                      items:
   663                                        description: HTTPHeader represents an HTTP
   664                                          Header name and value as defined by RFC
   665                                          7230.
   666                                        properties:
   667                                          name:
   668                                            description: "Name is the name of the
   669                                              HTTP Header to be matched. Name matching
   670                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   671                                              \n If multiple entries specify equivalent
   672                                              header names, the first entry with an
   673                                              equivalent name MUST be considered for
   674                                              a match. Subsequent entries with an
   675                                              equivalent header name MUST be ignored.
   676                                              Due to the case-insensitivity of header
   677                                              names, \"foo\" and \"Foo\" are considered
   678                                              equivalent."
   679                                            maxLength: 256
   680                                            minLength: 1
   681                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   682                                            type: string
   683                                          value:
   684                                            description: Value is the value of HTTP
   685                                              Header to be matched.
   686                                            maxLength: 4096
   687                                            minLength: 1
   688                                            type: string
   689                                        required:
   690                                        - name
   691                                        - value
   692                                        type: object
   693                                      maxItems: 16
   694                                      type: array
   695                                      x-kubernetes-list-map-keys:
   696                                      - name
   697                                      x-kubernetes-list-type: map
   698                                    remove:
   699                                      description: "Remove the given header(s) from
   700                                        the HTTP request before the action. The value
   701                                        of Remove is a list of HTTP header names.
   702                                        Note that the header names are case-insensitive
   703                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   704                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   705                                        my-header2: bar my-header3: baz \n Config:
   706                                        remove: [\"my-header1\", \"my-header3\"] \n
   707                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   708                                      items:
   709                                        type: string
   710                                      maxItems: 16
   711                                      type: array
   712                                    set:
   713                                      description: "Set overwrites the request with
   714                                        the given header (name, value) before the
   715                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   716                                        foo \n Config: set: - name: \"my-header\"
   717                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   718                                        my-header: bar"
   719                                      items:
   720                                        description: HTTPHeader represents an HTTP
   721                                          Header name and value as defined by RFC
   722                                          7230.
   723                                        properties:
   724                                          name:
   725                                            description: "Name is the name of the
   726                                              HTTP Header to be matched. Name matching
   727                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   728                                              \n If multiple entries specify equivalent
   729                                              header names, the first entry with an
   730                                              equivalent name MUST be considered for
   731                                              a match. Subsequent entries with an
   732                                              equivalent header name MUST be ignored.
   733                                              Due to the case-insensitivity of header
   734                                              names, \"foo\" and \"Foo\" are considered
   735                                              equivalent."
   736                                            maxLength: 256
   737                                            minLength: 1
   738                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   739                                            type: string
   740                                          value:
   741                                            description: Value is the value of HTTP
   742                                              Header to be matched.
   743                                            maxLength: 4096
   744                                            minLength: 1
   745                                            type: string
   746                                        required:
   747                                        - name
   748                                        - value
   749                                        type: object
   750                                      maxItems: 16
   751                                      type: array
   752                                      x-kubernetes-list-map-keys:
   753                                      - name
   754                                      x-kubernetes-list-type: map
   755                                  type: object
   756                                type:
   757                                  description: "Type identifies the type of filter
   758                                    to apply. As with other API fields, types are
   759                                    classified into three conformance levels: \n -
   760                                    Core: Filter types and their corresponding configuration
   761                                    defined by \"Support: Core\" in this package,
   762                                    e.g. \"RequestHeaderModifier\". All implementations
   763                                    must support core filters. \n - Extended: Filter
   764                                    types and their corresponding configuration defined
   765                                    by \"Support: Extended\" in this package, e.g.
   766                                    \"RequestMirror\". Implementers are encouraged
   767                                    to support extended filters. \n - Implementation-specific:
   768                                    Filters that are defined and supported by specific
   769                                    vendors. In the future, filters showing convergence
   770                                    in behavior across multiple implementations will
   771                                    be considered for inclusion in extended or core
   772                                    conformance levels. Filter-specific configuration
   773                                    for such filters is specified using the ExtensionRef
   774                                    field. `Type` should be set to \"ExtensionRef\"
   775                                    for custom filters. \n Implementers are encouraged
   776                                    to define custom implementation types to extend
   777                                    the core API with implementation-specific behavior.
   778                                    \n If a reference to a custom filter type cannot
   779                                    be resolved, the filter MUST NOT be skipped. Instead,
   780                                    requests that would have been processed by that
   781                                    filter MUST receive a HTTP error response. \n
   782                                    Note that values may be added to this enum, implementations
   783                                    must ensure that unknown values will not cause
   784                                    a crash. \n Unknown values here must result in
   785                                    the implementation setting the Accepted Condition
   786                                    for the Route to `status: False`, with a Reason
   787                                    of `UnsupportedValue`."
   788                                  enum:
   789                                  - RequestHeaderModifier
   790                                  - ResponseHeaderModifier
   791                                  - RequestMirror
   792                                  - RequestRedirect
   793                                  - URLRewrite
   794                                  - ExtensionRef
   795                                  type: string
   796                                urlRewrite:
   797                                  description: "URLRewrite defines a schema for a
   798                                    filter that modifies a request during forwarding.
   799                                    \n Support: Extended"
   800                                  properties:
   801                                    hostname:
   802                                      description: "Hostname is the value to be used
   803                                        to replace the Host header value during forwarding.
   804                                        \n Support: Extended"
   805                                      maxLength: 253
   806                                      minLength: 1
   807                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   808                                      type: string
   809                                    path:
   810                                      description: "Path defines a path rewrite. \n
   811                                        Support: Extended"
   812                                      properties:
   813                                        replaceFullPath:
   814                                          description: ReplaceFullPath specifies the
   815                                            value with which to replace the full path
   816                                            of a request during a rewrite or redirect.
   817                                          maxLength: 1024
   818                                          type: string
   819                                        replacePrefixMatch:
   820                                          description: "ReplacePrefixMatch specifies
   821                                            the value with which to replace the prefix
   822                                            match of a request during a rewrite or
   823                                            redirect. For example, a request to \"/foo/bar\"
   824                                            with a prefix match of \"/foo\" would
   825                                            be modified to \"/bar\". \n Note that
   826                                            this matches the behavior of the PathPrefix
   827                                            match type. This matches full path elements.
   828                                            A path element refers to the list of labels
   829                                            in the path split by the `/` separator.
   830                                            When specified, a trailing `/` is ignored.
   831                                            For example, the paths `/abc`, `/abc/`,
   832                                            and `/abc/def` would all match the prefix
   833                                            `/abc`, but the path `/abcd` would not."
   834                                          maxLength: 1024
   835                                          type: string
   836                                        type:
   837                                          description: "Type defines the type of path
   838                                            modifier. Additional types may be added
   839                                            in a future release of the API. \n Note
   840                                            that values may be added to this enum,
   841                                            implementations must ensure that unknown
   842                                            values will not cause a crash. \n Unknown
   843                                            values here must result in the implementation
   844                                            setting the Accepted Condition for the
   845                                            Route to `status: False`, with a Reason
   846                                            of `UnsupportedValue`."
   847                                          enum:
   848                                          - ReplaceFullPath
   849                                          - ReplacePrefixMatch
   850                                          type: string
   851                                      required:
   852                                      - type
   853                                      type: object
   854                                  type: object
   855                              required:
   856                              - type
   857                              type: object
   858                            maxItems: 16
   859                            type: array
   860                          group:
   861                            default: ""
   862                            description: Group is the group of the referent. For example,
   863                              "gateway.networking.k8s.io". When unspecified or empty
   864                              string, core API group is inferred.
   865                            maxLength: 253
   866                            pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   867                            type: string
   868                          kind:
   869                            default: Service
   870                            description: "Kind is the Kubernetes resource kind of
   871                              the referent. For example \"Service\". \n Defaults to
   872                              \"Service\" when not specified. \n ExternalName services
   873                              can refer to CNAME DNS records that may live outside
   874                              of the cluster and as such are difficult to reason about
   875                              in terms of conformance. They also may not be safe to
   876                              forward to (see CVE-2021-25740 for more information).
   877                              Implementations SHOULD NOT support ExternalName Services.
   878                              \n Support: Core (Services with a type other than ExternalName)
   879                              \n Support: Implementation-specific (Services with type
   880                              ExternalName)"
   881                            maxLength: 63
   882                            minLength: 1
   883                            pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   884                            type: string
   885                          name:
   886                            description: Name is the name of the referent.
   887                            maxLength: 253
   888                            minLength: 1
   889                            type: string
   890                          namespace:
   891                            description: "Namespace is the namespace of the backend.
   892                              When unspecified, the local namespace is inferred. \n
   893                              Note that when a namespace different than the local
   894                              namespace is specified, a ReferenceGrant object is required
   895                              in the referent namespace to allow that namespace's
   896                              owner to accept the reference. See the ReferenceGrant
   897                              documentation for details. \n Support: Core"
   898                            maxLength: 63
   899                            minLength: 1
   900                            pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   901                            type: string
   902                          port:
   903                            description: Port specifies the destination port number
   904                              to use for this resource. Port is required when the
   905                              referent is a Kubernetes Service. In this case, the
   906                              port number is the service port number, not the target
   907                              port. For other resources, destination port might be
   908                              derived from the referent resource or this field.
   909                            format: int32
   910                            maximum: 65535
   911                            minimum: 1
   912                            type: integer
   913                          weight:
   914                            default: 1
   915                            description: "Weight specifies the proportion of requests
   916                              forwarded to the referenced backend. This is computed
   917                              as weight/(sum of all weights in this BackendRefs list).
   918                              For non-zero values, there may be some epsilon from
   919                              the exact proportion defined here depending on the precision
   920                              an implementation supports. Weight is not a percentage
   921                              and the sum of weights does not need to equal 100. \n
   922                              If only one backend is specified and it has a weight
   923                              greater than 0, 100% of the traffic is forwarded to
   924                              that backend. If weight is set to 0, no traffic should
   925                              be forwarded for this entry. If unspecified, weight
   926                              defaults to 1. \n Support for this field varies based
   927                              on the context where used."
   928                            format: int32
   929                            maximum: 1000000
   930                            minimum: 0
   931                            type: integer
   932                        required:
   933                        - name
   934                        type: object
   935                      maxItems: 16
   936                      type: array
   937                    filters:
   938                      description: "Filters define the filters that are applied to
   939                        requests that match this rule. \n The effects of ordering
   940                        of multiple behaviors are currently unspecified. This can
   941                        change in the future based on feedback during the alpha stage.
   942                        \n Conformance-levels at this level are defined based on the
   943                        type of filter: \n - ALL core filters MUST be supported by
   944                        all implementations. - Implementers are encouraged to support
   945                        extended filters. - Implementation-specific custom filters
   946                        have no API guarantees across implementations. \n Specifying
   947                        a core filter multiple times has unspecified or implementation-specific
   948                        conformance. \n All filters are expected to be compatible
   949                        with each other except for the URLRewrite and RequestRedirect
   950                        filters, which may not be combined. If an implementation can
   951                        not support other combinations of filters, they must clearly
   952                        document that limitation. In all cases where incompatible
   953                        or unsupported filters are specified, implementations MUST
   954                        add a warning condition to status. \n Support: Core"
   955                      items:
   956                        description: HTTPRouteFilter defines processing steps that
   957                          must be completed during the request or response lifecycle.
   958                          HTTPRouteFilters are meant as an extension point to express
   959                          processing that may be done in Gateway implementations.
   960                          Some examples include request or response modification,
   961                          implementing authentication strategies, rate-limiting, and
   962                          traffic shaping. API guarantee/conformance is defined based
   963                          on the type of the filter.
   964                        properties:
   965                          extensionRef:
   966                            description: "ExtensionRef is an optional, implementation-specific
   967                              extension to the \"filter\" behavior.  For example,
   968                              resource \"myroutefilter\" in group \"networking.example.net\").
   969                              ExtensionRef MUST NOT be used for core and extended
   970                              filters. \n Support: Implementation-specific"
   971                            properties:
   972                              group:
   973                                description: Group is the group of the referent. For
   974                                  example, "gateway.networking.k8s.io". When unspecified
   975                                  or empty string, core API group is inferred.
   976                                maxLength: 253
   977                                pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   978                                type: string
   979                              kind:
   980                                description: Kind is kind of the referent. For example
   981                                  "HTTPRoute" or "Service".
   982                                maxLength: 63
   983                                minLength: 1
   984                                pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   985                                type: string
   986                              name:
   987                                description: Name is the name of the referent.
   988                                maxLength: 253
   989                                minLength: 1
   990                                type: string
   991                            required:
   992                            - group
   993                            - kind
   994                            - name
   995                            type: object
   996                          requestHeaderModifier:
   997                            description: "RequestHeaderModifier defines a schema for
   998                              a filter that modifies request headers. \n Support:
   999                              Core"
  1000                            properties:
  1001                              add:
  1002                                description: "Add adds the given header(s) (name,
  1003                                  value) to the request before the action. It appends
  1004                                  to any existing values associated with the header
  1005                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
  1006                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
  1007                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
  1008                                items:
  1009                                  description: HTTPHeader represents an HTTP Header
  1010                                    name and value as defined by RFC 7230.
  1011                                  properties:
  1012                                    name:
  1013                                      description: "Name is the name of the HTTP Header
  1014                                        to be matched. Name matching MUST be case
  1015                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1016                                        \n If multiple entries specify equivalent
  1017                                        header names, the first entry with an equivalent
  1018                                        name MUST be considered for a match. Subsequent
  1019                                        entries with an equivalent header name MUST
  1020                                        be ignored. Due to the case-insensitivity
  1021                                        of header names, \"foo\" and \"Foo\" are considered
  1022                                        equivalent."
  1023                                      maxLength: 256
  1024                                      minLength: 1
  1025                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1026                                      type: string
  1027                                    value:
  1028                                      description: Value is the value of HTTP Header
  1029                                        to be matched.
  1030                                      maxLength: 4096
  1031                                      minLength: 1
  1032                                      type: string
  1033                                  required:
  1034                                  - name
  1035                                  - value
  1036                                  type: object
  1037                                maxItems: 16
  1038                                type: array
  1039                                x-kubernetes-list-map-keys:
  1040                                - name
  1041                                x-kubernetes-list-type: map
  1042                              remove:
  1043                                description: "Remove the given header(s) from the
  1044                                  HTTP request before the action. The value of Remove
  1045                                  is a list of HTTP header names. Note that the header
  1046                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1047                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
  1048                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
  1049                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
  1050                                  bar"
  1051                                items:
  1052                                  type: string
  1053                                maxItems: 16
  1054                                type: array
  1055                              set:
  1056                                description: "Set overwrites the request with the
  1057                                  given header (name, value) before the action. \n
  1058                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
  1059                                  set: - name: \"my-header\" value: \"bar\" \n Output:
  1060                                  GET /foo HTTP/1.1 my-header: bar"
  1061                                items:
  1062                                  description: HTTPHeader represents an HTTP Header
  1063                                    name and value as defined by RFC 7230.
  1064                                  properties:
  1065                                    name:
  1066                                      description: "Name is the name of the HTTP Header
  1067                                        to be matched. Name matching MUST be case
  1068                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1069                                        \n If multiple entries specify equivalent
  1070                                        header names, the first entry with an equivalent
  1071                                        name MUST be considered for a match. Subsequent
  1072                                        entries with an equivalent header name MUST
  1073                                        be ignored. Due to the case-insensitivity
  1074                                        of header names, \"foo\" and \"Foo\" are considered
  1075                                        equivalent."
  1076                                      maxLength: 256
  1077                                      minLength: 1
  1078                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1079                                      type: string
  1080                                    value:
  1081                                      description: Value is the value of HTTP Header
  1082                                        to be matched.
  1083                                      maxLength: 4096
  1084                                      minLength: 1
  1085                                      type: string
  1086                                  required:
  1087                                  - name
  1088                                  - value
  1089                                  type: object
  1090                                maxItems: 16
  1091                                type: array
  1092                                x-kubernetes-list-map-keys:
  1093                                - name
  1094                                x-kubernetes-list-type: map
  1095                            type: object
  1096                          requestMirror:
  1097                            description: "RequestMirror defines a schema for a filter
  1098                              that mirrors requests. Requests are sent to the specified
  1099                              destination, but responses from that destination are
  1100                              ignored. \n Support: Extended"
  1101                            properties:
  1102                              backendRef:
  1103                                description: "BackendRef references a resource where
  1104                                  mirrored requests are sent. \n If the referent cannot
  1105                                  be found, this BackendRef is invalid and must be
  1106                                  dropped from the Gateway. The controller must ensure
  1107                                  the \"ResolvedRefs\" condition on the Route status
  1108                                  is set to `status: False` and not configure this
  1109                                  backend in the underlying implementation. \n If
  1110                                  there is a cross-namespace reference to an *existing*
  1111                                  object that is not allowed by a ReferenceGrant,
  1112                                  the controller must ensure the \"ResolvedRefs\"
  1113                                  \ condition on the Route is set to `status: False`,
  1114                                  with the \"RefNotPermitted\" reason and not configure
  1115                                  this backend in the underlying implementation. \n
  1116                                  In either error case, the Message of the `ResolvedRefs`
  1117                                  Condition should be used to provide more detail
  1118                                  about the problem. \n Support: Extended for Kubernetes
  1119                                  Service \n Support: Implementation-specific for
  1120                                  any other resource"
  1121                                properties:
  1122                                  group:
  1123                                    default: ""
  1124                                    description: Group is the group of the referent.
  1125                                      For example, "gateway.networking.k8s.io". When
  1126                                      unspecified or empty string, core API group
  1127                                      is inferred.
  1128                                    maxLength: 253
  1129                                    pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1130                                    type: string
  1131                                  kind:
  1132                                    default: Service
  1133                                    description: "Kind is the Kubernetes resource
  1134                                      kind of the referent. For example \"Service\".
  1135                                      \n Defaults to \"Service\" when not specified.
  1136                                      \n ExternalName services can refer to CNAME
  1137                                      DNS records that may live outside of the cluster
  1138                                      and as such are difficult to reason about in
  1139                                      terms of conformance. They also may not be safe
  1140                                      to forward to (see CVE-2021-25740 for more information).
  1141                                      Implementations SHOULD NOT support ExternalName
  1142                                      Services. \n Support: Core (Services with a
  1143                                      type other than ExternalName) \n Support: Implementation-specific
  1144                                      (Services with type ExternalName)"
  1145                                    maxLength: 63
  1146                                    minLength: 1
  1147                                    pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  1148                                    type: string
  1149                                  name:
  1150                                    description: Name is the name of the referent.
  1151                                    maxLength: 253
  1152                                    minLength: 1
  1153                                    type: string
  1154                                  namespace:
  1155                                    description: "Namespace is the namespace of the
  1156                                      backend. When unspecified, the local namespace
  1157                                      is inferred. \n Note that when a namespace different
  1158                                      than the local namespace is specified, a ReferenceGrant
  1159                                      object is required in the referent namespace
  1160                                      to allow that namespace's owner to accept the
  1161                                      reference. See the ReferenceGrant documentation
  1162                                      for details. \n Support: Core"
  1163                                    maxLength: 63
  1164                                    minLength: 1
  1165                                    pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  1166                                    type: string
  1167                                  port:
  1168                                    description: Port specifies the destination port
  1169                                      number to use for this resource. Port is required
  1170                                      when the referent is a Kubernetes Service. In
  1171                                      this case, the port number is the service port
  1172                                      number, not the target port. For other resources,
  1173                                      destination port might be derived from the referent
  1174                                      resource or this field.
  1175                                    format: int32
  1176                                    maximum: 65535
  1177                                    minimum: 1
  1178                                    type: integer
  1179                                required:
  1180                                - name
  1181                                type: object
  1182                            required:
  1183                            - backendRef
  1184                            type: object
  1185                          requestRedirect:
  1186                            description: "RequestRedirect defines a schema for a filter
  1187                              that responds to the request with an HTTP redirection.
  1188                              \n Support: Core"
  1189                            properties:
  1190                              hostname:
  1191                                description: "Hostname is the hostname to be used
  1192                                  in the value of the `Location` header in the response.
  1193                                  When empty, the hostname in the `Host` header of
  1194                                  the request is used. \n Support: Core"
  1195                                maxLength: 253
  1196                                minLength: 1
  1197                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1198                                type: string
  1199                              path:
  1200                                description: "Path defines parameters used to modify
  1201                                  the path of the incoming request. The modified path
  1202                                  is then used to construct the `Location` header.
  1203                                  When empty, the request path is used as-is. \n Support:
  1204                                  Extended"
  1205                                properties:
  1206                                  replaceFullPath:
  1207                                    description: ReplaceFullPath specifies the value
  1208                                      with which to replace the full path of a request
  1209                                      during a rewrite or redirect.
  1210                                    maxLength: 1024
  1211                                    type: string
  1212                                  replacePrefixMatch:
  1213                                    description: "ReplacePrefixMatch specifies the
  1214                                      value with which to replace the prefix match
  1215                                      of a request during a rewrite or redirect. For
  1216                                      example, a request to \"/foo/bar\" with a prefix
  1217                                      match of \"/foo\" would be modified to \"/bar\".
  1218                                      \n Note that this matches the behavior of the
  1219                                      PathPrefix match type. This matches full path
  1220                                      elements. A path element refers to the list
  1221                                      of labels in the path split by the `/` separator.
  1222                                      When specified, a trailing `/` is ignored. For
  1223                                      example, the paths `/abc`, `/abc/`, and `/abc/def`
  1224                                      would all match the prefix `/abc`, but the path
  1225                                      `/abcd` would not."
  1226                                    maxLength: 1024
  1227                                    type: string
  1228                                  type:
  1229                                    description: "Type defines the type of path modifier.
  1230                                      Additional types may be added in a future release
  1231                                      of the API. \n Note that values may be added
  1232                                      to this enum, implementations must ensure that
  1233                                      unknown values will not cause a crash. \n Unknown
  1234                                      values here must result in the implementation
  1235                                      setting the Accepted Condition for the Route
  1236                                      to `status: False`, with a Reason of `UnsupportedValue`."
  1237                                    enum:
  1238                                    - ReplaceFullPath
  1239                                    - ReplacePrefixMatch
  1240                                    type: string
  1241                                required:
  1242                                - type
  1243                                type: object
  1244                              port:
  1245                                description: "Port is the port to be used in the value
  1246                                  of the `Location` header in the response. \n If
  1247                                  no port is specified, the redirect port MUST be
  1248                                  derived using the following rules: \n * If redirect
  1249                                  scheme is not-empty, the redirect port MUST be the
  1250                                  well-known port associated with the redirect scheme.
  1251                                  Specifically \"http\" to port 80 and \"https\" to
  1252                                  port 443. If the redirect scheme does not have a
  1253                                  well-known port, the listener port of the Gateway
  1254                                  SHOULD be used. * If redirect scheme is empty, the
  1255                                  redirect port MUST be the Gateway Listener port.
  1256                                  \n Implementations SHOULD NOT add the port number
  1257                                  in the 'Location' header in the following cases:
  1258                                  \n * A Location header that will use HTTP (whether
  1259                                  that is determined via the Listener protocol or
  1260                                  the Scheme field) _and_ use port 80. * A Location
  1261                                  header that will use HTTPS (whether that is determined
  1262                                  via the Listener protocol or the Scheme field) _and_
  1263                                  use port 443. \n Support: Extended"
  1264                                format: int32
  1265                                maximum: 65535
  1266                                minimum: 1
  1267                                type: integer
  1268                              scheme:
  1269                                description: "Scheme is the scheme to be used in the
  1270                                  value of the `Location` header in the response.
  1271                                  When empty, the scheme of the request is used. \n
  1272                                  Scheme redirects can affect the port of the redirect,
  1273                                  for more information, refer to the documentation
  1274                                  for the port field of this filter. \n Note that
  1275                                  values may be added to this enum, implementations
  1276                                  must ensure that unknown values will not cause a
  1277                                  crash. \n Unknown values here must result in the
  1278                                  implementation setting the Accepted Condition for
  1279                                  the Route to `status: False`, with a Reason of `UnsupportedValue`.
  1280                                  \n Support: Extended"
  1281                                enum:
  1282                                - http
  1283                                - https
  1284                                type: string
  1285                              statusCode:
  1286                                default: 302
  1287                                description: "StatusCode is the HTTP status code to
  1288                                  be used in response. \n Note that values may be
  1289                                  added to this enum, implementations must ensure
  1290                                  that unknown values will not cause a crash. \n Unknown
  1291                                  values here must result in the implementation setting
  1292                                  the Accepted Condition for the Route to `status:
  1293                                  False`, with a Reason of `UnsupportedValue`. \n
  1294                                  Support: Core"
  1295                                enum:
  1296                                - 301
  1297                                - 302
  1298                                type: integer
  1299                            type: object
  1300                          responseHeaderModifier:
  1301                            description: "ResponseHeaderModifier defines a schema
  1302                              for a filter that modifies response headers. \n Support:
  1303                              Extended"
  1304                            properties:
  1305                              add:
  1306                                description: "Add adds the given header(s) (name,
  1307                                  value) to the request before the action. It appends
  1308                                  to any existing values associated with the header
  1309                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
  1310                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
  1311                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
  1312                                items:
  1313                                  description: HTTPHeader represents an HTTP Header
  1314                                    name and value as defined by RFC 7230.
  1315                                  properties:
  1316                                    name:
  1317                                      description: "Name is the name of the HTTP Header
  1318                                        to be matched. Name matching MUST be case
  1319                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1320                                        \n If multiple entries specify equivalent
  1321                                        header names, the first entry with an equivalent
  1322                                        name MUST be considered for a match. Subsequent
  1323                                        entries with an equivalent header name MUST
  1324                                        be ignored. Due to the case-insensitivity
  1325                                        of header names, \"foo\" and \"Foo\" are considered
  1326                                        equivalent."
  1327                                      maxLength: 256
  1328                                      minLength: 1
  1329                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1330                                      type: string
  1331                                    value:
  1332                                      description: Value is the value of HTTP Header
  1333                                        to be matched.
  1334                                      maxLength: 4096
  1335                                      minLength: 1
  1336                                      type: string
  1337                                  required:
  1338                                  - name
  1339                                  - value
  1340                                  type: object
  1341                                maxItems: 16
  1342                                type: array
  1343                                x-kubernetes-list-map-keys:
  1344                                - name
  1345                                x-kubernetes-list-type: map
  1346                              remove:
  1347                                description: "Remove the given header(s) from the
  1348                                  HTTP request before the action. The value of Remove
  1349                                  is a list of HTTP header names. Note that the header
  1350                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1351                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
  1352                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
  1353                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
  1354                                  bar"
  1355                                items:
  1356                                  type: string
  1357                                maxItems: 16
  1358                                type: array
  1359                              set:
  1360                                description: "Set overwrites the request with the
  1361                                  given header (name, value) before the action. \n
  1362                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
  1363                                  set: - name: \"my-header\" value: \"bar\" \n Output:
  1364                                  GET /foo HTTP/1.1 my-header: bar"
  1365                                items:
  1366                                  description: HTTPHeader represents an HTTP Header
  1367                                    name and value as defined by RFC 7230.
  1368                                  properties:
  1369                                    name:
  1370                                      description: "Name is the name of the HTTP Header
  1371                                        to be matched. Name matching MUST be case
  1372                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1373                                        \n If multiple entries specify equivalent
  1374                                        header names, the first entry with an equivalent
  1375                                        name MUST be considered for a match. Subsequent
  1376                                        entries with an equivalent header name MUST
  1377                                        be ignored. Due to the case-insensitivity
  1378                                        of header names, \"foo\" and \"Foo\" are considered
  1379                                        equivalent."
  1380                                      maxLength: 256
  1381                                      minLength: 1
  1382                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1383                                      type: string
  1384                                    value:
  1385                                      description: Value is the value of HTTP Header
  1386                                        to be matched.
  1387                                      maxLength: 4096
  1388                                      minLength: 1
  1389                                      type: string
  1390                                  required:
  1391                                  - name
  1392                                  - value
  1393                                  type: object
  1394                                maxItems: 16
  1395                                type: array
  1396                                x-kubernetes-list-map-keys:
  1397                                - name
  1398                                x-kubernetes-list-type: map
  1399                            type: object
  1400                          type:
  1401                            description: "Type identifies the type of filter to apply.
  1402                              As with other API fields, types are classified into
  1403                              three conformance levels: \n - Core: Filter types and
  1404                              their corresponding configuration defined by \"Support:
  1405                              Core\" in this package, e.g. \"RequestHeaderModifier\".
  1406                              All implementations must support core filters. \n -
  1407                              Extended: Filter types and their corresponding configuration
  1408                              defined by \"Support: Extended\" in this package, e.g.
  1409                              \"RequestMirror\". Implementers are encouraged to support
  1410                              extended filters. \n - Implementation-specific: Filters
  1411                              that are defined and supported by specific vendors.
  1412                              In the future, filters showing convergence in behavior
  1413                              across multiple implementations will be considered for
  1414                              inclusion in extended or core conformance levels. Filter-specific
  1415                              configuration for such filters is specified using the
  1416                              ExtensionRef field. `Type` should be set to \"ExtensionRef\"
  1417                              for custom filters. \n Implementers are encouraged to
  1418                              define custom implementation types to extend the core
  1419                              API with implementation-specific behavior. \n If a reference
  1420                              to a custom filter type cannot be resolved, the filter
  1421                              MUST NOT be skipped. Instead, requests that would have
  1422                              been processed by that filter MUST receive a HTTP error
  1423                              response. \n Note that values may be added to this enum,
  1424                              implementations must ensure that unknown values will
  1425                              not cause a crash. \n Unknown values here must result
  1426                              in the implementation setting the Accepted Condition
  1427                              for the Route to `status: False`, with a Reason of `UnsupportedValue`."
  1428                            enum:
  1429                            - RequestHeaderModifier
  1430                            - ResponseHeaderModifier
  1431                            - RequestMirror
  1432                            - RequestRedirect
  1433                            - URLRewrite
  1434                            - ExtensionRef
  1435                            type: string
  1436                          urlRewrite:
  1437                            description: "URLRewrite defines a schema for a filter
  1438                              that modifies a request during forwarding. \n Support:
  1439                              Extended"
  1440                            properties:
  1441                              hostname:
  1442                                description: "Hostname is the value to be used to
  1443                                  replace the Host header value during forwarding.
  1444                                  \n Support: Extended"
  1445                                maxLength: 253
  1446                                minLength: 1
  1447                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1448                                type: string
  1449                              path:
  1450                                description: "Path defines a path rewrite. \n Support:
  1451                                  Extended"
  1452                                properties:
  1453                                  replaceFullPath:
  1454                                    description: ReplaceFullPath specifies the value
  1455                                      with which to replace the full path of a request
  1456                                      during a rewrite or redirect.
  1457                                    maxLength: 1024
  1458                                    type: string
  1459                                  replacePrefixMatch:
  1460                                    description: "ReplacePrefixMatch specifies the
  1461                                      value with which to replace the prefix match
  1462                                      of a request during a rewrite or redirect. For
  1463                                      example, a request to \"/foo/bar\" with a prefix
  1464                                      match of \"/foo\" would be modified to \"/bar\".
  1465                                      \n Note that this matches the behavior of the
  1466                                      PathPrefix match type. This matches full path
  1467                                      elements. A path element refers to the list
  1468                                      of labels in the path split by the `/` separator.
  1469                                      When specified, a trailing `/` is ignored. For
  1470                                      example, the paths `/abc`, `/abc/`, and `/abc/def`
  1471                                      would all match the prefix `/abc`, but the path
  1472                                      `/abcd` would not."
  1473                                    maxLength: 1024
  1474                                    type: string
  1475                                  type:
  1476                                    description: "Type defines the type of path modifier.
  1477                                      Additional types may be added in a future release
  1478                                      of the API. \n Note that values may be added
  1479                                      to this enum, implementations must ensure that
  1480                                      unknown values will not cause a crash. \n Unknown
  1481                                      values here must result in the implementation
  1482                                      setting the Accepted Condition for the Route
  1483                                      to `status: False`, with a Reason of `UnsupportedValue`."
  1484                                    enum:
  1485                                    - ReplaceFullPath
  1486                                    - ReplacePrefixMatch
  1487                                    type: string
  1488                                required:
  1489                                - type
  1490                                type: object
  1491                            type: object
  1492                        required:
  1493                        - type
  1494                        type: object
  1495                      maxItems: 16
  1496                      type: array
  1497                    matches:
  1498                      default:
  1499                      - path:
  1500                          type: PathPrefix
  1501                          value: /
  1502                      description: "Matches define conditions used for matching the
  1503                        rule against incoming HTTP requests. Each match is independent,
  1504                        i.e. this rule will be matched if **any** one of the matches
  1505                        is satisfied. \n For example, take the following matches configuration:
  1506                        \n ``` matches: - path: value: \"/foo\" headers: - name: \"version\"
  1507                        value: \"v2\" - path: value: \"/v2/foo\" ``` \n For a request
  1508                        to match against this rule, a request must satisfy EITHER
  1509                        of the two conditions: \n - path prefixed with `/foo` AND
  1510                        contains the header `version: v2` - path prefix of `/v2/foo`
  1511                        \n See the documentation for HTTPRouteMatch on how to specify
  1512                        multiple match conditions that should be ANDed together. \n
  1513                        If no matches are specified, the default is a prefix path
  1514                        match on \"/\", which has the effect of matching every HTTP
  1515                        request. \n Proxy or Load Balancer routing configuration generated
  1516                        from HTTPRoutes MUST prioritize matches based on the following
  1517                        criteria, continuing on ties. Across all rules specified on
  1518                        applicable Routes, precedence must be given to the match having:
  1519                        \n * \"Exact\" path match. * \"Prefix\" path match with largest
  1520                        number of characters. * Method match. * Largest number of
  1521                        header matches. * Largest number of query param matches. \n
  1522                        Note: The precedence of RegularExpression path matches are
  1523                        implementation-specific. \n If ties still exist across multiple
  1524                        Routes, matching precedence MUST be determined in order of
  1525                        the following criteria, continuing on ties: \n * The oldest
  1526                        Route based on creation timestamp. * The Route appearing first
  1527                        in alphabetical order by \"{namespace}/{name}\". \n If ties
  1528                        still exist within an HTTPRoute, matching precedence MUST
  1529                        be granted to the FIRST matching rule (in list order) with
  1530                        a match meeting the above criteria. \n When no rules matching
  1531                        a request have been successfully attached to the parent a
  1532                        request is coming from, a HTTP 404 status code MUST be returned."
  1533                      items:
  1534                        description: "HTTPRouteMatch defines the predicate used to
  1535                          match requests to a given action. Multiple match types are
  1536                          ANDed together, i.e. the match will evaluate to true only
  1537                          if all conditions are satisfied. \n For example, the match
  1538                          below will match a HTTP request only if its path starts
  1539                          with `/foo` AND it contains the `version: v1` header: \n
  1540                          ``` match: \n path: value: \"/foo\" headers: - name: \"version\"
  1541                          value \"v1\" \n ```"
  1542                        properties:
  1543                          headers:
  1544                            description: Headers specifies HTTP request header matchers.
  1545                              Multiple match values are ANDed together, meaning, a
  1546                              request must match all the specified headers to select
  1547                              the route.
  1548                            items:
  1549                              description: HTTPHeaderMatch describes how to select
  1550                                a HTTP route by matching HTTP request headers.
  1551                              properties:
  1552                                name:
  1553                                  description: "Name is the name of the HTTP Header
  1554                                    to be matched. Name matching MUST be case insensitive.
  1555                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1556                                    \n If multiple entries specify equivalent header
  1557                                    names, only the first entry with an equivalent
  1558                                    name MUST be considered for a match. Subsequent
  1559                                    entries with an equivalent header name MUST be
  1560                                    ignored. Due to the case-insensitivity of header
  1561                                    names, \"foo\" and \"Foo\" are considered equivalent.
  1562                                    \n When a header is repeated in an HTTP request,
  1563                                    it is implementation-specific behavior as to how
  1564                                    this is represented. Generally, proxies should
  1565                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
  1566                                    regarding processing a repeated header, with special
  1567                                    handling for \"Set-Cookie\"."
  1568                                  maxLength: 256
  1569                                  minLength: 1
  1570                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1571                                  type: string
  1572                                type:
  1573                                  default: Exact
  1574                                  description: "Type specifies how to match against
  1575                                    the value of the header. \n Support: Core (Exact)
  1576                                    \n Support: Implementation-specific (RegularExpression)
  1577                                    \n Since RegularExpression HeaderMatchType has
  1578                                    implementation-specific conformance, implementations
  1579                                    can support POSIX, PCRE or any other dialects
  1580                                    of regular expressions. Please read the implementation's
  1581                                    documentation to determine the supported dialect."
  1582                                  enum:
  1583                                  - Exact
  1584                                  - RegularExpression
  1585                                  type: string
  1586                                value:
  1587                                  description: Value is the value of HTTP Header to
  1588                                    be matched.
  1589                                  maxLength: 4096
  1590                                  minLength: 1
  1591                                  type: string
  1592                              required:
  1593                              - name
  1594                              - value
  1595                              type: object
  1596                            maxItems: 16
  1597                            type: array
  1598                            x-kubernetes-list-map-keys:
  1599                            - name
  1600                            x-kubernetes-list-type: map
  1601                          method:
  1602                            description: "Method specifies HTTP method matcher. When
  1603                              specified, this route will be matched only if the request
  1604                              has the specified method. \n Support: Extended"
  1605                            enum:
  1606                            - GET
  1607                            - HEAD
  1608                            - POST
  1609                            - PUT
  1610                            - DELETE
  1611                            - CONNECT
  1612                            - OPTIONS
  1613                            - TRACE
  1614                            - PATCH
  1615                            type: string
  1616                          path:
  1617                            default:
  1618                              type: PathPrefix
  1619                              value: /
  1620                            description: Path specifies a HTTP request path matcher.
  1621                              If this field is not specified, a default prefix match
  1622                              on the "/" path is provided.
  1623                            properties:
  1624                              type:
  1625                                default: PathPrefix
  1626                                description: "Type specifies how to match against
  1627                                  the path Value. \n Support: Core (Exact, PathPrefix)
  1628                                  \n Support: Implementation-specific (RegularExpression)"
  1629                                enum:
  1630                                - Exact
  1631                                - PathPrefix
  1632                                - RegularExpression
  1633                                type: string
  1634                              value:
  1635                                default: /
  1636                                description: Value of the HTTP path to match against.
  1637                                maxLength: 1024
  1638                                type: string
  1639                            type: object
  1640                          queryParams:
  1641                            description: "QueryParams specifies HTTP query parameter
  1642                              matchers. Multiple match values are ANDed together,
  1643                              meaning, a request must match all the specified query
  1644                              parameters to select the route. \n Support: Extended"
  1645                            items:
  1646                              description: HTTPQueryParamMatch describes how to select
  1647                                a HTTP route by matching HTTP query parameters.
  1648                              properties:
  1649                                name:
  1650                                  description: "Name is the name of the HTTP query
  1651                                    param to be matched. This must be an exact string
  1652                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  1653                                    \n If multiple entries specify equivalent query
  1654                                    param names, only the first entry with an equivalent
  1655                                    name MUST be considered for a match. Subsequent
  1656                                    entries with an equivalent query param name MUST
  1657                                    be ignored. \n If a query param is repeated in
  1658                                    an HTTP request, the behavior is purposely left
  1659                                    undefined, since different data planes have different
  1660                                    capabilities. However, it is *recommended* that
  1661                                    implementations should match against the first
  1662                                    value of the param if the data plane supports
  1663                                    it, as this behavior is expected in other load
  1664                                    balancing contexts outside of the Gateway API.
  1665                                    \n Users SHOULD NOT route traffic based on repeated
  1666                                    query params to guard themselves against potential
  1667                                    differences in the implementations."
  1668                                  maxLength: 256
  1669                                  minLength: 1
  1670                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1671                                  type: string
  1672                                type:
  1673                                  default: Exact
  1674                                  description: "Type specifies how to match against
  1675                                    the value of the query parameter. \n Support:
  1676                                    Extended (Exact) \n Support: Implementation-specific
  1677                                    (RegularExpression) \n Since RegularExpression
  1678                                    QueryParamMatchType has Implementation-specific
  1679                                    conformance, implementations can support POSIX,
  1680                                    PCRE or any other dialects of regular expressions.
  1681                                    Please read the implementation's documentation
  1682                                    to determine the supported dialect."
  1683                                  enum:
  1684                                  - Exact
  1685                                  - RegularExpression
  1686                                  type: string
  1687                                value:
  1688                                  description: Value is the value of HTTP query param
  1689                                    to be matched.
  1690                                  maxLength: 1024
  1691                                  minLength: 1
  1692                                  type: string
  1693                              required:
  1694                              - name
  1695                              - value
  1696                              type: object
  1697                            maxItems: 16
  1698                            type: array
  1699                            x-kubernetes-list-map-keys:
  1700                            - name
  1701                            x-kubernetes-list-type: map
  1702                        type: object
  1703                      maxItems: 8
  1704                      type: array
  1705                  type: object
  1706                maxItems: 16
  1707                type: array
  1708            type: object
  1709          status:
  1710            description: Status defines the current state of HTTPRoute.
  1711            properties:
  1712              parents:
  1713                description: "Parents is a list of parent resources (usually Gateways)
  1714                  that are associated with the route, and the status of the route
  1715                  with respect to each parent. When this route attaches to a parent,
  1716                  the controller that manages the parent must add an entry to this
  1717                  list when the controller first sees the route and should update
  1718                  the entry as appropriate when the route or gateway is modified.
  1719                  \n Note that parent references that cannot be resolved by an implementation
  1720                  of this API will not be added to this list. Implementations of this
  1721                  API can only populate Route status for the Gateways/parent resources
  1722                  they are responsible for. \n A maximum of 32 Gateways will be represented
  1723                  in this list. An empty list means the route has not been attached
  1724                  to any Gateway."
  1725                items:
  1726                  description: RouteParentStatus describes the status of a route with
  1727                    respect to an associated Parent.
  1728                  properties:
  1729                    conditions:
  1730                      description: "Conditions describes the status of the route with
  1731                        respect to the Gateway. Note that the route's availability
  1732                        is also subject to the Gateway's own status conditions and
  1733                        listener status. \n If the Route's ParentRef specifies an
  1734                        existing Gateway that supports Routes of this kind AND that
  1735                        Gateway's controller has sufficient access, then that Gateway's
  1736                        controller MUST set the \"Accepted\" condition on the Route,
  1737                        to indicate whether the route has been accepted or rejected
  1738                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  1739                        if at least one of the Route's rules is implemented by the
  1740                        Gateway. \n There are a number of cases where the \"Accepted\"
  1741                        condition may not be set due to lack of controller visibility,
  1742                        that includes when: \n * The Route refers to a non-existent
  1743                        parent. * The Route is of a type that the controller does
  1744                        not support. * The Route is in a namespace the controller
  1745                        does not have access to."
  1746                      items:
  1747                        description: "Condition contains details for one aspect of
  1748                          the current state of this API Resource. --- This struct
  1749                          is intended for direct use as an array at the field path
  1750                          .status.conditions.  For example, \n type FooStatus struct{
  1751                          // Represents the observations of a foo's current state.
  1752                          // Known .status.conditions.type are: \"Available\", \"Progressing\",
  1753                          and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge
  1754                          // +listType=map // +listMapKey=type Conditions []metav1.Condition
  1755                          `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\"
  1756                          protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields
  1757                          }"
  1758                        properties:
  1759                          lastTransitionTime:
  1760                            description: lastTransitionTime is the last time the condition
  1761                              transitioned from one status to another. This should
  1762                              be when the underlying condition changed.  If that is
  1763                              not known, then using the time when the API field changed
  1764                              is acceptable.
  1765                            format: date-time
  1766                            type: string
  1767                          message:
  1768                            description: message is a human readable message indicating
  1769                              details about the transition. This may be an empty string.
  1770                            maxLength: 32768
  1771                            type: string
  1772                          observedGeneration:
  1773                            description: observedGeneration represents the .metadata.generation
  1774                              that the condition was set based upon. For instance,
  1775                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  1776                              is 9, the condition is out of date with respect to the
  1777                              current state of the instance.
  1778                            format: int64
  1779                            minimum: 0
  1780                            type: integer
  1781                          reason:
  1782                            description: reason contains a programmatic identifier
  1783                              indicating the reason for the condition's last transition.
  1784                              Producers of specific condition types may define expected
  1785                              values and meanings for this field, and whether the
  1786                              values are considered a guaranteed API. The value should
  1787                              be a CamelCase string. This field may not be empty.
  1788                            maxLength: 1024
  1789                            minLength: 1
  1790                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  1791                            type: string
  1792                          status:
  1793                            description: status of the condition, one of True, False,
  1794                              Unknown.
  1795                            enum:
  1796                            - "True"
  1797                            - "False"
  1798                            - Unknown
  1799                            type: string
  1800                          type:
  1801                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  1802                              --- Many .condition.type values are consistent across
  1803                              resources like Available, but because arbitrary conditions
  1804                              can be useful (see .node.status.conditions), the ability
  1805                              to deconflict is important. The regex it matches is
  1806                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  1807                            maxLength: 316
  1808                            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])$
  1809                            type: string
  1810                        required:
  1811                        - lastTransitionTime
  1812                        - message
  1813                        - reason
  1814                        - status
  1815                        - type
  1816                        type: object
  1817                      maxItems: 8
  1818                      minItems: 1
  1819                      type: array
  1820                      x-kubernetes-list-map-keys:
  1821                      - type
  1822                      x-kubernetes-list-type: map
  1823                    controllerName:
  1824                      description: "ControllerName is a domain/path string that indicates
  1825                        the name of the controller that wrote this status. This corresponds
  1826                        with the controllerName field on GatewayClass. \n Example:
  1827                        \"example.net/gateway-controller\". \n The format of this
  1828                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  1829                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  1830                        \n Controllers MUST populate this field when writing status.
  1831                        Controllers should ensure that entries to status populated
  1832                        with their ControllerName are cleaned up when they are no
  1833                        longer necessary."
  1834                      maxLength: 253
  1835                      minLength: 1
  1836                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  1837                      type: string
  1838                    parentRef:
  1839                      description: ParentRef corresponds with a ParentRef in the spec
  1840                        that this RouteParentStatus struct describes the status of.
  1841                      properties:
  1842                        group:
  1843                          default: gateway.networking.k8s.io
  1844                          description: "Group is the group of the referent. When unspecified,
  1845                            \"gateway.networking.k8s.io\" is inferred. To set the
  1846                            core API group (such as for a \"Service\" kind referent),
  1847                            Group must be explicitly set to \"\" (empty string). \n
  1848                            Support: Core"
  1849                          maxLength: 253
  1850                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1851                          type: string
  1852                        kind:
  1853                          default: Gateway
  1854                          description: "Kind is kind of the referent. \n Support:
  1855                            Core (Gateway) \n Support: Implementation-specific (Other
  1856                            Resources)"
  1857                          maxLength: 63
  1858                          minLength: 1
  1859                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  1860                          type: string
  1861                        name:
  1862                          description: "Name is the name of the referent. \n Support:
  1863                            Core"
  1864                          maxLength: 253
  1865                          minLength: 1
  1866                          type: string
  1867                        namespace:
  1868                          description: "Namespace is the namespace of the referent.
  1869                            When unspecified, this refers to the local namespace of
  1870                            the Route. \n Note that there are specific rules for ParentRefs
  1871                            which cross namespace boundaries. Cross-namespace references
  1872                            are only valid if they are explicitly allowed by something
  1873                            in the namespace they are referring to. For example: Gateway
  1874                            has the AllowedRoutes field, and ReferenceGrant provides
  1875                            a generic way to enable any other kind of cross-namespace
  1876                            reference. \n Support: Core"
  1877                          maxLength: 63
  1878                          minLength: 1
  1879                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  1880                          type: string
  1881                        port:
  1882                          description: "Port is the network port this Route targets.
  1883                            It can be interpreted differently based on the type of
  1884                            parent resource. \n When the parent resource is a Gateway,
  1885                            this targets all listeners listening on the specified
  1886                            port that also support this kind of Route(and select this
  1887                            Route). It's not recommended to set `Port` unless the
  1888                            networking behaviors specified in a Route must apply to
  1889                            a specific port as opposed to a listener(s) whose port(s)
  1890                            may be changed. When both Port and SectionName are specified,
  1891                            the name and port of the selected listener must match
  1892                            both specified values. \n Implementations MAY choose to
  1893                            support other parent resources. Implementations supporting
  1894                            other types of parent resources MUST clearly document
  1895                            how/if Port is interpreted. \n For the purpose of status,
  1896                            an attachment is considered successful as long as the
  1897                            parent resource accepts it partially. For example, Gateway
  1898                            listeners can restrict which Routes can attach to them
  1899                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  1900                            listeners accept attachment from the referencing Route,
  1901                            the Route MUST be considered successfully attached. If
  1902                            no Gateway listeners accept attachment from this Route,
  1903                            the Route MUST be considered detached from the Gateway.
  1904                            \n Support: Extended \n <gateway:experimental>"
  1905                          format: int32
  1906                          maximum: 65535
  1907                          minimum: 1
  1908                          type: integer
  1909                        sectionName:
  1910                          description: "SectionName is the name of a section within
  1911                            the target resource. In the following resources, SectionName
  1912                            is interpreted as the following: \n * Gateway: Listener
  1913                            Name. When both Port (experimental) and SectionName are
  1914                            specified, the name and port of the selected listener
  1915                            must match both specified values. \n Implementations MAY
  1916                            choose to support attaching Routes to other resources.
  1917                            If that is the case, they MUST clearly document how SectionName
  1918                            is interpreted. \n When unspecified (empty string), this
  1919                            will reference the entire resource. For the purpose of
  1920                            status, an attachment is considered successful if at least
  1921                            one section in the parent resource accepts it. For example,
  1922                            Gateway listeners can restrict which Routes can attach
  1923                            to them by Route kind, namespace, or hostname. If 1 of
  1924                            2 Gateway listeners accept attachment from the referencing
  1925                            Route, the Route MUST be considered successfully attached.
  1926                            If no Gateway listeners accept attachment from this Route,
  1927                            the Route MUST be considered detached from the Gateway.
  1928                            \n Support: Core"
  1929                          maxLength: 253
  1930                          minLength: 1
  1931                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1932                          type: string
  1933                      required:
  1934                      - name
  1935                      type: object
  1936                  required:
  1937                  - controllerName
  1938                  - parentRef
  1939                  type: object
  1940                maxItems: 32
  1941                type: array
  1942            required:
  1943            - parents
  1944            type: object
  1945        required:
  1946        - spec
  1947        type: object
  1948    served: true
  1949    storage: false
  1950    subresources:
  1951      status: {}
  1952  - additionalPrinterColumns:
  1953    - jsonPath: .spec.hostnames
  1954      name: Hostnames
  1955      type: string
  1956    - jsonPath: .metadata.creationTimestamp
  1957      name: Age
  1958      type: date
  1959    name: v1beta1
  1960    schema:
  1961      openAPIV3Schema:
  1962        description: HTTPRoute provides a way to route HTTP requests. This includes
  1963          the capability to match requests by hostname, path, header, or query param.
  1964          Filters can be used to specify additional processing steps. Backends specify
  1965          where matching requests should be routed.
  1966        properties:
  1967          apiVersion:
  1968            description: 'APIVersion defines the versioned schema of this representation
  1969              of an object. Servers should convert recognized schemas to the latest
  1970              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
  1971            type: string
  1972          kind:
  1973            description: 'Kind is a string value representing the REST resource this
  1974              object represents. Servers may infer this from the endpoint the client
  1975              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
  1976            type: string
  1977          metadata:
  1978            type: object
  1979          spec:
  1980            description: Spec defines the desired state of HTTPRoute.
  1981            properties:
  1982              hostnames:
  1983                description: "Hostnames defines a set of hostname that should match
  1984                  against the HTTP Host header to select a HTTPRoute used to process
  1985                  the request. Implementations MUST ignore any port value specified
  1986                  in the HTTP Host header while performing a match. \n Valid values
  1987                  for Hostnames are determined by RFC 1123 definition of a hostname
  1988                  with 2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
  1989                  may be prefixed with a wildcard label (`*.`). The wildcard label
  1990                  must appear by itself as the first label. \n If a hostname is specified
  1991                  by both the Listener and HTTPRoute, there must be at least one intersecting
  1992                  hostname for the HTTPRoute to be attached to the Listener. For example:
  1993                  \n * A Listener with `test.example.com` as the hostname matches
  1994                  HTTPRoutes that have either not specified any hostnames, or have
  1995                  specified at least one of `test.example.com` or `*.example.com`.
  1996                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
  1997                  that have either not specified any hostnames or have specified at
  1998                  least one hostname that matches the Listener hostname. For example,
  1999                  `*.example.com`, `test.example.com`, and `foo.test.example.com`
  2000                  would all match. On the other hand, `example.com` and `test.example.net`
  2001                  would not match. \n Hostnames that are prefixed with a wildcard
  2002                  label (`*.`) are interpreted as a suffix match. That means that
  2003                  a match for `*.example.com` would match both `test.example.com`,
  2004                  and `foo.test.example.com`, but not `example.com`. \n If both the
  2005                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
  2006                  that do not match the Listener hostname MUST be ignored. For example,
  2007                  if a Listener specified `*.example.com`, and the HTTPRoute specified
  2008                  `test.example.com` and `test.example.net`, `test.example.net` must
  2009                  not be considered for a match. \n If both the Listener and HTTPRoute
  2010                  have specified hostnames, and none match with the criteria above,
  2011                  then the HTTPRoute is not accepted. The implementation must raise
  2012                  an 'Accepted' Condition with a status of `False` in the corresponding
  2013                  RouteParentStatus. \n In the event that multiple HTTPRoutes specify
  2014                  intersecting hostnames (e.g. overlapping wildcard matching and exact
  2015                  matching hostnames), precedence must be given to rules from the
  2016                  HTTPRoute with the largest number of: \n * Characters in a matching
  2017                  non-wildcard hostname. * Characters in a matching hostname. \n If
  2018                  ties exist across multiple Routes, the matching precedence rules
  2019                  for HTTPRouteMatches takes over. \n Support: Core"
  2020                items:
  2021                  description: "Hostname is the fully qualified domain name of a network
  2022                    host. This matches the RFC 1123 definition of a hostname with
  2023                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
  2024                    may be prefixed with a wildcard label (`*.`). The wildcard label
  2025                    must appear by itself as the first label. \n Hostname can be \"precise\"
  2026                    which is a domain name without the terminating dot of a network
  2027                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
  2028                    name prefixed with a single wildcard label (e.g. `*.example.com`).
  2029                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
  2030                    of lower case alphanumeric characters or '-', and must start and
  2031                    end with an alphanumeric character. No other punctuation is allowed."
  2032                  maxLength: 253
  2033                  minLength: 1
  2034                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2035                  type: string
  2036                maxItems: 16
  2037                type: array
  2038              parentRefs:
  2039                description: "ParentRefs references the resources (usually Gateways)
  2040                  that a Route wants to be attached to. Note that the referenced parent
  2041                  resource needs to allow this for the attachment to be complete.
  2042                  For Gateways, that means the Gateway needs to allow attachment from
  2043                  Routes of this kind and namespace. \n The only kind of parent resource
  2044                  with \"Core\" support is Gateway. This API may be extended in the
  2045                  future to support additional kinds of parent resources such as one
  2046                  of the route kinds. \n It is invalid to reference an identical parent
  2047                  more than once. It is valid to reference multiple distinct sections
  2048                  within the same parent resource, such as 2 Listeners within a Gateway.
  2049                  \n It is possible to separately reference multiple distinct objects
  2050                  that may be collapsed by an implementation. For example, some implementations
  2051                  may choose to merge compatible Gateway Listeners together. If that
  2052                  is the case, the list of routes attached to those resources should
  2053                  also be merged. \n Note that for ParentRefs that cross namespace
  2054                  boundaries, there are specific rules. Cross-namespace references
  2055                  are only valid if they are explicitly allowed by something in the
  2056                  namespace they are referring to. For example, Gateway has the AllowedRoutes
  2057                  field, and ReferenceGrant provides a generic way to enable any other
  2058                  kind of cross-namespace reference."
  2059                items:
  2060                  description: "ParentReference identifies an API object (usually
  2061                    a Gateway) that can be considered a parent of this resource (usually
  2062                    a route). The only kind of parent resource with \"Core\" support
  2063                    is Gateway. This API may be extended in the future to support
  2064                    additional kinds of parent resources, such as HTTPRoute. \n The
  2065                    API object must be valid in the cluster; the Group and Kind must
  2066                    be registered in the cluster for this reference to be valid."
  2067                  properties:
  2068                    group:
  2069                      default: gateway.networking.k8s.io
  2070                      description: "Group is the group of the referent. When unspecified,
  2071                        \"gateway.networking.k8s.io\" is inferred. To set the core
  2072                        API group (such as for a \"Service\" kind referent), Group
  2073                        must be explicitly set to \"\" (empty string). \n Support:
  2074                        Core"
  2075                      maxLength: 253
  2076                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2077                      type: string
  2078                    kind:
  2079                      default: Gateway
  2080                      description: "Kind is kind of the referent. \n Support: Core
  2081                        (Gateway) \n Support: Implementation-specific (Other Resources)"
  2082                      maxLength: 63
  2083                      minLength: 1
  2084                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2085                      type: string
  2086                    name:
  2087                      description: "Name is the name of the referent. \n Support:
  2088                        Core"
  2089                      maxLength: 253
  2090                      minLength: 1
  2091                      type: string
  2092                    namespace:
  2093                      description: "Namespace is the namespace of the referent. When
  2094                        unspecified, this refers to the local namespace of the Route.
  2095                        \n Note that there are specific rules for ParentRefs which
  2096                        cross namespace boundaries. Cross-namespace references are
  2097                        only valid if they are explicitly allowed by something in
  2098                        the namespace they are referring to. For example: Gateway
  2099                        has the AllowedRoutes field, and ReferenceGrant provides a
  2100                        generic way to enable any other kind of cross-namespace reference.
  2101                        \n Support: Core"
  2102                      maxLength: 63
  2103                      minLength: 1
  2104                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2105                      type: string
  2106                    port:
  2107                      description: "Port is the network port this Route targets. It
  2108                        can be interpreted differently based on the type of parent
  2109                        resource. \n When the parent resource is a Gateway, this targets
  2110                        all listeners listening on the specified port that also support
  2111                        this kind of Route(and select this Route). It's not recommended
  2112                        to set `Port` unless the networking behaviors specified in
  2113                        a Route must apply to a specific port as opposed to a listener(s)
  2114                        whose port(s) may be changed. When both Port and SectionName
  2115                        are specified, the name and port of the selected listener
  2116                        must match both specified values. \n Implementations MAY choose
  2117                        to support other parent resources. Implementations supporting
  2118                        other types of parent resources MUST clearly document how/if
  2119                        Port is interpreted. \n For the purpose of status, an attachment
  2120                        is considered successful as long as the parent resource accepts
  2121                        it partially. For example, Gateway listeners can restrict
  2122                        which Routes can attach to them by Route kind, namespace,
  2123                        or hostname. If 1 of 2 Gateway listeners accept attachment
  2124                        from the referencing Route, the Route MUST be considered successfully
  2125                        attached. If no Gateway listeners accept attachment from this
  2126                        Route, the Route MUST be considered detached from the Gateway.
  2127                        \n Support: Extended \n <gateway:experimental>"
  2128                      format: int32
  2129                      maximum: 65535
  2130                      minimum: 1
  2131                      type: integer
  2132                    sectionName:
  2133                      description: "SectionName is the name of a section within the
  2134                        target resource. In the following resources, SectionName is
  2135                        interpreted as the following: \n * Gateway: Listener Name.
  2136                        When both Port (experimental) and SectionName are specified,
  2137                        the name and port of the selected listener must match both
  2138                        specified values. \n Implementations MAY choose to support
  2139                        attaching Routes to other resources. If that is the case,
  2140                        they MUST clearly document how SectionName is interpreted.
  2141                        \n When unspecified (empty string), this will reference the
  2142                        entire resource. For the purpose of status, an attachment
  2143                        is considered successful if at least one section in the parent
  2144                        resource accepts it. For example, Gateway listeners can restrict
  2145                        which Routes can attach to them by Route kind, namespace,
  2146                        or hostname. If 1 of 2 Gateway listeners accept attachment
  2147                        from the referencing Route, the Route MUST be considered successfully
  2148                        attached. If no Gateway listeners accept attachment from this
  2149                        Route, the Route MUST be considered detached from the Gateway.
  2150                        \n Support: Core"
  2151                      maxLength: 253
  2152                      minLength: 1
  2153                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2154                      type: string
  2155                  required:
  2156                  - name
  2157                  type: object
  2158                maxItems: 32
  2159                type: array
  2160              rules:
  2161                default:
  2162                - matches:
  2163                  - path:
  2164                      type: PathPrefix
  2165                      value: /
  2166                description: Rules are a list of HTTP matchers, filters and actions.
  2167                items:
  2168                  description: HTTPRouteRule defines semantics for matching an HTTP
  2169                    request based on conditions (matches), processing it (filters),
  2170                    and forwarding the request to an API object (backendRefs).
  2171                  properties:
  2172                    backendRefs:
  2173                      description: "BackendRefs defines the backend(s) where matching
  2174                        requests should be sent. \n Failure behavior here depends
  2175                        on how many BackendRefs are specified and how many are invalid.
  2176                        \n If *all* entries in BackendRefs are invalid, and there
  2177                        are also no filters specified in this route rule, *all* traffic
  2178                        which matches this rule MUST receive a 500 status code. \n
  2179                        See the HTTPBackendRef definition for the rules about what
  2180                        makes a single HTTPBackendRef invalid. \n When a HTTPBackendRef
  2181                        is invalid, 500 status codes MUST be returned for requests
  2182                        that would have otherwise been routed to an invalid backend.
  2183                        If multiple backends are specified, and some are invalid,
  2184                        the proportion of requests that would otherwise have been
  2185                        routed to an invalid backend MUST receive a 500 status code.
  2186                        \n For example, if two backends are specified with equal weights,
  2187                        and one is invalid, 50 percent of traffic must receive a 500.
  2188                        Implementations may choose how that 50 percent is determined.
  2189                        \n Support: Core for Kubernetes Service \n Support: Extended
  2190                        for Kubernetes ServiceImport \n Support: Implementation-specific
  2191                        for any other resource \n Support for weight: Core"
  2192                      items:
  2193                        description: HTTPBackendRef defines how a HTTPRoute should
  2194                          forward an HTTP request.
  2195                        properties:
  2196                          filters:
  2197                            description: "Filters defined at this level should be
  2198                              executed if and only if the request is being forwarded
  2199                              to the backend defined here. \n Support: Implementation-specific
  2200                              (For broader support of filters, use the Filters field
  2201                              in HTTPRouteRule.)"
  2202                            items:
  2203                              description: HTTPRouteFilter defines processing steps
  2204                                that must be completed during the request or response
  2205                                lifecycle. HTTPRouteFilters are meant as an extension
  2206                                point to express processing that may be done in Gateway
  2207                                implementations. Some examples include request or
  2208                                response modification, implementing authentication
  2209                                strategies, rate-limiting, and traffic shaping. API
  2210                                guarantee/conformance is defined based on the type
  2211                                of the filter.
  2212                              properties:
  2213                                extensionRef:
  2214                                  description: "ExtensionRef is an optional, implementation-specific
  2215                                    extension to the \"filter\" behavior.  For example,
  2216                                    resource \"myroutefilter\" in group \"networking.example.net\").
  2217                                    ExtensionRef MUST NOT be used for core and extended
  2218                                    filters. \n Support: Implementation-specific"
  2219                                  properties:
  2220                                    group:
  2221                                      description: Group is the group of the referent.
  2222                                        For example, "gateway.networking.k8s.io".
  2223                                        When unspecified or empty string, core API
  2224                                        group is inferred.
  2225                                      maxLength: 253
  2226                                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2227                                      type: string
  2228                                    kind:
  2229                                      description: Kind is kind of the referent. For
  2230                                        example "HTTPRoute" or "Service".
  2231                                      maxLength: 63
  2232                                      minLength: 1
  2233                                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2234                                      type: string
  2235                                    name:
  2236                                      description: Name is the name of the referent.
  2237                                      maxLength: 253
  2238                                      minLength: 1
  2239                                      type: string
  2240                                  required:
  2241                                  - group
  2242                                  - kind
  2243                                  - name
  2244                                  type: object
  2245                                requestHeaderModifier:
  2246                                  description: "RequestHeaderModifier defines a schema
  2247                                    for a filter that modifies request headers. \n
  2248                                    Support: Core"
  2249                                  properties:
  2250                                    add:
  2251                                      description: "Add adds the given header(s) (name,
  2252                                        value) to the request before the action. It
  2253                                        appends to any existing values associated
  2254                                        with the header name. \n Input: GET /foo HTTP/1.1
  2255                                        my-header: foo \n Config: add: - name: \"my-header\"
  2256                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  2257                                        my-header: foo,bar,baz"
  2258                                      items:
  2259                                        description: HTTPHeader represents an HTTP
  2260                                          Header name and value as defined by RFC
  2261                                          7230.
  2262                                        properties:
  2263                                          name:
  2264                                            description: "Name is the name of the
  2265                                              HTTP Header to be matched. Name matching
  2266                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2267                                              \n If multiple entries specify equivalent
  2268                                              header names, the first entry with an
  2269                                              equivalent name MUST be considered for
  2270                                              a match. Subsequent entries with an
  2271                                              equivalent header name MUST be ignored.
  2272                                              Due to the case-insensitivity of header
  2273                                              names, \"foo\" and \"Foo\" are considered
  2274                                              equivalent."
  2275                                            maxLength: 256
  2276                                            minLength: 1
  2277                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2278                                            type: string
  2279                                          value:
  2280                                            description: Value is the value of HTTP
  2281                                              Header to be matched.
  2282                                            maxLength: 4096
  2283                                            minLength: 1
  2284                                            type: string
  2285                                        required:
  2286                                        - name
  2287                                        - value
  2288                                        type: object
  2289                                      maxItems: 16
  2290                                      type: array
  2291                                      x-kubernetes-list-map-keys:
  2292                                      - name
  2293                                      x-kubernetes-list-type: map
  2294                                    remove:
  2295                                      description: "Remove the given header(s) from
  2296                                        the HTTP request before the action. The value
  2297                                        of Remove is a list of HTTP header names.
  2298                                        Note that the header names are case-insensitive
  2299                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  2300                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  2301                                        my-header2: bar my-header3: baz \n Config:
  2302                                        remove: [\"my-header1\", \"my-header3\"] \n
  2303                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  2304                                      items:
  2305                                        type: string
  2306                                      maxItems: 16
  2307                                      type: array
  2308                                    set:
  2309                                      description: "Set overwrites the request with
  2310                                        the given header (name, value) before the
  2311                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  2312                                        foo \n Config: set: - name: \"my-header\"
  2313                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  2314                                        my-header: bar"
  2315                                      items:
  2316                                        description: HTTPHeader represents an HTTP
  2317                                          Header name and value as defined by RFC
  2318                                          7230.
  2319                                        properties:
  2320                                          name:
  2321                                            description: "Name is the name of the
  2322                                              HTTP Header to be matched. Name matching
  2323                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2324                                              \n If multiple entries specify equivalent
  2325                                              header names, the first entry with an
  2326                                              equivalent name MUST be considered for
  2327                                              a match. Subsequent entries with an
  2328                                              equivalent header name MUST be ignored.
  2329                                              Due to the case-insensitivity of header
  2330                                              names, \"foo\" and \"Foo\" are considered
  2331                                              equivalent."
  2332                                            maxLength: 256
  2333                                            minLength: 1
  2334                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2335                                            type: string
  2336                                          value:
  2337                                            description: Value is the value of HTTP
  2338                                              Header to be matched.
  2339                                            maxLength: 4096
  2340                                            minLength: 1
  2341                                            type: string
  2342                                        required:
  2343                                        - name
  2344                                        - value
  2345                                        type: object
  2346                                      maxItems: 16
  2347                                      type: array
  2348                                      x-kubernetes-list-map-keys:
  2349                                      - name
  2350                                      x-kubernetes-list-type: map
  2351                                  type: object
  2352                                requestMirror:
  2353                                  description: "RequestMirror defines a schema for
  2354                                    a filter that mirrors requests. Requests are sent
  2355                                    to the specified destination, but responses from
  2356                                    that destination are ignored. \n Support: Extended"
  2357                                  properties:
  2358                                    backendRef:
  2359                                      description: "BackendRef references a resource
  2360                                        where mirrored requests are sent. \n If the
  2361                                        referent cannot be found, this BackendRef
  2362                                        is invalid and must be dropped from the Gateway.
  2363                                        The controller must ensure the \"ResolvedRefs\"
  2364                                        condition on the Route status is set to `status:
  2365                                        False` and not configure this backend in the
  2366                                        underlying implementation. \n If there is
  2367                                        a cross-namespace reference to an *existing*
  2368                                        object that is not allowed by a ReferenceGrant,
  2369                                        the controller must ensure the \"ResolvedRefs\"
  2370                                        \ condition on the Route is set to `status:
  2371                                        False`, with the \"RefNotPermitted\" reason
  2372                                        and not configure this backend in the underlying
  2373                                        implementation. \n In either error case, the
  2374                                        Message of the `ResolvedRefs` Condition should
  2375                                        be used to provide more detail about the problem.
  2376                                        \n Support: Extended for Kubernetes Service
  2377                                        \n Support: Implementation-specific for any
  2378                                        other resource"
  2379                                      properties:
  2380                                        group:
  2381                                          default: ""
  2382                                          description: Group is the group of the referent.
  2383                                            For example, "gateway.networking.k8s.io".
  2384                                            When unspecified or empty string, core
  2385                                            API group is inferred.
  2386                                          maxLength: 253
  2387                                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2388                                          type: string
  2389                                        kind:
  2390                                          default: Service
  2391                                          description: "Kind is the Kubernetes resource
  2392                                            kind of the referent. For example \"Service\".
  2393                                            \n Defaults to \"Service\" when not specified.
  2394                                            \n ExternalName services can refer to
  2395                                            CNAME DNS records that may live outside
  2396                                            of the cluster and as such are difficult
  2397                                            to reason about in terms of conformance.
  2398                                            They also may not be safe to forward to
  2399                                            (see CVE-2021-25740 for more information).
  2400                                            Implementations SHOULD NOT support ExternalName
  2401                                            Services. \n Support: Core (Services with
  2402                                            a type other than ExternalName) \n Support:
  2403                                            Implementation-specific (Services with
  2404                                            type ExternalName)"
  2405                                          maxLength: 63
  2406                                          minLength: 1
  2407                                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2408                                          type: string
  2409                                        name:
  2410                                          description: Name is the name of the referent.
  2411                                          maxLength: 253
  2412                                          minLength: 1
  2413                                          type: string
  2414                                        namespace:
  2415                                          description: "Namespace is the namespace
  2416                                            of the backend. When unspecified, the
  2417                                            local namespace is inferred. \n Note that
  2418                                            when a namespace different than the local
  2419                                            namespace is specified, a ReferenceGrant
  2420                                            object is required in the referent namespace
  2421                                            to allow that namespace's owner to accept
  2422                                            the reference. See the ReferenceGrant
  2423                                            documentation for details. \n Support:
  2424                                            Core"
  2425                                          maxLength: 63
  2426                                          minLength: 1
  2427                                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2428                                          type: string
  2429                                        port:
  2430                                          description: Port specifies the destination
  2431                                            port number to use for this resource.
  2432                                            Port is required when the referent is
  2433                                            a Kubernetes Service. In this case, the
  2434                                            port number is the service port number,
  2435                                            not the target port. For other resources,
  2436                                            destination port might be derived from
  2437                                            the referent resource or this field.
  2438                                          format: int32
  2439                                          maximum: 65535
  2440                                          minimum: 1
  2441                                          type: integer
  2442                                      required:
  2443                                      - name
  2444                                      type: object
  2445                                  required:
  2446                                  - backendRef
  2447                                  type: object
  2448                                requestRedirect:
  2449                                  description: "RequestRedirect defines a schema for
  2450                                    a filter that responds to the request with an
  2451                                    HTTP redirection. \n Support: Core"
  2452                                  properties:
  2453                                    hostname:
  2454                                      description: "Hostname is the hostname to be
  2455                                        used in the value of the `Location` header
  2456                                        in the response. When empty, the hostname
  2457                                        in the `Host` header of the request is used.
  2458                                        \n Support: Core"
  2459                                      maxLength: 253
  2460                                      minLength: 1
  2461                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2462                                      type: string
  2463                                    path:
  2464                                      description: "Path defines parameters used to
  2465                                        modify the path of the incoming request. The
  2466                                        modified path is then used to construct the
  2467                                        `Location` header. When empty, the request
  2468                                        path is used as-is. \n Support: Extended"
  2469                                      properties:
  2470                                        replaceFullPath:
  2471                                          description: ReplaceFullPath specifies the
  2472                                            value with which to replace the full path
  2473                                            of a request during a rewrite or redirect.
  2474                                          maxLength: 1024
  2475                                          type: string
  2476                                        replacePrefixMatch:
  2477                                          description: "ReplacePrefixMatch specifies
  2478                                            the value with which to replace the prefix
  2479                                            match of a request during a rewrite or
  2480                                            redirect. For example, a request to \"/foo/bar\"
  2481                                            with a prefix match of \"/foo\" would
  2482                                            be modified to \"/bar\". \n Note that
  2483                                            this matches the behavior of the PathPrefix
  2484                                            match type. This matches full path elements.
  2485                                            A path element refers to the list of labels
  2486                                            in the path split by the `/` separator.
  2487                                            When specified, a trailing `/` is ignored.
  2488                                            For example, the paths `/abc`, `/abc/`,
  2489                                            and `/abc/def` would all match the prefix
  2490                                            `/abc`, but the path `/abcd` would not."
  2491                                          maxLength: 1024
  2492                                          type: string
  2493                                        type:
  2494                                          description: "Type defines the type of path
  2495                                            modifier. Additional types may be added
  2496                                            in a future release of the API. \n Note
  2497                                            that values may be added to this enum,
  2498                                            implementations must ensure that unknown
  2499                                            values will not cause a crash. \n Unknown
  2500                                            values here must result in the implementation
  2501                                            setting the Accepted Condition for the
  2502                                            Route to `status: False`, with a Reason
  2503                                            of `UnsupportedValue`."
  2504                                          enum:
  2505                                          - ReplaceFullPath
  2506                                          - ReplacePrefixMatch
  2507                                          type: string
  2508                                      required:
  2509                                      - type
  2510                                      type: object
  2511                                    port:
  2512                                      description: "Port is the port to be used in
  2513                                        the value of the `Location` header in the
  2514                                        response. \n If no port is specified, the
  2515                                        redirect port MUST be derived using the following
  2516                                        rules: \n * If redirect scheme is not-empty,
  2517                                        the redirect port MUST be the well-known port
  2518                                        associated with the redirect scheme. Specifically
  2519                                        \"http\" to port 80 and \"https\" to port
  2520                                        443. If the redirect scheme does not have
  2521                                        a well-known port, the listener port of the
  2522                                        Gateway SHOULD be used. * If redirect scheme
  2523                                        is empty, the redirect port MUST be the Gateway
  2524                                        Listener port. \n Implementations SHOULD NOT
  2525                                        add the port number in the 'Location' header
  2526                                        in the following cases: \n * A Location header
  2527                                        that will use HTTP (whether that is determined
  2528                                        via the Listener protocol or the Scheme field)
  2529                                        _and_ use port 80. * A Location header that
  2530                                        will use HTTPS (whether that is determined
  2531                                        via the Listener protocol or the Scheme field)
  2532                                        _and_ use port 443. \n Support: Extended"
  2533                                      format: int32
  2534                                      maximum: 65535
  2535                                      minimum: 1
  2536                                      type: integer
  2537                                    scheme:
  2538                                      description: "Scheme is the scheme to be used
  2539                                        in the value of the `Location` header in the
  2540                                        response. When empty, the scheme of the request
  2541                                        is used. \n Scheme redirects can affect the
  2542                                        port of the redirect, for more information,
  2543                                        refer to the documentation for the port field
  2544                                        of this filter. \n Note that values may be
  2545                                        added to this enum, implementations must ensure
  2546                                        that unknown values will not cause a crash.
  2547                                        \n Unknown values here must result in the
  2548                                        implementation setting the Accepted Condition
  2549                                        for the Route to `status: False`, with a Reason
  2550                                        of `UnsupportedValue`. \n Support: Extended"
  2551                                      enum:
  2552                                      - http
  2553                                      - https
  2554                                      type: string
  2555                                    statusCode:
  2556                                      default: 302
  2557                                      description: "StatusCode is the HTTP status
  2558                                        code to be used in response. \n Note that
  2559                                        values may be added to this enum, implementations
  2560                                        must ensure that unknown values will not cause
  2561                                        a crash. \n Unknown values here must result
  2562                                        in the implementation setting the Accepted
  2563                                        Condition for the Route to `status: False`,
  2564                                        with a Reason of `UnsupportedValue`. \n Support:
  2565                                        Core"
  2566                                      enum:
  2567                                      - 301
  2568                                      - 302
  2569                                      type: integer
  2570                                  type: object
  2571                                responseHeaderModifier:
  2572                                  description: "ResponseHeaderModifier defines a schema
  2573                                    for a filter that modifies response headers. \n
  2574                                    Support: Extended"
  2575                                  properties:
  2576                                    add:
  2577                                      description: "Add adds the given header(s) (name,
  2578                                        value) to the request before the action. It
  2579                                        appends to any existing values associated
  2580                                        with the header name. \n Input: GET /foo HTTP/1.1
  2581                                        my-header: foo \n Config: add: - name: \"my-header\"
  2582                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  2583                                        my-header: foo,bar,baz"
  2584                                      items:
  2585                                        description: HTTPHeader represents an HTTP
  2586                                          Header name and value as defined by RFC
  2587                                          7230.
  2588                                        properties:
  2589                                          name:
  2590                                            description: "Name is the name of the
  2591                                              HTTP Header to be matched. Name matching
  2592                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2593                                              \n If multiple entries specify equivalent
  2594                                              header names, the first entry with an
  2595                                              equivalent name MUST be considered for
  2596                                              a match. Subsequent entries with an
  2597                                              equivalent header name MUST be ignored.
  2598                                              Due to the case-insensitivity of header
  2599                                              names, \"foo\" and \"Foo\" are considered
  2600                                              equivalent."
  2601                                            maxLength: 256
  2602                                            minLength: 1
  2603                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2604                                            type: string
  2605                                          value:
  2606                                            description: Value is the value of HTTP
  2607                                              Header to be matched.
  2608                                            maxLength: 4096
  2609                                            minLength: 1
  2610                                            type: string
  2611                                        required:
  2612                                        - name
  2613                                        - value
  2614                                        type: object
  2615                                      maxItems: 16
  2616                                      type: array
  2617                                      x-kubernetes-list-map-keys:
  2618                                      - name
  2619                                      x-kubernetes-list-type: map
  2620                                    remove:
  2621                                      description: "Remove the given header(s) from
  2622                                        the HTTP request before the action. The value
  2623                                        of Remove is a list of HTTP header names.
  2624                                        Note that the header names are case-insensitive
  2625                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  2626                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  2627                                        my-header2: bar my-header3: baz \n Config:
  2628                                        remove: [\"my-header1\", \"my-header3\"] \n
  2629                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  2630                                      items:
  2631                                        type: string
  2632                                      maxItems: 16
  2633                                      type: array
  2634                                    set:
  2635                                      description: "Set overwrites the request with
  2636                                        the given header (name, value) before the
  2637                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  2638                                        foo \n Config: set: - name: \"my-header\"
  2639                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  2640                                        my-header: bar"
  2641                                      items:
  2642                                        description: HTTPHeader represents an HTTP
  2643                                          Header name and value as defined by RFC
  2644                                          7230.
  2645                                        properties:
  2646                                          name:
  2647                                            description: "Name is the name of the
  2648                                              HTTP Header to be matched. Name matching
  2649                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2650                                              \n If multiple entries specify equivalent
  2651                                              header names, the first entry with an
  2652                                              equivalent name MUST be considered for
  2653                                              a match. Subsequent entries with an
  2654                                              equivalent header name MUST be ignored.
  2655                                              Due to the case-insensitivity of header
  2656                                              names, \"foo\" and \"Foo\" are considered
  2657                                              equivalent."
  2658                                            maxLength: 256
  2659                                            minLength: 1
  2660                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2661                                            type: string
  2662                                          value:
  2663                                            description: Value is the value of HTTP
  2664                                              Header to be matched.
  2665                                            maxLength: 4096
  2666                                            minLength: 1
  2667                                            type: string
  2668                                        required:
  2669                                        - name
  2670                                        - value
  2671                                        type: object
  2672                                      maxItems: 16
  2673                                      type: array
  2674                                      x-kubernetes-list-map-keys:
  2675                                      - name
  2676                                      x-kubernetes-list-type: map
  2677                                  type: object
  2678                                type:
  2679                                  description: "Type identifies the type of filter
  2680                                    to apply. As with other API fields, types are
  2681                                    classified into three conformance levels: \n -
  2682                                    Core: Filter types and their corresponding configuration
  2683                                    defined by \"Support: Core\" in this package,
  2684                                    e.g. \"RequestHeaderModifier\". All implementations
  2685                                    must support core filters. \n - Extended: Filter
  2686                                    types and their corresponding configuration defined
  2687                                    by \"Support: Extended\" in this package, e.g.
  2688                                    \"RequestMirror\". Implementers are encouraged
  2689                                    to support extended filters. \n - Implementation-specific:
  2690                                    Filters that are defined and supported by specific
  2691                                    vendors. In the future, filters showing convergence
  2692                                    in behavior across multiple implementations will
  2693                                    be considered for inclusion in extended or core
  2694                                    conformance levels. Filter-specific configuration
  2695                                    for such filters is specified using the ExtensionRef
  2696                                    field. `Type` should be set to \"ExtensionRef\"
  2697                                    for custom filters. \n Implementers are encouraged
  2698                                    to define custom implementation types to extend
  2699                                    the core API with implementation-specific behavior.
  2700                                    \n If a reference to a custom filter type cannot
  2701                                    be resolved, the filter MUST NOT be skipped. Instead,
  2702                                    requests that would have been processed by that
  2703                                    filter MUST receive a HTTP error response. \n
  2704                                    Note that values may be added to this enum, implementations
  2705                                    must ensure that unknown values will not cause
  2706                                    a crash. \n Unknown values here must result in
  2707                                    the implementation setting the Accepted Condition
  2708                                    for the Route to `status: False`, with a Reason
  2709                                    of `UnsupportedValue`."
  2710                                  enum:
  2711                                  - RequestHeaderModifier
  2712                                  - ResponseHeaderModifier
  2713                                  - RequestMirror
  2714                                  - RequestRedirect
  2715                                  - URLRewrite
  2716                                  - ExtensionRef
  2717                                  type: string
  2718                                urlRewrite:
  2719                                  description: "URLRewrite defines a schema for a
  2720                                    filter that modifies a request during forwarding.
  2721                                    \n Support: Extended"
  2722                                  properties:
  2723                                    hostname:
  2724                                      description: "Hostname is the value to be used
  2725                                        to replace the Host header value during forwarding.
  2726                                        \n Support: Extended"
  2727                                      maxLength: 253
  2728                                      minLength: 1
  2729                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2730                                      type: string
  2731                                    path:
  2732                                      description: "Path defines a path rewrite. \n
  2733                                        Support: Extended"
  2734                                      properties:
  2735                                        replaceFullPath:
  2736                                          description: ReplaceFullPath specifies the
  2737                                            value with which to replace the full path
  2738                                            of a request during a rewrite or redirect.
  2739                                          maxLength: 1024
  2740                                          type: string
  2741                                        replacePrefixMatch:
  2742                                          description: "ReplacePrefixMatch specifies
  2743                                            the value with which to replace the prefix
  2744                                            match of a request during a rewrite or
  2745                                            redirect. For example, a request to \"/foo/bar\"
  2746                                            with a prefix match of \"/foo\" would
  2747                                            be modified to \"/bar\". \n Note that
  2748                                            this matches the behavior of the PathPrefix
  2749                                            match type. This matches full path elements.
  2750                                            A path element refers to the list of labels
  2751                                            in the path split by the `/` separator.
  2752                                            When specified, a trailing `/` is ignored.
  2753                                            For example, the paths `/abc`, `/abc/`,
  2754                                            and `/abc/def` would all match the prefix
  2755                                            `/abc`, but the path `/abcd` would not."
  2756                                          maxLength: 1024
  2757                                          type: string
  2758                                        type:
  2759                                          description: "Type defines the type of path
  2760                                            modifier. Additional types may be added
  2761                                            in a future release of the API. \n Note
  2762                                            that values may be added to this enum,
  2763                                            implementations must ensure that unknown
  2764                                            values will not cause a crash. \n Unknown
  2765                                            values here must result in the implementation
  2766                                            setting the Accepted Condition for the
  2767                                            Route to `status: False`, with a Reason
  2768                                            of `UnsupportedValue`."
  2769                                          enum:
  2770                                          - ReplaceFullPath
  2771                                          - ReplacePrefixMatch
  2772                                          type: string
  2773                                      required:
  2774                                      - type
  2775                                      type: object
  2776                                  type: object
  2777                              required:
  2778                              - type
  2779                              type: object
  2780                            maxItems: 16
  2781                            type: array
  2782                          group:
  2783                            default: ""
  2784                            description: Group is the group of the referent. For example,
  2785                              "gateway.networking.k8s.io". When unspecified or empty
  2786                              string, core API group is inferred.
  2787                            maxLength: 253
  2788                            pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2789                            type: string
  2790                          kind:
  2791                            default: Service
  2792                            description: "Kind is the Kubernetes resource kind of
  2793                              the referent. For example \"Service\". \n Defaults to
  2794                              \"Service\" when not specified. \n ExternalName services
  2795                              can refer to CNAME DNS records that may live outside
  2796                              of the cluster and as such are difficult to reason about
  2797                              in terms of conformance. They also may not be safe to
  2798                              forward to (see CVE-2021-25740 for more information).
  2799                              Implementations SHOULD NOT support ExternalName Services.
  2800                              \n Support: Core (Services with a type other than ExternalName)
  2801                              \n Support: Implementation-specific (Services with type
  2802                              ExternalName)"
  2803                            maxLength: 63
  2804                            minLength: 1
  2805                            pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2806                            type: string
  2807                          name:
  2808                            description: Name is the name of the referent.
  2809                            maxLength: 253
  2810                            minLength: 1
  2811                            type: string
  2812                          namespace:
  2813                            description: "Namespace is the namespace of the backend.
  2814                              When unspecified, the local namespace is inferred. \n
  2815                              Note that when a namespace different than the local
  2816                              namespace is specified, a ReferenceGrant object is required
  2817                              in the referent namespace to allow that namespace's
  2818                              owner to accept the reference. See the ReferenceGrant
  2819                              documentation for details. \n Support: Core"
  2820                            maxLength: 63
  2821                            minLength: 1
  2822                            pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2823                            type: string
  2824                          port:
  2825                            description: Port specifies the destination port number
  2826                              to use for this resource. Port is required when the
  2827                              referent is a Kubernetes Service. In this case, the
  2828                              port number is the service port number, not the target
  2829                              port. For other resources, destination port might be
  2830                              derived from the referent resource or this field.
  2831                            format: int32
  2832                            maximum: 65535
  2833                            minimum: 1
  2834                            type: integer
  2835                          weight:
  2836                            default: 1
  2837                            description: "Weight specifies the proportion of requests
  2838                              forwarded to the referenced backend. This is computed
  2839                              as weight/(sum of all weights in this BackendRefs list).
  2840                              For non-zero values, there may be some epsilon from
  2841                              the exact proportion defined here depending on the precision
  2842                              an implementation supports. Weight is not a percentage
  2843                              and the sum of weights does not need to equal 100. \n
  2844                              If only one backend is specified and it has a weight
  2845                              greater than 0, 100% of the traffic is forwarded to
  2846                              that backend. If weight is set to 0, no traffic should
  2847                              be forwarded for this entry. If unspecified, weight
  2848                              defaults to 1. \n Support for this field varies based
  2849                              on the context where used."
  2850                            format: int32
  2851                            maximum: 1000000
  2852                            minimum: 0
  2853                            type: integer
  2854                        required:
  2855                        - name
  2856                        type: object
  2857                      maxItems: 16
  2858                      type: array
  2859                    filters:
  2860                      description: "Filters define the filters that are applied to
  2861                        requests that match this rule. \n The effects of ordering
  2862                        of multiple behaviors are currently unspecified. This can
  2863                        change in the future based on feedback during the alpha stage.
  2864                        \n Conformance-levels at this level are defined based on the
  2865                        type of filter: \n - ALL core filters MUST be supported by
  2866                        all implementations. - Implementers are encouraged to support
  2867                        extended filters. - Implementation-specific custom filters
  2868                        have no API guarantees across implementations. \n Specifying
  2869                        a core filter multiple times has unspecified or implementation-specific
  2870                        conformance. \n All filters are expected to be compatible
  2871                        with each other except for the URLRewrite and RequestRedirect
  2872                        filters, which may not be combined. If an implementation can
  2873                        not support other combinations of filters, they must clearly
  2874                        document that limitation. In all cases where incompatible
  2875                        or unsupported filters are specified, implementations MUST
  2876                        add a warning condition to status. \n Support: Core"
  2877                      items:
  2878                        description: HTTPRouteFilter defines processing steps that
  2879                          must be completed during the request or response lifecycle.
  2880                          HTTPRouteFilters are meant as an extension point to express
  2881                          processing that may be done in Gateway implementations.
  2882                          Some examples include request or response modification,
  2883                          implementing authentication strategies, rate-limiting, and
  2884                          traffic shaping. API guarantee/conformance is defined based
  2885                          on the type of the filter.
  2886                        properties:
  2887                          extensionRef:
  2888                            description: "ExtensionRef is an optional, implementation-specific
  2889                              extension to the \"filter\" behavior.  For example,
  2890                              resource \"myroutefilter\" in group \"networking.example.net\").
  2891                              ExtensionRef MUST NOT be used for core and extended
  2892                              filters. \n Support: Implementation-specific"
  2893                            properties:
  2894                              group:
  2895                                description: Group is the group of the referent. For
  2896                                  example, "gateway.networking.k8s.io". When unspecified
  2897                                  or empty string, core API group is inferred.
  2898                                maxLength: 253
  2899                                pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2900                                type: string
  2901                              kind:
  2902                                description: Kind is kind of the referent. For example
  2903                                  "HTTPRoute" or "Service".
  2904                                maxLength: 63
  2905                                minLength: 1
  2906                                pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2907                                type: string
  2908                              name:
  2909                                description: Name is the name of the referent.
  2910                                maxLength: 253
  2911                                minLength: 1
  2912                                type: string
  2913                            required:
  2914                            - group
  2915                            - kind
  2916                            - name
  2917                            type: object
  2918                          requestHeaderModifier:
  2919                            description: "RequestHeaderModifier defines a schema for
  2920                              a filter that modifies request headers. \n Support:
  2921                              Core"
  2922                            properties:
  2923                              add:
  2924                                description: "Add adds the given header(s) (name,
  2925                                  value) to the request before the action. It appends
  2926                                  to any existing values associated with the header
  2927                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
  2928                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
  2929                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
  2930                                items:
  2931                                  description: HTTPHeader represents an HTTP Header
  2932                                    name and value as defined by RFC 7230.
  2933                                  properties:
  2934                                    name:
  2935                                      description: "Name is the name of the HTTP Header
  2936                                        to be matched. Name matching MUST be case
  2937                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2938                                        \n If multiple entries specify equivalent
  2939                                        header names, the first entry with an equivalent
  2940                                        name MUST be considered for a match. Subsequent
  2941                                        entries with an equivalent header name MUST
  2942                                        be ignored. Due to the case-insensitivity
  2943                                        of header names, \"foo\" and \"Foo\" are considered
  2944                                        equivalent."
  2945                                      maxLength: 256
  2946                                      minLength: 1
  2947                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2948                                      type: string
  2949                                    value:
  2950                                      description: Value is the value of HTTP Header
  2951                                        to be matched.
  2952                                      maxLength: 4096
  2953                                      minLength: 1
  2954                                      type: string
  2955                                  required:
  2956                                  - name
  2957                                  - value
  2958                                  type: object
  2959                                maxItems: 16
  2960                                type: array
  2961                                x-kubernetes-list-map-keys:
  2962                                - name
  2963                                x-kubernetes-list-type: map
  2964                              remove:
  2965                                description: "Remove the given header(s) from the
  2966                                  HTTP request before the action. The value of Remove
  2967                                  is a list of HTTP header names. Note that the header
  2968                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  2969                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
  2970                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
  2971                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
  2972                                  bar"
  2973                                items:
  2974                                  type: string
  2975                                maxItems: 16
  2976                                type: array
  2977                              set:
  2978                                description: "Set overwrites the request with the
  2979                                  given header (name, value) before the action. \n
  2980                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
  2981                                  set: - name: \"my-header\" value: \"bar\" \n Output:
  2982                                  GET /foo HTTP/1.1 my-header: bar"
  2983                                items:
  2984                                  description: HTTPHeader represents an HTTP Header
  2985                                    name and value as defined by RFC 7230.
  2986                                  properties:
  2987                                    name:
  2988                                      description: "Name is the name of the HTTP Header
  2989                                        to be matched. Name matching MUST be case
  2990                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2991                                        \n If multiple entries specify equivalent
  2992                                        header names, the first entry with an equivalent
  2993                                        name MUST be considered for a match. Subsequent
  2994                                        entries with an equivalent header name MUST
  2995                                        be ignored. Due to the case-insensitivity
  2996                                        of header names, \"foo\" and \"Foo\" are considered
  2997                                        equivalent."
  2998                                      maxLength: 256
  2999                                      minLength: 1
  3000                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3001                                      type: string
  3002                                    value:
  3003                                      description: Value is the value of HTTP Header
  3004                                        to be matched.
  3005                                      maxLength: 4096
  3006                                      minLength: 1
  3007                                      type: string
  3008                                  required:
  3009                                  - name
  3010                                  - value
  3011                                  type: object
  3012                                maxItems: 16
  3013                                type: array
  3014                                x-kubernetes-list-map-keys:
  3015                                - name
  3016                                x-kubernetes-list-type: map
  3017                            type: object
  3018                          requestMirror:
  3019                            description: "RequestMirror defines a schema for a filter
  3020                              that mirrors requests. Requests are sent to the specified
  3021                              destination, but responses from that destination are
  3022                              ignored. \n Support: Extended"
  3023                            properties:
  3024                              backendRef:
  3025                                description: "BackendRef references a resource where
  3026                                  mirrored requests are sent. \n If the referent cannot
  3027                                  be found, this BackendRef is invalid and must be
  3028                                  dropped from the Gateway. The controller must ensure
  3029                                  the \"ResolvedRefs\" condition on the Route status
  3030                                  is set to `status: False` and not configure this
  3031                                  backend in the underlying implementation. \n If
  3032                                  there is a cross-namespace reference to an *existing*
  3033                                  object that is not allowed by a ReferenceGrant,
  3034                                  the controller must ensure the \"ResolvedRefs\"
  3035                                  \ condition on the Route is set to `status: False`,
  3036                                  with the \"RefNotPermitted\" reason and not configure
  3037                                  this backend in the underlying implementation. \n
  3038                                  In either error case, the Message of the `ResolvedRefs`
  3039                                  Condition should be used to provide more detail
  3040                                  about the problem. \n Support: Extended for Kubernetes
  3041                                  Service \n Support: Implementation-specific for
  3042                                  any other resource"
  3043                                properties:
  3044                                  group:
  3045                                    default: ""
  3046                                    description: Group is the group of the referent.
  3047                                      For example, "gateway.networking.k8s.io". When
  3048                                      unspecified or empty string, core API group
  3049                                      is inferred.
  3050                                    maxLength: 253
  3051                                    pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3052                                    type: string
  3053                                  kind:
  3054                                    default: Service
  3055                                    description: "Kind is the Kubernetes resource
  3056                                      kind of the referent. For example \"Service\".
  3057                                      \n Defaults to \"Service\" when not specified.
  3058                                      \n ExternalName services can refer to CNAME
  3059                                      DNS records that may live outside of the cluster
  3060                                      and as such are difficult to reason about in
  3061                                      terms of conformance. They also may not be safe
  3062                                      to forward to (see CVE-2021-25740 for more information).
  3063                                      Implementations SHOULD NOT support ExternalName
  3064                                      Services. \n Support: Core (Services with a
  3065                                      type other than ExternalName) \n Support: Implementation-specific
  3066                                      (Services with type ExternalName)"
  3067                                    maxLength: 63
  3068                                    minLength: 1
  3069                                    pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  3070                                    type: string
  3071                                  name:
  3072                                    description: Name is the name of the referent.
  3073                                    maxLength: 253
  3074                                    minLength: 1
  3075                                    type: string
  3076                                  namespace:
  3077                                    description: "Namespace is the namespace of the
  3078                                      backend. When unspecified, the local namespace
  3079                                      is inferred. \n Note that when a namespace different
  3080                                      than the local namespace is specified, a ReferenceGrant
  3081                                      object is required in the referent namespace
  3082                                      to allow that namespace's owner to accept the
  3083                                      reference. See the ReferenceGrant documentation
  3084                                      for details. \n Support: Core"
  3085                                    maxLength: 63
  3086                                    minLength: 1
  3087                                    pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  3088                                    type: string
  3089                                  port:
  3090                                    description: Port specifies the destination port
  3091                                      number to use for this resource. Port is required
  3092                                      when the referent is a Kubernetes Service. In
  3093                                      this case, the port number is the service port
  3094                                      number, not the target port. For other resources,
  3095                                      destination port might be derived from the referent
  3096                                      resource or this field.
  3097                                    format: int32
  3098                                    maximum: 65535
  3099                                    minimum: 1
  3100                                    type: integer
  3101                                required:
  3102                                - name
  3103                                type: object
  3104                            required:
  3105                            - backendRef
  3106                            type: object
  3107                          requestRedirect:
  3108                            description: "RequestRedirect defines a schema for a filter
  3109                              that responds to the request with an HTTP redirection.
  3110                              \n Support: Core"
  3111                            properties:
  3112                              hostname:
  3113                                description: "Hostname is the hostname to be used
  3114                                  in the value of the `Location` header in the response.
  3115                                  When empty, the hostname in the `Host` header of
  3116                                  the request is used. \n Support: Core"
  3117                                maxLength: 253
  3118                                minLength: 1
  3119                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3120                                type: string
  3121                              path:
  3122                                description: "Path defines parameters used to modify
  3123                                  the path of the incoming request. The modified path
  3124                                  is then used to construct the `Location` header.
  3125                                  When empty, the request path is used as-is. \n Support:
  3126                                  Extended"
  3127                                properties:
  3128                                  replaceFullPath:
  3129                                    description: ReplaceFullPath specifies the value
  3130                                      with which to replace the full path of a request
  3131                                      during a rewrite or redirect.
  3132                                    maxLength: 1024
  3133                                    type: string
  3134                                  replacePrefixMatch:
  3135                                    description: "ReplacePrefixMatch specifies the
  3136                                      value with which to replace the prefix match
  3137                                      of a request during a rewrite or redirect. For
  3138                                      example, a request to \"/foo/bar\" with a prefix
  3139                                      match of \"/foo\" would be modified to \"/bar\".
  3140                                      \n Note that this matches the behavior of the
  3141                                      PathPrefix match type. This matches full path
  3142                                      elements. A path element refers to the list
  3143                                      of labels in the path split by the `/` separator.
  3144                                      When specified, a trailing `/` is ignored. For
  3145                                      example, the paths `/abc`, `/abc/`, and `/abc/def`
  3146                                      would all match the prefix `/abc`, but the path
  3147                                      `/abcd` would not."
  3148                                    maxLength: 1024
  3149                                    type: string
  3150                                  type:
  3151                                    description: "Type defines the type of path modifier.
  3152                                      Additional types may be added in a future release
  3153                                      of the API. \n Note that values may be added
  3154                                      to this enum, implementations must ensure that
  3155                                      unknown values will not cause a crash. \n Unknown
  3156                                      values here must result in the implementation
  3157                                      setting the Accepted Condition for the Route
  3158                                      to `status: False`, with a Reason of `UnsupportedValue`."
  3159                                    enum:
  3160                                    - ReplaceFullPath
  3161                                    - ReplacePrefixMatch
  3162                                    type: string
  3163                                required:
  3164                                - type
  3165                                type: object
  3166                              port:
  3167                                description: "Port is the port to be used in the value
  3168                                  of the `Location` header in the response. \n If
  3169                                  no port is specified, the redirect port MUST be
  3170                                  derived using the following rules: \n * If redirect
  3171                                  scheme is not-empty, the redirect port MUST be the
  3172                                  well-known port associated with the redirect scheme.
  3173                                  Specifically \"http\" to port 80 and \"https\" to
  3174                                  port 443. If the redirect scheme does not have a
  3175                                  well-known port, the listener port of the Gateway
  3176                                  SHOULD be used. * If redirect scheme is empty, the
  3177                                  redirect port MUST be the Gateway Listener port.
  3178                                  \n Implementations SHOULD NOT add the port number
  3179                                  in the 'Location' header in the following cases:
  3180                                  \n * A Location header that will use HTTP (whether
  3181                                  that is determined via the Listener protocol or
  3182                                  the Scheme field) _and_ use port 80. * A Location
  3183                                  header that will use HTTPS (whether that is determined
  3184                                  via the Listener protocol or the Scheme field) _and_
  3185                                  use port 443. \n Support: Extended"
  3186                                format: int32
  3187                                maximum: 65535
  3188                                minimum: 1
  3189                                type: integer
  3190                              scheme:
  3191                                description: "Scheme is the scheme to be used in the
  3192                                  value of the `Location` header in the response.
  3193                                  When empty, the scheme of the request is used. \n
  3194                                  Scheme redirects can affect the port of the redirect,
  3195                                  for more information, refer to the documentation
  3196                                  for the port field of this filter. \n Note that
  3197                                  values may be added to this enum, implementations
  3198                                  must ensure that unknown values will not cause a
  3199                                  crash. \n Unknown values here must result in the
  3200                                  implementation setting the Accepted Condition for
  3201                                  the Route to `status: False`, with a Reason of `UnsupportedValue`.
  3202                                  \n Support: Extended"
  3203                                enum:
  3204                                - http
  3205                                - https
  3206                                type: string
  3207                              statusCode:
  3208                                default: 302
  3209                                description: "StatusCode is the HTTP status code to
  3210                                  be used in response. \n Note that values may be
  3211                                  added to this enum, implementations must ensure
  3212                                  that unknown values will not cause a crash. \n Unknown
  3213                                  values here must result in the implementation setting
  3214                                  the Accepted Condition for the Route to `status:
  3215                                  False`, with a Reason of `UnsupportedValue`. \n
  3216                                  Support: Core"
  3217                                enum:
  3218                                - 301
  3219                                - 302
  3220                                type: integer
  3221                            type: object
  3222                          responseHeaderModifier:
  3223                            description: "ResponseHeaderModifier defines a schema
  3224                              for a filter that modifies response headers. \n Support:
  3225                              Extended"
  3226                            properties:
  3227                              add:
  3228                                description: "Add adds the given header(s) (name,
  3229                                  value) to the request before the action. It appends
  3230                                  to any existing values associated with the header
  3231                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
  3232                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
  3233                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
  3234                                items:
  3235                                  description: HTTPHeader represents an HTTP Header
  3236                                    name and value as defined by RFC 7230.
  3237                                  properties:
  3238                                    name:
  3239                                      description: "Name is the name of the HTTP Header
  3240                                        to be matched. Name matching MUST be case
  3241                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3242                                        \n If multiple entries specify equivalent
  3243                                        header names, the first entry with an equivalent
  3244                                        name MUST be considered for a match. Subsequent
  3245                                        entries with an equivalent header name MUST
  3246                                        be ignored. Due to the case-insensitivity
  3247                                        of header names, \"foo\" and \"Foo\" are considered
  3248                                        equivalent."
  3249                                      maxLength: 256
  3250                                      minLength: 1
  3251                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3252                                      type: string
  3253                                    value:
  3254                                      description: Value is the value of HTTP Header
  3255                                        to be matched.
  3256                                      maxLength: 4096
  3257                                      minLength: 1
  3258                                      type: string
  3259                                  required:
  3260                                  - name
  3261                                  - value
  3262                                  type: object
  3263                                maxItems: 16
  3264                                type: array
  3265                                x-kubernetes-list-map-keys:
  3266                                - name
  3267                                x-kubernetes-list-type: map
  3268                              remove:
  3269                                description: "Remove the given header(s) from the
  3270                                  HTTP request before the action. The value of Remove
  3271                                  is a list of HTTP header names. Note that the header
  3272                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  3273                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
  3274                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
  3275                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
  3276                                  bar"
  3277                                items:
  3278                                  type: string
  3279                                maxItems: 16
  3280                                type: array
  3281                              set:
  3282                                description: "Set overwrites the request with the
  3283                                  given header (name, value) before the action. \n
  3284                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
  3285                                  set: - name: \"my-header\" value: \"bar\" \n Output:
  3286                                  GET /foo HTTP/1.1 my-header: bar"
  3287                                items:
  3288                                  description: HTTPHeader represents an HTTP Header
  3289                                    name and value as defined by RFC 7230.
  3290                                  properties:
  3291                                    name:
  3292                                      description: "Name is the name of the HTTP Header
  3293                                        to be matched. Name matching MUST be case
  3294                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3295                                        \n If multiple entries specify equivalent
  3296                                        header names, the first entry with an equivalent
  3297                                        name MUST be considered for a match. Subsequent
  3298                                        entries with an equivalent header name MUST
  3299                                        be ignored. Due to the case-insensitivity
  3300                                        of header names, \"foo\" and \"Foo\" are considered
  3301                                        equivalent."
  3302                                      maxLength: 256
  3303                                      minLength: 1
  3304                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3305                                      type: string
  3306                                    value:
  3307                                      description: Value is the value of HTTP Header
  3308                                        to be matched.
  3309                                      maxLength: 4096
  3310                                      minLength: 1
  3311                                      type: string
  3312                                  required:
  3313                                  - name
  3314                                  - value
  3315                                  type: object
  3316                                maxItems: 16
  3317                                type: array
  3318                                x-kubernetes-list-map-keys:
  3319                                - name
  3320                                x-kubernetes-list-type: map
  3321                            type: object
  3322                          type:
  3323                            description: "Type identifies the type of filter to apply.
  3324                              As with other API fields, types are classified into
  3325                              three conformance levels: \n - Core: Filter types and
  3326                              their corresponding configuration defined by \"Support:
  3327                              Core\" in this package, e.g. \"RequestHeaderModifier\".
  3328                              All implementations must support core filters. \n -
  3329                              Extended: Filter types and their corresponding configuration
  3330                              defined by \"Support: Extended\" in this package, e.g.
  3331                              \"RequestMirror\". Implementers are encouraged to support
  3332                              extended filters. \n - Implementation-specific: Filters
  3333                              that are defined and supported by specific vendors.
  3334                              In the future, filters showing convergence in behavior
  3335                              across multiple implementations will be considered for
  3336                              inclusion in extended or core conformance levels. Filter-specific
  3337                              configuration for such filters is specified using the
  3338                              ExtensionRef field. `Type` should be set to \"ExtensionRef\"
  3339                              for custom filters. \n Implementers are encouraged to
  3340                              define custom implementation types to extend the core
  3341                              API with implementation-specific behavior. \n If a reference
  3342                              to a custom filter type cannot be resolved, the filter
  3343                              MUST NOT be skipped. Instead, requests that would have
  3344                              been processed by that filter MUST receive a HTTP error
  3345                              response. \n Note that values may be added to this enum,
  3346                              implementations must ensure that unknown values will
  3347                              not cause a crash. \n Unknown values here must result
  3348                              in the implementation setting the Accepted Condition
  3349                              for the Route to `status: False`, with a Reason of `UnsupportedValue`."
  3350                            enum:
  3351                            - RequestHeaderModifier
  3352                            - ResponseHeaderModifier
  3353                            - RequestMirror
  3354                            - RequestRedirect
  3355                            - URLRewrite
  3356                            - ExtensionRef
  3357                            type: string
  3358                          urlRewrite:
  3359                            description: "URLRewrite defines a schema for a filter
  3360                              that modifies a request during forwarding. \n Support:
  3361                              Extended"
  3362                            properties:
  3363                              hostname:
  3364                                description: "Hostname is the value to be used to
  3365                                  replace the Host header value during forwarding.
  3366                                  \n Support: Extended"
  3367                                maxLength: 253
  3368                                minLength: 1
  3369                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3370                                type: string
  3371                              path:
  3372                                description: "Path defines a path rewrite. \n Support:
  3373                                  Extended"
  3374                                properties:
  3375                                  replaceFullPath:
  3376                                    description: ReplaceFullPath specifies the value
  3377                                      with which to replace the full path of a request
  3378                                      during a rewrite or redirect.
  3379                                    maxLength: 1024
  3380                                    type: string
  3381                                  replacePrefixMatch:
  3382                                    description: "ReplacePrefixMatch specifies the
  3383                                      value with which to replace the prefix match
  3384                                      of a request during a rewrite or redirect. For
  3385                                      example, a request to \"/foo/bar\" with a prefix
  3386                                      match of \"/foo\" would be modified to \"/bar\".
  3387                                      \n Note that this matches the behavior of the
  3388                                      PathPrefix match type. This matches full path
  3389                                      elements. A path element refers to the list
  3390                                      of labels in the path split by the `/` separator.
  3391                                      When specified, a trailing `/` is ignored. For
  3392                                      example, the paths `/abc`, `/abc/`, and `/abc/def`
  3393                                      would all match the prefix `/abc`, but the path
  3394                                      `/abcd` would not."
  3395                                    maxLength: 1024
  3396                                    type: string
  3397                                  type:
  3398                                    description: "Type defines the type of path modifier.
  3399                                      Additional types may be added in a future release
  3400                                      of the API. \n Note that values may be added
  3401                                      to this enum, implementations must ensure that
  3402                                      unknown values will not cause a crash. \n Unknown
  3403                                      values here must result in the implementation
  3404                                      setting the Accepted Condition for the Route
  3405                                      to `status: False`, with a Reason of `UnsupportedValue`."
  3406                                    enum:
  3407                                    - ReplaceFullPath
  3408                                    - ReplacePrefixMatch
  3409                                    type: string
  3410                                required:
  3411                                - type
  3412                                type: object
  3413                            type: object
  3414                        required:
  3415                        - type
  3416                        type: object
  3417                      maxItems: 16
  3418                      type: array
  3419                    matches:
  3420                      default:
  3421                      - path:
  3422                          type: PathPrefix
  3423                          value: /
  3424                      description: "Matches define conditions used for matching the
  3425                        rule against incoming HTTP requests. Each match is independent,
  3426                        i.e. this rule will be matched if **any** one of the matches
  3427                        is satisfied. \n For example, take the following matches configuration:
  3428                        \n ``` matches: - path: value: \"/foo\" headers: - name: \"version\"
  3429                        value: \"v2\" - path: value: \"/v2/foo\" ``` \n For a request
  3430                        to match against this rule, a request must satisfy EITHER
  3431                        of the two conditions: \n - path prefixed with `/foo` AND
  3432                        contains the header `version: v2` - path prefix of `/v2/foo`
  3433                        \n See the documentation for HTTPRouteMatch on how to specify
  3434                        multiple match conditions that should be ANDed together. \n
  3435                        If no matches are specified, the default is a prefix path
  3436                        match on \"/\", which has the effect of matching every HTTP
  3437                        request. \n Proxy or Load Balancer routing configuration generated
  3438                        from HTTPRoutes MUST prioritize matches based on the following
  3439                        criteria, continuing on ties. Across all rules specified on
  3440                        applicable Routes, precedence must be given to the match having:
  3441                        \n * \"Exact\" path match. * \"Prefix\" path match with largest
  3442                        number of characters. * Method match. * Largest number of
  3443                        header matches. * Largest number of query param matches. \n
  3444                        Note: The precedence of RegularExpression path matches are
  3445                        implementation-specific. \n If ties still exist across multiple
  3446                        Routes, matching precedence MUST be determined in order of
  3447                        the following criteria, continuing on ties: \n * The oldest
  3448                        Route based on creation timestamp. * The Route appearing first
  3449                        in alphabetical order by \"{namespace}/{name}\". \n If ties
  3450                        still exist within an HTTPRoute, matching precedence MUST
  3451                        be granted to the FIRST matching rule (in list order) with
  3452                        a match meeting the above criteria. \n When no rules matching
  3453                        a request have been successfully attached to the parent a
  3454                        request is coming from, a HTTP 404 status code MUST be returned."
  3455                      items:
  3456                        description: "HTTPRouteMatch defines the predicate used to
  3457                          match requests to a given action. Multiple match types are
  3458                          ANDed together, i.e. the match will evaluate to true only
  3459                          if all conditions are satisfied. \n For example, the match
  3460                          below will match a HTTP request only if its path starts
  3461                          with `/foo` AND it contains the `version: v1` header: \n
  3462                          ``` match: \n path: value: \"/foo\" headers: - name: \"version\"
  3463                          value \"v1\" \n ```"
  3464                        properties:
  3465                          headers:
  3466                            description: Headers specifies HTTP request header matchers.
  3467                              Multiple match values are ANDed together, meaning, a
  3468                              request must match all the specified headers to select
  3469                              the route.
  3470                            items:
  3471                              description: HTTPHeaderMatch describes how to select
  3472                                a HTTP route by matching HTTP request headers.
  3473                              properties:
  3474                                name:
  3475                                  description: "Name is the name of the HTTP Header
  3476                                    to be matched. Name matching MUST be case insensitive.
  3477                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3478                                    \n If multiple entries specify equivalent header
  3479                                    names, only the first entry with an equivalent
  3480                                    name MUST be considered for a match. Subsequent
  3481                                    entries with an equivalent header name MUST be
  3482                                    ignored. Due to the case-insensitivity of header
  3483                                    names, \"foo\" and \"Foo\" are considered equivalent.
  3484                                    \n When a header is repeated in an HTTP request,
  3485                                    it is implementation-specific behavior as to how
  3486                                    this is represented. Generally, proxies should
  3487                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
  3488                                    regarding processing a repeated header, with special
  3489                                    handling for \"Set-Cookie\"."
  3490                                  maxLength: 256
  3491                                  minLength: 1
  3492                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3493                                  type: string
  3494                                type:
  3495                                  default: Exact
  3496                                  description: "Type specifies how to match against
  3497                                    the value of the header. \n Support: Core (Exact)
  3498                                    \n Support: Implementation-specific (RegularExpression)
  3499                                    \n Since RegularExpression HeaderMatchType has
  3500                                    implementation-specific conformance, implementations
  3501                                    can support POSIX, PCRE or any other dialects
  3502                                    of regular expressions. Please read the implementation's
  3503                                    documentation to determine the supported dialect."
  3504                                  enum:
  3505                                  - Exact
  3506                                  - RegularExpression
  3507                                  type: string
  3508                                value:
  3509                                  description: Value is the value of HTTP Header to
  3510                                    be matched.
  3511                                  maxLength: 4096
  3512                                  minLength: 1
  3513                                  type: string
  3514                              required:
  3515                              - name
  3516                              - value
  3517                              type: object
  3518                            maxItems: 16
  3519                            type: array
  3520                            x-kubernetes-list-map-keys:
  3521                            - name
  3522                            x-kubernetes-list-type: map
  3523                          method:
  3524                            description: "Method specifies HTTP method matcher. When
  3525                              specified, this route will be matched only if the request
  3526                              has the specified method. \n Support: Extended"
  3527                            enum:
  3528                            - GET
  3529                            - HEAD
  3530                            - POST
  3531                            - PUT
  3532                            - DELETE
  3533                            - CONNECT
  3534                            - OPTIONS
  3535                            - TRACE
  3536                            - PATCH
  3537                            type: string
  3538                          path:
  3539                            default:
  3540                              type: PathPrefix
  3541                              value: /
  3542                            description: Path specifies a HTTP request path matcher.
  3543                              If this field is not specified, a default prefix match
  3544                              on the "/" path is provided.
  3545                            properties:
  3546                              type:
  3547                                default: PathPrefix
  3548                                description: "Type specifies how to match against
  3549                                  the path Value. \n Support: Core (Exact, PathPrefix)
  3550                                  \n Support: Implementation-specific (RegularExpression)"
  3551                                enum:
  3552                                - Exact
  3553                                - PathPrefix
  3554                                - RegularExpression
  3555                                type: string
  3556                              value:
  3557                                default: /
  3558                                description: Value of the HTTP path to match against.
  3559                                maxLength: 1024
  3560                                type: string
  3561                            type: object
  3562                          queryParams:
  3563                            description: "QueryParams specifies HTTP query parameter
  3564                              matchers. Multiple match values are ANDed together,
  3565                              meaning, a request must match all the specified query
  3566                              parameters to select the route. \n Support: Extended"
  3567                            items:
  3568                              description: HTTPQueryParamMatch describes how to select
  3569                                a HTTP route by matching HTTP query parameters.
  3570                              properties:
  3571                                name:
  3572                                  description: "Name is the name of the HTTP query
  3573                                    param to be matched. This must be an exact string
  3574                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  3575                                    \n If multiple entries specify equivalent query
  3576                                    param names, only the first entry with an equivalent
  3577                                    name MUST be considered for a match. Subsequent
  3578                                    entries with an equivalent query param name MUST
  3579                                    be ignored. \n If a query param is repeated in
  3580                                    an HTTP request, the behavior is purposely left
  3581                                    undefined, since different data planes have different
  3582                                    capabilities. However, it is *recommended* that
  3583                                    implementations should match against the first
  3584                                    value of the param if the data plane supports
  3585                                    it, as this behavior is expected in other load
  3586                                    balancing contexts outside of the Gateway API.
  3587                                    \n Users SHOULD NOT route traffic based on repeated
  3588                                    query params to guard themselves against potential
  3589                                    differences in the implementations."
  3590                                  maxLength: 256
  3591                                  minLength: 1
  3592                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3593                                  type: string
  3594                                type:
  3595                                  default: Exact
  3596                                  description: "Type specifies how to match against
  3597                                    the value of the query parameter. \n Support:
  3598                                    Extended (Exact) \n Support: Implementation-specific
  3599                                    (RegularExpression) \n Since RegularExpression
  3600                                    QueryParamMatchType has Implementation-specific
  3601                                    conformance, implementations can support POSIX,
  3602                                    PCRE or any other dialects of regular expressions.
  3603                                    Please read the implementation's documentation
  3604                                    to determine the supported dialect."
  3605                                  enum:
  3606                                  - Exact
  3607                                  - RegularExpression
  3608                                  type: string
  3609                                value:
  3610                                  description: Value is the value of HTTP query param
  3611                                    to be matched.
  3612                                  maxLength: 1024
  3613                                  minLength: 1
  3614                                  type: string
  3615                              required:
  3616                              - name
  3617                              - value
  3618                              type: object
  3619                            maxItems: 16
  3620                            type: array
  3621                            x-kubernetes-list-map-keys:
  3622                            - name
  3623                            x-kubernetes-list-type: map
  3624                        type: object
  3625                      maxItems: 8
  3626                      type: array
  3627                  type: object
  3628                maxItems: 16
  3629                type: array
  3630            type: object
  3631          status:
  3632            description: Status defines the current state of HTTPRoute.
  3633            properties:
  3634              parents:
  3635                description: "Parents is a list of parent resources (usually Gateways)
  3636                  that are associated with the route, and the status of the route
  3637                  with respect to each parent. When this route attaches to a parent,
  3638                  the controller that manages the parent must add an entry to this
  3639                  list when the controller first sees the route and should update
  3640                  the entry as appropriate when the route or gateway is modified.
  3641                  \n Note that parent references that cannot be resolved by an implementation
  3642                  of this API will not be added to this list. Implementations of this
  3643                  API can only populate Route status for the Gateways/parent resources
  3644                  they are responsible for. \n A maximum of 32 Gateways will be represented
  3645                  in this list. An empty list means the route has not been attached
  3646                  to any Gateway."
  3647                items:
  3648                  description: RouteParentStatus describes the status of a route with
  3649                    respect to an associated Parent.
  3650                  properties:
  3651                    conditions:
  3652                      description: "Conditions describes the status of the route with
  3653                        respect to the Gateway. Note that the route's availability
  3654                        is also subject to the Gateway's own status conditions and
  3655                        listener status. \n If the Route's ParentRef specifies an
  3656                        existing Gateway that supports Routes of this kind AND that
  3657                        Gateway's controller has sufficient access, then that Gateway's
  3658                        controller MUST set the \"Accepted\" condition on the Route,
  3659                        to indicate whether the route has been accepted or rejected
  3660                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  3661                        if at least one of the Route's rules is implemented by the
  3662                        Gateway. \n There are a number of cases where the \"Accepted\"
  3663                        condition may not be set due to lack of controller visibility,
  3664                        that includes when: \n * The Route refers to a non-existent
  3665                        parent. * The Route is of a type that the controller does
  3666                        not support. * The Route is in a namespace the controller
  3667                        does not have access to."
  3668                      items:
  3669                        description: "Condition contains details for one aspect of
  3670                          the current state of this API Resource. --- This struct
  3671                          is intended for direct use as an array at the field path
  3672                          .status.conditions.  For example, \n type FooStatus struct{
  3673                          // Represents the observations of a foo's current state.
  3674                          // Known .status.conditions.type are: \"Available\", \"Progressing\",
  3675                          and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge
  3676                          // +listType=map // +listMapKey=type Conditions []metav1.Condition
  3677                          `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\"
  3678                          protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields
  3679                          }"
  3680                        properties:
  3681                          lastTransitionTime:
  3682                            description: lastTransitionTime is the last time the condition
  3683                              transitioned from one status to another. This should
  3684                              be when the underlying condition changed.  If that is
  3685                              not known, then using the time when the API field changed
  3686                              is acceptable.
  3687                            format: date-time
  3688                            type: string
  3689                          message:
  3690                            description: message is a human readable message indicating
  3691                              details about the transition. This may be an empty string.
  3692                            maxLength: 32768
  3693                            type: string
  3694                          observedGeneration:
  3695                            description: observedGeneration represents the .metadata.generation
  3696                              that the condition was set based upon. For instance,
  3697                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  3698                              is 9, the condition is out of date with respect to the
  3699                              current state of the instance.
  3700                            format: int64
  3701                            minimum: 0
  3702                            type: integer
  3703                          reason:
  3704                            description: reason contains a programmatic identifier
  3705                              indicating the reason for the condition's last transition.
  3706                              Producers of specific condition types may define expected
  3707                              values and meanings for this field, and whether the
  3708                              values are considered a guaranteed API. The value should
  3709                              be a CamelCase string. This field may not be empty.
  3710                            maxLength: 1024
  3711                            minLength: 1
  3712                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  3713                            type: string
  3714                          status:
  3715                            description: status of the condition, one of True, False,
  3716                              Unknown.
  3717                            enum:
  3718                            - "True"
  3719                            - "False"
  3720                            - Unknown
  3721                            type: string
  3722                          type:
  3723                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  3724                              --- Many .condition.type values are consistent across
  3725                              resources like Available, but because arbitrary conditions
  3726                              can be useful (see .node.status.conditions), the ability
  3727                              to deconflict is important. The regex it matches is
  3728                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  3729                            maxLength: 316
  3730                            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])$
  3731                            type: string
  3732                        required:
  3733                        - lastTransitionTime
  3734                        - message
  3735                        - reason
  3736                        - status
  3737                        - type
  3738                        type: object
  3739                      maxItems: 8
  3740                      minItems: 1
  3741                      type: array
  3742                      x-kubernetes-list-map-keys:
  3743                      - type
  3744                      x-kubernetes-list-type: map
  3745                    controllerName:
  3746                      description: "ControllerName is a domain/path string that indicates
  3747                        the name of the controller that wrote this status. This corresponds
  3748                        with the controllerName field on GatewayClass. \n Example:
  3749                        \"example.net/gateway-controller\". \n The format of this
  3750                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  3751                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  3752                        \n Controllers MUST populate this field when writing status.
  3753                        Controllers should ensure that entries to status populated
  3754                        with their ControllerName are cleaned up when they are no
  3755                        longer necessary."
  3756                      maxLength: 253
  3757                      minLength: 1
  3758                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  3759                      type: string
  3760                    parentRef:
  3761                      description: ParentRef corresponds with a ParentRef in the spec
  3762                        that this RouteParentStatus struct describes the status of.
  3763                      properties:
  3764                        group:
  3765                          default: gateway.networking.k8s.io
  3766                          description: "Group is the group of the referent. When unspecified,
  3767                            \"gateway.networking.k8s.io\" is inferred. To set the
  3768                            core API group (such as for a \"Service\" kind referent),
  3769                            Group must be explicitly set to \"\" (empty string). \n
  3770                            Support: Core"
  3771                          maxLength: 253
  3772                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3773                          type: string
  3774                        kind:
  3775                          default: Gateway
  3776                          description: "Kind is kind of the referent. \n Support:
  3777                            Core (Gateway) \n Support: Implementation-specific (Other
  3778                            Resources)"
  3779                          maxLength: 63
  3780                          minLength: 1
  3781                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  3782                          type: string
  3783                        name:
  3784                          description: "Name is the name of the referent. \n Support:
  3785                            Core"
  3786                          maxLength: 253
  3787                          minLength: 1
  3788                          type: string
  3789                        namespace:
  3790                          description: "Namespace is the namespace of the referent.
  3791                            When unspecified, this refers to the local namespace of
  3792                            the Route. \n Note that there are specific rules for ParentRefs
  3793                            which cross namespace boundaries. Cross-namespace references
  3794                            are only valid if they are explicitly allowed by something
  3795                            in the namespace they are referring to. For example: Gateway
  3796                            has the AllowedRoutes field, and ReferenceGrant provides
  3797                            a generic way to enable any other kind of cross-namespace
  3798                            reference. \n Support: Core"
  3799                          maxLength: 63
  3800                          minLength: 1
  3801                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  3802                          type: string
  3803                        port:
  3804                          description: "Port is the network port this Route targets.
  3805                            It can be interpreted differently based on the type of
  3806                            parent resource. \n When the parent resource is a Gateway,
  3807                            this targets all listeners listening on the specified
  3808                            port that also support this kind of Route(and select this
  3809                            Route). It's not recommended to set `Port` unless the
  3810                            networking behaviors specified in a Route must apply to
  3811                            a specific port as opposed to a listener(s) whose port(s)
  3812                            may be changed. When both Port and SectionName are specified,
  3813                            the name and port of the selected listener must match
  3814                            both specified values. \n Implementations MAY choose to
  3815                            support other parent resources. Implementations supporting
  3816                            other types of parent resources MUST clearly document
  3817                            how/if Port is interpreted. \n For the purpose of status,
  3818                            an attachment is considered successful as long as the
  3819                            parent resource accepts it partially. For example, Gateway
  3820                            listeners can restrict which Routes can attach to them
  3821                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  3822                            listeners accept attachment from the referencing Route,
  3823                            the Route MUST be considered successfully attached. If
  3824                            no Gateway listeners accept attachment from this Route,
  3825                            the Route MUST be considered detached from the Gateway.
  3826                            \n Support: Extended \n <gateway:experimental>"
  3827                          format: int32
  3828                          maximum: 65535
  3829                          minimum: 1
  3830                          type: integer
  3831                        sectionName:
  3832                          description: "SectionName is the name of a section within
  3833                            the target resource. In the following resources, SectionName
  3834                            is interpreted as the following: \n * Gateway: Listener
  3835                            Name. When both Port (experimental) and SectionName are
  3836                            specified, the name and port of the selected listener
  3837                            must match both specified values. \n Implementations MAY
  3838                            choose to support attaching Routes to other resources.
  3839                            If that is the case, they MUST clearly document how SectionName
  3840                            is interpreted. \n When unspecified (empty string), this
  3841                            will reference the entire resource. For the purpose of
  3842                            status, an attachment is considered successful if at least
  3843                            one section in the parent resource accepts it. For example,
  3844                            Gateway listeners can restrict which Routes can attach
  3845                            to them by Route kind, namespace, or hostname. If 1 of
  3846                            2 Gateway listeners accept attachment from the referencing
  3847                            Route, the Route MUST be considered successfully attached.
  3848                            If no Gateway listeners accept attachment from this Route,
  3849                            the Route MUST be considered detached from the Gateway.
  3850                            \n Support: Core"
  3851                          maxLength: 253
  3852                          minLength: 1
  3853                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3854                          type: string
  3855                      required:
  3856                      - name
  3857                      type: object
  3858                  required:
  3859                  - controllerName
  3860                  - parentRef
  3861                  type: object
  3862                maxItems: 32
  3863                type: array
  3864            required:
  3865            - parents
  3866            type: object
  3867        required:
  3868        - spec
  3869        type: object
  3870    served: true
  3871    storage: true
  3872    subresources:
  3873      status: {}
  3874status:
  3875  acceptedNames:
  3876    kind: ""
  3877    plural: ""
  3878  conditions: null
  3879  storedVersions: null
  3880{{- end }}
  3881

View as plain text