replace (
	example.net/deleted v0.1.0 => ./d1
	example.net/deleted v0.2.0 => ./d2
	example.net/lazy v0.1.0 => ./lazy
	example.net/pruned v0.1.0 => ./pruned
)

require (
	example.net/deleted v0.1.0
	example.net/deleted v0.1.0 // redundant
	example.net/lazy v0.1.0
)
-- go.mod.tidy --
module example.com/m

go 1.17

replace (
	example.net/deleted v0.1.0 => ./d1
	example.net/deleted v0.2.0 => ./d2

func RemoveSSEHeaders(metadata map[string]string) {
	delete(metadata, xhttp.AmzServerSideEncryption)
	delete(metadata, xhttp.AmzServerSideEncryptionKmsID)
	delete(metadata, xhttp.AmzServerSideEncryptionKmsContext)
	delete(metadata, xhttp.AmzServerSideEncryptionCustomerAlgorithm)
	delete(metadata, xhttp.AmzServerSideEncryptionCustomerKey)
	delete(metadata, xhttp.AmzServerSideEncryptionCustomerKeyMD5)

		slice := obsoleteSlices[i]
		logger.V(5).Info("Deleting obsolete node resource slice", "slice", klog.KObj(slice))
		if err := c.kubeClient.ResourceV1alpha2().ResourceSlices().Delete(ctx, slice.Name, metav1.DeleteOptions{}); err != nil {
			return fmt.Errorf("delete node resource slice: %w", err)
		}
	}

	return nil
}

func indexOfModel(models []*resourceapi.ResourceModel, model *resourceapi.ResourceModel) int {

		f.Go.Version = version
		f.Syntax.updateLine(f.Go.Syntax, "go", version)
	}
	return nil
}

// DropGoStmt deletes the go statement from the file.
func (f *File) DropGoStmt() {
	if f.Go != nil {
		f.Go.Syntax.markRemoved()
		f.Go = nil
	}
}

// DropToolchainStmt deletes the toolchain statement from the file.
func (f *File) DropToolchainStmt() {
	if f.Toolchain != nil {

	case policy.WhenScaled == retain && policy.WhenDeleted == delete:
		refs = addControllerRef(refs, set, controllerKind)
	case policy.WhenScaled == delete && policy.WhenDeleted == retain:
		podScaledDown := !podInOrdinalRange(pod, set)
		if podScaledDown {
			refs = addControllerRef(refs, pod, podKind)
		}
	case policy.WhenScaled == delete && policy.WhenDeleted == delete:
		podScaledDown := !podInOrdinalRange(pod, set)

	// AssignedPodDelete is the event when a pod is deleted that causes pods with matching affinity
	// terms to be more schedulable.
	AssignedPodDelete = framework.ClusterEvent{Resource: framework.Pod, ActionType: framework.Delete, Label: "AssignedPodDelete"}
	// NodeSpecUnschedulableChange is the event when unschedulable node spec is changed.

}

// DeletedObjectInfo - container for list objects versions deleted objects.
type DeletedObjectInfo struct {
	// Name of the bucket.
	Bucket string

	// Name of the object.
	Name string

	// Date and time when the object was last modified.
	ModTime time.Time

	// Version ID of this object.
	VersionID string

	// Indicates the deleted marker is latest
	IsLatest bool
}

	a, loaded := uniqueMaps.LoadOrStore(typ, m)
	if !loaded {
		// Add a cleanup function for the new map.
		cleanupFuncsMu.Lock()
		cleanupFuncs = append(cleanupFuncs, func() {
			// Delete all the entries whose weak references are nil and clean up
			// deleted entries.
			m.All()(func(key T, wp weak.Pointer[T]) bool {
				if wp.Strong() == nil {
					m.CompareAndDelete(key, wp)
				}
				return true
			})
		})

	// Delete
	if err := DB.Model(&user2).Association("Pets").Delete(&Pet{}); err != nil {
		t.Fatalf("Error happened when delete pet, got %v", err)
	}
	AssertAssociationCount(t, user2, "Pets", 1, "after delete non-existing data")

	if err := DB.Model(&user2).Association("Pets").Delete(&pet2); err != nil {
		t.Fatalf("Error happened when delete Pets, got %v", err)
	}

	// Delete
	if err := DB.Model(&user2).Association("Account").Delete(&Account{}); err != nil {
		t.Fatalf("Error happened when delete account, got %v", err)
	}
	AssertAssociationCount(t, user2, "Account", 1, "after delete non-existing data")

	if err := DB.Model(&user2).Association("Account").Delete(&account2); err != nil {
		t.Fatalf("Error happened when delete Account, got %v", err)
	}