func ToProtoModels(openAPISpec *spec.Swagger) (proto.Models, error) {
	specBytes, err := json.MarshalIndent(openAPISpec, " ", " ")
	if err != nil {
		return nil, err
	}

	doc, err := openapi_v2.ParseDocument(specBytes)
	if err != nil {
		return nil, err
	}

	models, err := proto.NewOpenAPIData(doc)
	if err != nil {
		return nil, err
	}

	return models, nil

    List<SuggestItem> parseQueryLog(QueryLog queryLog, String[] fields, String[] tagFieldNames, String roleFieldName,
            ReadingConverter readingConverter, Normalizer normalizer);

    List<SuggestItem> parseDocument(Map<String, Object> document, String[] fields, String[] tagFieldNames, String roleFieldName,
            String langFieldName, ReadingConverter readingConverter, ReadingConverter contentsReadingConverter, Normalizer normalizer,

		_, err := os.Stat(f.Path)
		if err != nil {
			f.err = err
			return
		}
		spec, err := os.ReadFile(f.Path)
		if err != nil {
			f.err = err
			return
		}
		f.document, f.err = openapi_v2.ParseDocument(spec)
	})
	return f.document, f.err
}

func getSchema(f *Fake, model string) (openapi.Schema, error) {
	s, err := f.OpenAPISchema()
	if err != nil {
		return nil, err
	}

            throw new SuggesterException("Failed to create SuggestItem from queryLog.", e);
        }

        return items;
    }

    @Override
    public List<SuggestItem> parseDocument(final Map<String, Object> document, final String[] fields, final String[] tagFieldNames,
            final String roleFieldName, final String langFieldName, final ReadingConverter readingConverter,

            if (parallel) {
                stream.parallel();
            }
            final SuggestItem[] items = stream.flatMap(document -> {
                try {
                    return contentsParser.parseDocument(document, supportedFields, tagFieldNames, roleFieldName, langFieldName,
                            readingConverter, contentsReadingConverter, normalizer, analyzer).stream();

		}

		// convert to JSON
		bs, err = json.Marshal(filteredSwagger)
		if err != nil {
			t.Fatalf("failed to encode filtered to JSON: %v", err)
		}

		// create gnostic doc
		doc, err := openapi_v2.ParseDocument(bs)
		if err != nil {
			t.Fatalf("failed to create gnostic doc: %v", err)
		}

		// load with kube-openapi/pkg/util/proto
		if _, err := proto.NewOpenAPIData(doc); err != nil {