return FullTypeDef();
    } else {
      return *ft;
    }
  }

  TF_Output output_;

  // For LLVM style RTTI.
  static bool classof(const AbstractTensorHandle* ptr) {
    return ptr->getKind() == kGraph;
  }

 private:
  TF_Graph* graph_;  // For shape inference.
};

// GraphOperation wraps and populates a TF_OperationDescription.
class GraphOperation : public TracingOperation {
 public:

	kinds := findResourceInSpec(un.GetObjectKind().GroupVersionKind())
	if kinds == "" {
		kinds = strings.ToLower(un.GetKind()) + "s"
	}
	// Override with special kind if it exists in the map
	if specialKind, exists := specialKinds[un.GetKind()]; exists {
		kinds = specialKind
	}
	return kinds
}

        return annotatedClassElements
            .flatMap(element -> element.getKind() == ElementKind.METHOD ? Stream.of(element) : element.getEnclosedElements().stream())
            .filter(it -> it.getKind() == ElementKind.METHOD)
            .map(it -> (ExecutableElement) it)

public class AnnotationCallInterceptionRequestReaderImpl implements AnnotatedMethodReaderExtension {

    @Override
    public Collection<Result> readRequest(ExecutableElement input) {
        if (input.getKind() != ElementKind.METHOD) {
            return emptyList();
        }

        if (!input.getModifiers().containsAll(Arrays.asList(Modifier.STATIC, Modifier.PUBLIC))) {
            return emptyList();
        }

  // to the caller.
  virtual std::unique_ptr<RunMetadata> ExportRunMetadata() = 0;

  // For LLVM style RTTI.
  static bool classof(const AbstractContext* ptr) {
    return ptr->getKind() == kEager || ptr->getKind() == kTfrt;
  }

  //===--------------------------------------------------------------------===//
  // Experimental Custom Device.

				}
				if e, a := noxuDefinition.Spec.Group+"/"+watchVersion, createdTypeMeta.GetAPIVersion(); e != a {
					t.Errorf("expected %v, got %v", e, a)
				}
				if e, a := noxuDefinition.Spec.Names.Kind, createdTypeMeta.GetKind(); e != a {
					t.Errorf("expected %v, got %v", e, a)
				}
			case <-time.After(5 * time.Second):
				t.Errorf("missing watch event")
			}
		}

		// Check get for all versions

        List<Checksum> checksums = verification.getChecksums();
        for (Checksum checksum : checksums) {
            verifyChecksum(checksum.getKind(), file, checksum.getValue(), checksum.getAlternatives(), checksumService, builder);
        }
    }

  Type getElementType() {
    return mlir::cast<ShapedType>(value_.getType()).getElementType();
  }

  // For LLVM style RTTI.
  static bool classof(const AbstractTensorHandle* ptr) {
    return ptr->getKind() == kMlir;
  }

  // Return default (TFT_UNSET) full type information. This could be updated in
  // the future if full type information is needed.
  tensorflow::FullTypeDef FullType() const override {

	// update request will always fail pod validation because those fields are immutable once the object is created.
	if a.GetKind().GroupKind() == api.Kind("Pod") && a.GetOperation() == admission.Update {
		return false
	}

	return a.GetKind().GroupKind() == api.Kind("Pod") || a.GetKind().GroupKind() == api.Kind("PersistentVolumeClaim")
}

// SupportsLimit always returns true.

				switch options.Continue {
				case "":
					metadataAccessor.SetContinue(&obj, "abc")
				case "abc":
					metadataAccessor.SetContinue(&obj, "def")
				case "def":
					metadataAccessor.SetKind(&obj, "ListComplete")
				}
				return &obj, nil
			},
			expectedTokens: []string{"", "abc", "def"},
		},
		{
			name:        "stops looping if listFunc returns an error",