Name:        col.Name,
			Type:        col.Type,
			Format:      col.Format,
			Description: desc,
			Priority:    col.Priority,
		})
	}

	return c, nil
}

type columnPrinter interface {
	FindResults(data interface{}) ([][]reflect.Value, error)
	PrintResults(w io.Writer, results []reflect.Value) error
}

type convertor struct {
	headers           []metav1.TableColumnDefinition
	additionalColumns []columnPrinter

		parser := jsonpath.New("path")
		err := parser.Parse(i.fixPath(path))
		if err != nil {
			return fmt.Errorf("invalid path: %v - %v", path, err)
		}
		values, err := parser.AllowMissingKeys(true).FindResults(i.structure)
		if err != nil {
			return fmt.Errorf("err finding results for path: %v - %v", path, err)
		}
		if len(values) == 0 {
			return nil
		}
		if len(values[0]) > 0 {

                error.printStackTrace()
            }
        }
    }

    private static List<ResettableExpectations> allResettableExpectationsOf(instance) {
        allInstanceFieldsOf(instance).findResults { field ->
            try {
                def fieldValue = field.tap { accessible = true }.get(instance)
                fieldValue instanceof ResettableExpectations ? fieldValue : null

		selectableFieldsSet = fields.Set{}
		for _, sf := range a.selectableFieldSet {
			if sf.err != nil {
				return nil, fmt.Errorf("unexpected error parsing jsonPath: %w", sf.err)
			}
			results, err := sf.fieldPath.FindResults(uc)
			if err != nil {
				return nil, fmt.Errorf("unexpected error finding value with jsonPath: %w", err)
			}
			var value any

			if len(results) > 0 && len(results[0]) > 0 {