You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: api.xpack.ml.get_trained_models.go
    path of file: ./repos/corteza/extra/server-discovery/vendor/github.com/elastic/go-elasticsearch/v7/esapi
    
    the code of the file until where you have to start completion: // Licensed to Elasticsearch B.V under one or more agreements.
// Elasticsearch B.V. licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
//
// Code generated from specification version 7.12.0: DO NOT EDIT

package esapi

import (
	"context"
	"net/http"
	"strconv"
	"strings"
)

func newMLGetTrainedModelsFunc(t Transport) MLGetTrainedModels {
	return func(o ...func(*MLGetTrainedModelsRequest)) (*Response, error) {
		var r = MLGetTrainedModelsRequest{}
		for _, f := range o {
			f(&r)
		}
		return r.Do(r.ctx, t)
	}
}

// ----- API Definition -------------------------------------------------------

// MLGetTrainedModels - Retrieves configuration information for a trained inference model.
//
// This API is beta.
//
// See full documentation at https://www.elastic.co/guide/en/elasticsearch/reference/current/get-trained-models.html.
//
type MLGetTrainedModels func(o ...func(*MLGetTrainedModelsRequest)) (*Response, error)

// MLGetTrainedModelsRequest configures the ML Get Trained Models API request.
//
type MLGetTrainedModelsRequest struct {
	ModelID string

	AllowNoMatch           *bool
	DecompressDefinition   *bool
	ExcludeGenerated       *bool
	From                   *int
	Include                string
	IncludeModelDefinition *bool
	Size                   *int
	Tags                   []string

	Pretty     bool
	Human      bool
	ErrorTrace bool
	FilterPath []string

	Header http.Header

	ctx context.Context
}

// Do executes the request and returns response or error.
//
func (r MLGetTrainedModelsRequest) Do(ctx context.Context, transport Transport) (*Response, error) {
	var (
		method string
		path   str
    
func (r MLGetTrainedModelsRequest) Do(ctx context.Context, transport Transport) (*Response, error) {
	var (
		method string
		path   strings.Builder
		params map[string]string
	)

	method = "GET"

	path.Grow(1 + len("_ml") + 1 + len("trained_models") + 1 + len(r.ModelID))
	path.WriteString("/")
	path.WriteString("_ml")
	path.WriteString("/")
	path.WriteString("trained_models")
	if r.ModelID != "" {
		path.WriteString("/")
		path.WriteString(r.ModelID)
	}

	params = make(map[string]string)

	if r.AllowNoMatch != nil {
		params["allow_no_match"] = strconv.FormatBool(*r.AllowNoMatch)
	}

	if r.DecompressDefinition != nil {
		params["decompress_definition"] = strconv.FormatBool(*r.DecompressDefinition)
	}

	if r.ExcludeGenerated != nil {
		params["exclude_generated"] = strconv.FormatBool(*r.ExcludeGenerated)
	}

	if r.From != nil {
		params["from"] = strconv.FormatInt(int64(*r.From), 10)
	}

	if r.Include != "" {
		params["include"] = r.Include
	}

	if r.IncludeModelDefinition != nil {
		params["include_model_definition"] = strconv.FormatBool(*r.IncludeModelDefinition)
	}

	if r.Size != nil {
		params["size"] = strconv.FormatInt(int64(*r.Size), 10)
	}

	if len(r.Tags) > 0 {
		params["tags"] = strings.Join(r.Tags, ",")
	}

	if r.Pretty {
		params["pretty"] = "true"
	}

	if r.Human {
		params["human"] = "true"
	}

	if r.ErrorTrace {
		params["error_trace"] = "true"
	}

	if len(r.FilterPath) > 0 {
		params["filter_path"] = strings.Join(r.FilterPath, ",")
	}

	req, err := newRequest(method, path.String(), nil)
	if err != nil {
		return nil, err
	}

	if len(params) > 0 {
		q := req.URL.Query()
		for k, v := range params {
			q.Set(k, v)
		}
		req.URL.RawQuery = q.Encode()
	}

	if len(r.Header) > 0 {
		if len(req.Header) == 0 {
			req.Header = r.Header
		} else {
			for k, vv := range r.Header {
				for _, v := range vv {
					req.Header.Add(k, v)
				}
			}
		}
	}

	if ctx != nil {
		req = req.WithContext(ctx)
	}

	res, err := transport.Perform(req)
	if err != nil {
		return nil, err
	}

	response := Response{
		StatusCode: res.StatusCode,
		Body:       res.Body,
		Header:     res.Header,
	}

	return &response, nil
}