}

    TensorType resource_subtype = mlir::cast<TensorType>(value.getType());
    ResourceType resource_type =
        ResourceType::get({resource_subtype}, op.getContext());
    UnrankedTensorType new_resource_type =
        UnrankedTensorType::get(resource_type);

    Type refined_type = TypeMeet(resource.getType(), new_resource_type);
    if (refined_type == resource.getType()) continue;

		if candidate.Name == ann {
			return candidate
		}
	}

	return nil
}

func resourceTypesAsStrings(resourceTypes []annotation.ResourceTypes) []string {
	retval := []string{}
	for _, resourceType := range resourceTypes {
		if s := resourceType.String(); s != "Unknown" {
			retval = append(retval, s)
		}
	}
	return retval

							}
						}
						dumps[resourceType] = append(dumps[resourceType], &discoveryv3.Resource{
							Name:     w.Config.Name,
							Resource: protoconv.MessageToAny(w),
						})
					default:
						dumps[resourceType] = append(dumps[resourceType], rr)
					}
				default:
					dumps[resourceType] = append(dumps[resourceType], rr)
				}
			}
		} else {

			arn: ARN{
				Partition:    "minio",
				Service:      "iam",
				Region:       "us-east-1",
				ResourceType: "role",
				ResourceID:   "my-role",
			},
			want: "arn:minio:iam:us-east-1::role/my-role",
		},
		{
			arn: ARN{
				Partition:    "minio",
				Service:      "",
				Region:       "us-east-1",
				ResourceType: "role",
				ResourceID:   "my-role",
			},
			want: "arn:minio::us-east-1::role/my-role",
		},

	SdsCaSuffix = "-cacert"
)

// SecretResource defines a reference to a secret
type SecretResource struct {
	// ResourceType is the type of secret. One of KubernetesSecretType or KubernetesGatewaySecretType
	ResourceType string
	// Name is the name of the secret
	Name string
	// Namespace is the namespace the secret resides in. For implicit namespace references (such as in KubernetesSecretType),

		Region:       serverRegion,
		ResourceType: arnResourceTypeRole,
		ResourceID:   resourceID,
	}, nil
}

// String - returns string representation of the ARN.
func (arn ARN) String() string {
	return strings.Join(
		[]string{
			arnPrefixArn,
			arn.Partition,
			arn.Service,
			arn.Region,
			"", // account-id is always empty in this implementation
			arn.ResourceType + "/" + arn.ResourceID,
		},
		":",
	)

			"Components.{{.ComponentName}}.K8S.PriorityClassName":   {OutPath: "[{{.ResourceType}}:{{.ResourceName}}].spec.template.spec.priorityClassName."},
			"Components.{{.ComponentName}}.K8S.ReadinessProbe":      {OutPath: "[{{.ResourceType}}:{{.ResourceName}}].spec.template.spec.containers.[name:{{.ContainerName}}].readinessProbe"},

	for resourceType := range totalMemoryType {
		commonMemoryTypeSet[resourceType] = true
	}

	for resourceType := range nodeAllocatableReservation {
		if !(corev1helper.IsHugePageResourceName(resourceType) || resourceType == v1.ResourceMemory) {
			continue
		}
		commonMemoryTypeSet[resourceType] = true
	}

	for resourceType := range commonMemoryTypeSet {

			expected: SecretResource{
				ResourceType: KubernetesSecretType,
				Name:         "cert",
				Namespace:    "default",
				ResourceName: "kubernetes://cert",
				Cluster:      "cluster",
			},
		},
		{
			name:             "with namespace",
			resource:         "kubernetes://namespace/cert",
			defaultNamespace: "default",
			expected: SecretResource{
				ResourceType: KubernetesSecretType,
				Name:         "cert",

  } else {
    first_operand_type = op.getOperand().getType();
  }

  auto element_type = getElementTypeOrSelf(first_operand_type);
  if (mlir::isa<TF::ResourceType>(element_type)) {
    first_operand_type =
        mlir::cast<TF::ResourceType>(element_type).getSubtypes().front();
  }

  auto tensor_type = mlir::dyn_cast_or_null<TensorType>(first_operand_type);
  if (!(tensor_type && tensor_type.hasRank())) {