private DecoratingConverter() {
            super(PublishArtifact.class);
        }

        @Override
        protected ConfigurablePublishArtifact parseType(PublishArtifact notation) {
            return instantiator.newInstance(DecoratingPublishArtifact.class, taskDependencyFactory, notation);
        }
    }

            visitor.candidate("Version catalog type-safe accessors.");
        }

        @Override
        protected ModuleVersionSelector parseType(ProviderConvertible<?> notation) {
            return providerConverter.parseType(notation.asProvider());
        }

    }

    static class ProviderConverter extends TypedNotationConverter<Provider<?>, ModuleVersionSelector> {

		gvkList := parseGroupVersionKind(model.Extensions)
		if len(gvkList) == 0 {
			continue
		}

		parsedType := typeParser.Type(modelName)
		for _, gvk := range gvkList {
			if len(gvk.Kind) > 0 {
				tr[schema.GroupVersionKind(gvk)] = &parsedType
			}
		}
	}
	return tr
}

// Get and parse GroupVersionKind from the extension. Returns empty if it doesn't have one.

        private LibraryConverter() {
            super(NativeLibrarySpec.class);
        }

        @Override
        protected NativeLibraryRequirement parseType(NativeLibrarySpec notation) {
            return notation.getShared();
        }
    }

    private static class NativeLibraryRequirementMapNotationConverter extends MapNotationConverter<NativeLibraryRequirement> {

namespace compiler {

class MlrtDialect : public mlir::Dialect {
 public:
  explicit MlrtDialect(mlir::MLIRContext *context);
  static llvm::StringRef getDialectNamespace() { return "mlrt"; }

  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
  void printType(mlir::Type type, mlir::DialectAsmPrinter &os) const override;
};

// The MLIR type represents a C++ mlrt::Future.
class FutureType

        private ArchiveTaskNotationConverter() {
            super(AbstractArchiveTask.class);
        }

        @Override
        protected IvyArtifact parseType(AbstractArchiveTask archiveTask) {
            return instantiator.newInstance(ArchiveTaskBasedIvyArtifact.class, archiveTask, publicationCoordinates, taskDependencyFactory);
        }
    }

class TensorflowMlrtDialect : public mlir::Dialect {
 public:
  explicit TensorflowMlrtDialect(mlir::MLIRContext *context);
  static llvm::StringRef getDialectNamespace() { return "tf_mlrt"; }

  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
  void printType(mlir::Type type, mlir::DialectAsmPrinter &os) const override;
};

// The MLIR type represents a tensorflow::Tensor.
class TFTensorType

// Dialect for fallback operations.
class FallbackDialect : public Dialect {
 public:
  explicit FallbackDialect(MLIRContext *context);
  static StringRef getDialectNamespace() { return "tfrt_fallback"; }

  Type parseType(DialectAsmParser &parser) const override;
  void printType(Type type, DialectAsmPrinter &os) const override;
};

// The MLIR type represents a tensorflow::Tensor.

      >();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_ops.cpp.inc"
      >();
}

// Parse a type registered to this dialect.
mlir::Type TensorflowMlrtDialect::parseType(
    mlir::DialectAsmParser &parser) const {
  llvm::StringRef keyword;
  if (parser.parseKeyword(&keyword)) return mlir::Type();

  if (keyword == "tensor") return TFTensorType::get(getContext());

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.cpp.inc"
      >();
}

/// Parse a type registered to this dialect.
Type FallbackDialect::parseType(DialectAsmParser &parser) const {
  StringRef keyword;
  if (parser.parseKeyword(&keyword)) return Type();

  if (keyword == "tf_tensor") return TFTensorType::get(getContext());