handleResource := func(r *resource.Instance, gvkType config.GroupVersionKind) {
		spec, ok := r.Message.(policy)
		if spec.GetTargetRef() != nil {
			return
		}
		if !ok || spec.GetSelector() == nil {
			return
		}
		selector := spec.GetSelector()
		for _, pod := range pods[r.Metadata.FullName.Namespace.String()] {
			if maps.Contains(pod, selector.MatchLabels) {

	apNs := r.Metadata.FullName.Namespace.String()

	// If AuthzPolicy is mesh-wide
	if meshWidePolicy(apNs, c) {
		// If it has selector, need further analysis
		if ap.GetSelector() != nil {
			apSelector := klabels.SelectorFromSet(ap.GetSelector().MatchLabels)
			// If there is at least one pod matching the selector within the whole mesh
			if !hasMatchingPodsRunning(apSelector, podLabelsMap) {

        incomingEdges.addAll(module.getUnattachedDependencies());
        for (EdgeState incomingEdge : incomingEdges) {
            SelectorState selector = incomingEdge.getSelector();
            for (String path : pathTo(incomingEdge, false)) {
                String requestedAttribute = formatAttributeQuery(selector, attribute);
                fmt.node(path + " " + requestedAttribute);
            }

        this.versionSelector = versionSelector;
    }

    public VersionSelector getInverseSelector() {
        return versionSelector;
    }

    @Override
    public String getSelector() {
        return "!(" + versionSelector.getSelector() + ")";
    }

    @Override
    public boolean isDynamic() {
        return versionSelector.isDynamic();
    }

    @Override
    public boolean requiresMetadata() {

    public DelegatingDependencyMetadata(DependencyMetadata delegate) {
        this.delegate = delegate;
    }

    @Override
    public ComponentSelector getSelector() {
        return delegate.getSelector();
    }

    @Override

            return module.getModuleIdentifier();
        }
        ModuleVersionSelector moduleVersionSelector = getSelector(componentSelector);
        return moduleVersionSelector.getModule();
    }

    @Override
    public ModuleVersionSelector getSelector(ComponentSelector selector) {
        if (selector instanceof ModuleComponentSelector) {

import javax.annotation.Nullable;

public interface ResolvableSelectorState {
    /**
     * The raw component selector being resolved, after any substitution.
     */
    ComponentSelector getSelector();

    /**
     * The version constraint that applies to this selector, if any.
     * Will return null for a project selector.
     */
    @Nullable
    ResolvedVersionConstraint getVersionConstraint();

    public ForcedDependencyMetadataWrapper(ModuleDependencyMetadata delegate) {
        super(delegate);
        this.delegate = delegate;
    }

    @Override
    public ModuleComponentSelector getSelector() {
        return delegate.getSelector();
    }

    @Override
    public ModuleDependencyMetadata withRequestedVersion(VersionConstraint requestedVersion) {

	for k, v := range e.workload {
		if !strings.HasPrefix(k, pod.Metadata.FullName.Namespace.String()) {
			continue
		}
		if maps.Contains(pod.Metadata.Labels, v.GetSelector().GetMatchLabels()) {
			if v.GetImage().GetImageType() != "" {
				variant = v.GetImage().GetImageType()
			}
		}
	}
	if v, ok := pod.Metadata.Annotations[annotation.ProxyConfig.Name]; ok {

        result.failed(new ModuleVersionNotFoundException(dependency.getSelector(), () -> String.format("Cannot resolve external dependency %s because no repositories are defined.", dependency.getSelector()), ImmutableList.of()));
    }

    @Override