}

// DeleteFile - deletes a file.
func (client *storageRESTClient) Delete(ctx context.Context, volume string, path string, deleteOpts DeleteOptions) error {
	if !deleteOpts.Immediate {
		// add deadlines for all non-immediate purges
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, globalDriveConfig.GetMaxTimeout())
		defer cancel()
	}

)

selects.config_setting_group(
    name = "api_indexable",
    match_any = [":api_indexable_flag"] + ADDITIONAL_API_INDEXABLE_SETTINGS,
    visibility = ["//visibility:public"],
)

# DO NOT ADD ANY NEW EXCEPTIONS TO THIS LIST!
# Instead, please use public APIs or public build rules TF provides.
# If you need functionality that is not exposed, we will work with you to expand our public APIs.

				ObjectName: objInfo.Name,
				VersionID:  objInfo.VersionID,
			},
		}
	}
	names = append(names, ObjectToDelete{
		ObjectV: ObjectV{
			ObjectName: "dir/obj1",
			VersionID:  mustGetUUID(), // add a non-existent UUID.
		},
	})

	_, delErrs := obj.DeleteObjects(ctx, bucketName, names, ObjectOptions{
		Versioned: true,
	})
	for i := range delErrs {
		if delErrs[i] != nil {

			return true
		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'):
			// .. element: remove to last / - assume it has to be cleaned.
			return true
		default:
			// real path element.
			// add slash if needed
			if rooted && w != 1 || !rooted && w != 0 {
				w++
			}
			// copy element
			for ; r < n && path[r] != '/'; r++ {
				w++
			}
			// allow one slash, not at end

	}
	var buf bytes.Buffer
	tw := NewWriter(&buf)
	if err := tw.AddFS(fsys); err != nil {
		t.Fatal(err)
	}
	if err := tw.Close(); err != nil {
		t.Fatal(err)
	}

	// Add subfolder into fsys to match what we'll read from the tar.
	fsys["subfolder"] = &fstest.MapFile{Mode: 0o555 | os.ModeDir}

	// Test that we can get the files back from the archive
	tr := NewReader(&buf)

	if err != nil {
		t.Errorf("failed to create users")
	}

	reusedb := gorm.G[User](DB).Where("name like ?", "TestGenericsReuse%")

	sg := sync.WaitGroup{}
	for i := 0; i < 5; i++ {
		sg.Add(1)

		go func() {
			if u1, err := reusedb.Where("id = ?", users[0].ID).First(ctx); err != nil {
				t.Errorf("failed to find user, got error: %v", err)
			} else if u1.Name != users[0].Name || u1.ID != users[0].ID {

			}
			return spd
		}(),
	}}

	for i, v := range vectors {
		var hdr Header
		hdr.PAXRecords = v.inputHdrs
		r := strings.NewReader(v.inputData + "#") // Add canary byte
		tr := Reader{curr: &regFileReader{r, int64(r.Len())}}
		got, err := tr.readGNUSparsePAXHeaders(&hdr)
		if !slices.Equal(got, v.wantMap) {

				3: {checkPartSuccess, checkPartSuccess, checkPartSuccess, checkPartFileNotFound},
			},
			expectedMeta:     fi,
			expectedDangling: false,
		},

		// Add new cases as seen
	}
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			gotMeta, dangling := isObjectDangling(testCase.metaArr, testCase.errs, testCase.dataErrs)

		targets, err := fetchSubSysTargets(ctx, cfg, subSys, transport)
		if err != nil {
			return nil, err
		}
		for _, t := range targets {
			if err = targetList.Add(t); err != nil {
				return nil, err
			}
		}
	}
	return targetList, nil
}

// DefaultNotificationKVS - default notification list of kvs.
var (
	DefaultNotificationKVS = map[string]config.KVS{

	isJump        bool             // Instruction being assembled is a jump.
	allowABI      bool             // Whether ABI selectors are allowed.
	pkgPrefix     string           // Prefix to add to local symbols.
	errorWriter   io.Writer
}

type Patch struct {
	addr  *obj.Addr
	label string
}

func NewParser(ctxt *obj.Link, ar *arch.Arch, lexer lex.TokenReader) *Parser {