492 changed files with 2 additions and 116082 deletions
--- a/.forgejo/ISSUE_TEMPLATE/bug_report.md
+++ b/.forgejo/ISSUE_TEMPLATE/bug_report.md
@ -1,45 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: community, triage, bug
 assignees: ''
 ---
 <!--- Provide a general summary of the issue in the Title above -->
 ## Expected Behavior
 <!--- If you're describing a bug, tell us what should happen -->
 <!--- If you're suggesting a change/improvement, tell us how it should work -->
 ## Current Behavior
 <!--- If describing a bug, tell us what happens instead of the expected behavior -->
 <!--- If suggesting a change/improvement, explain the difference from current behavior -->
 ## Possible Solution
 <!--- Not obligatory -->
 <!--- If no reason/fix/additions for the bug can be suggested, -->
 <!--- uncomment the following phrase: -->
 <!--- No fix can be suggested by a QA engineer. Further solutions shall be up to developers. -->
 ## Steps to Reproduce (for bugs)
 <!--- Provide a link to a live example, or an unambiguous set of steps to -->
 <!--- reproduce this bug. -->
 1.
 ## Context
 <!--- How has this issue affected you? What are you trying to accomplish? -->
 <!--- Providing context helps us come up with a solution that is most useful in the real world -->
 ## Regression
 <!-- Is this issue a regression? (Yes / No) -->
 <!-- If Yes, optionally please include version or commit id or PR# that caused this regression, if you have these details. -->
 ## Your Environment
 <!--- Include as many relevant details about the environment you experienced the bug in -->
 * Version used:
 * Server setup and configuration:
 * Operating System and version (`uname -a`):
--- a/.forgejo/ISSUE_TEMPLATE/config.yml
+++ b/.forgejo/ISSUE_TEMPLATE/config.yml
@ -1 +0,0 @@
 blank_issues_enabled: false
--- a/.forgejo/ISSUE_TEMPLATE/feature_request.md
+++ b/.forgejo/ISSUE_TEMPLATE/feature_request.md
@ -1,20 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: community, triage
 assignees: ''
 ---
 ## Is your feature request related to a problem? Please describe.
 <!--- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
 ## Describe the solution you'd like
 <!--- A clear and concise description of what you want to happen. -->
 ## Describe alternatives you've considered
 <!--- A clear and concise description of any alternative solutions or features you've considered. -->
 ## Additional context
 <!--- Add any other context or screenshots about the feature request here. -->
--- a/.forgejo/workflows/dco.yml
+++ b/.forgejo/workflows/dco.yml
@ -1,21 +0,0 @@
 name: DCO
 on: [pull_request]
 jobs:
  dco:
    name: DCO
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.23'
      - name: Run commit format checker
        uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3
        with:
          from: 'origin/${{ github.event.pull_request.base.ref }}'
--- a/.forgejo/workflows/tests.yml
+++ b/.forgejo/workflows/tests.yml
@ -1,39 +0,0 @@
 name: Tests and linters
 on: [pull_request]
 jobs:
  lint:
    name: Lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.23'
          cache: true
      - name: Install linters
        run: make lint-install
      - name: Run linters
        run: make lint
  tests:
    name: Tests
    runs-on: ubuntu-latest
    strategy:
      matrix:
        go_versions: [ '1.22', '1.23' ]
      fail-fast: false
    steps:
      - uses: actions/checkout@v3
      - name: Set up Go
        uses: actions/setup-go@v3
        with:
          go-version: '${{ matrix.go_versions }}'
      - name: Run tests
        run: make test
--- a/.gitattributes
+++ b/.gitattributes
@ -1,7 +0,0 @@
 /pkg/policy/parser/*.go -diff
 /pkg/policy/parser/generate.go diff
 **/*.interp -diff
 **/*.tokens -diff
 /**/*.pb.go -diff -merge
 /**/*.pb.go linguist-generated=true
 /go.sum -diff
--- a/.gitignore
+++ b/.gitignore
@ -1,33 +0,0 @@
 # Binaries for programs and plugins
 *.exe
 *.exe~
 *.dll
 *.so
 *.dylib
 # Test binary, built with `go test -c`
 *.test
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 # Dependency directories
 vendor/
 # IDE
 .idea
 .vscode
 # coverage
 coverage.txt
 coverage.html
 # antlr tool jar
 antlr*.jar
 # tempfiles
 .cache
 # binary
 bin/
 release/
--- a/.golangci.yml
+++ b/.golangci.yml
@ -1,69 +0,0 @@
 # This file contains all available configuration options
 # with their default values.
 # options for analysis running
 run:
  # timeout for analysis, e.g. 30s, 5m, default is 1m
  timeout: 10m
  # include test files or not, default is true
  tests: false
 # output configuration options
 output:
  # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
  formats:
    - format: tab
 # all available settings of specific linters
 linters-settings:
  exhaustive:
    # indicates that switch statements are to be considered exhaustive if a
    # 'default' case is present, even if all enum members aren't listed in the
    # switch
    default-signifies-exhaustive: true
  govet:
    # report about shadowed variables
    check-shadowing: false
  staticcheck:
    checks: ["all"]
  funlen:
    lines: 80 # default 60
    statements: 60 # default 40
  gocognit:
    min-complexity: 40 # default 30
 linters:
  enable:
    # mandatory linters
    - govet
    - revive
    # some default golangci-lint linters
    - errcheck
    - gosimple
    - godot
    - ineffassign
    - staticcheck
    - typecheck
    - unused
    # extra linters
    - bidichk
    - durationcheck
    - exhaustive
    - copyloopvar
    - gofmt
    - goimports
    - misspell
    - predeclared
    - reassign
    - whitespace
    - containedctx
    - funlen
    - gocognit
    - contextcheck
    - protogetter
    - intrange
  disable-all: true
  fast: false
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,36 +0,0 @@
 ci:
  autofix_prs: false
 repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
    - id: check-added-large-files
    - id: check-case-conflict
    - id: check-executables-have-shebangs
    - id: check-shebang-scripts-are-executable
    - id: check-merge-conflict
    - id: check-json
    - id: check-xml
    - id: check-yaml
    - id: trailing-whitespace
      args: [--markdown-linebreak-ext=md]
    - id: end-of-file-fixer
      exclude: "(.key|.interp|.tokens)$"
  - repo: local
    hooks:
       - id: go-unit-tests
         name: go unit tests
         entry: make test GOFLAGS=''
         pass_filenames: false
         types: [go]
         language: system
  - repo: local
    hooks:
      - id: make-lint
        name: Run Make Lint
        entry: make lint
        language: system
        pass_filenames: false
--- a/1
+++ b/1
@ -1 +0,0 @@
 .*   @TrueCloudLab/storage-core @TrueCloudLab/storage-services
--- a/4
+++ b/4
@ -1,4 +0,0 @@
 FROM golang:1.22
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install make openjdk-17-jre -y
 WORKDIR /work
--- a/201
+++ b/201
@ -1,201 +0,0 @@
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright [yyyy] [name of copyright owner]
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
--- a/157
+++ b/157
@ -1,157 +0,0 @@
 #!/usr/bin/make -f
 ANTLR_VERSION=4.13.1
 TMP_DIR := .cache
 LINT_VERSION ?= 1.61.0
 TRUECLOUDLAB_LINT_VERSION ?= 0.0.7
 OUTPUT_LINT_DIR ?= $(shell pwd)/bin
 LINT_DIR = $(OUTPUT_LINT_DIR)/golangci-lint-$(LINT_VERSION)-v$(TRUECLOUDLAB_LINT_VERSION)
 PROTOC_VERSION ?= 27.2
 PROTOC_GEN_GO_VERSION ?= $(shell go list -f '{{.Version}}' -m google.golang.org/protobuf)
 PROTOC_OS_VERSION=osx-x86_64
 ifeq ($(shell uname), Linux)
 	PROTOC_OS_VERSION=linux-x86_64
 endif
 BIN = bin
 PROTOBUF_DIR ?= $(abspath $(BIN))/protobuf
 PROTOC_DIR ?= $(PROTOBUF_DIR)/protoc-v$(PROTOC_VERSION)
 PROTOC_GEN_GO_DIR ?= $(PROTOBUF_DIR)/protoc-gen-go-$(PROTOC_GEN_GO_VERSION)
 .PHONY: dep imports protoc test lint help $(BIN)/protogen protoc-test
 # Run tests
 test: GOFLAGS ?= "-cover -count=1"
 test:
 	@GOFLAGS=$(GOFLAGS) go test ./...
 # Reformat imports
 imports:
 	@echo "⇒ Processing goimports check"
 	@for f in `find . -type f -name '*.go' -not -name '*.pb.go' -prune`; do \
 		goimports -w $$f; \
 	done
 # Install protoc
 protoc-install:
 	@rm -rf $(PROTOBUF_DIR)
 	@mkdir -p $(PROTOBUF_DIR)
 	@echo "⇒ Installing protoc... "
 	@wget -q -O $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip 'https://github.com/protocolbuffers/protobuf/releases/download/v$(PROTOC_VERSION)/protoc-$(PROTOC_VERSION)-$(PROTOC_OS_VERSION).zip'
 	@unzip -q -o $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip -d $(PROTOC_DIR)
 	@rm $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip
 	@echo "⇒ Installing protoc-gen-go..."
 	@GOBIN=$(PROTOC_GEN_GO_DIR) go install -v google.golang.org/protobuf/...@$(PROTOC_GEN_GO_VERSION)
 # Regenerate code for proto files
 protoc:
 	@if [ ! -d "$(PROTOC_DIR)" ] || [ ! -d "$(PROTOC_GEN_GO_DIR)" ]; then \
 		make protoc-install; \
 	fi
 	# Protoc generate
 	@for f in `find . -type f -name '*.proto' -not -path './bin/*' -not -path './api/util/proto/test/*'`; do \
 		echo "⇒ Processing $$f "; \
 		$(PROTOC_DIR)/bin/protoc \
 			--proto_path=.:$(PROTOC_DIR)/include:/usr/local/include \
 			--plugin=protoc-gen-go-frostfs=$(abspath ./bin/protogen) \
 			--go-frostfs_out=fuzz=true:. \
 			--go-frostfs_opt=paths=source_relative \
 			--go-grpc_opt=require_unimplemented_servers=false \
 			--go-grpc_out=. --go-grpc_opt=paths=source_relative $$f; \
 	done
 $(BIN)/protogen:
 	@go build -v -trimpath \
 		-o $(BIN)/protogen \
 		./api/util/protogen
 protoc-test: protoc $(BIN)/protogen
 	@$(PROTOC_DIR)/bin/protoc \
 			--go_out=. --go_opt=paths=source_relative \
 			--plugin=protoc-gen-go-frostfs=$(abspath $(BIN)/protogen) \
 			--go-frostfs_opt=Mapi/util/proto/test/test.proto=git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/test/custom \
 			--go-frostfs_opt=module=git.frostfs.info/TrueCloudLab/frostfs-sdk-go \
 			--go-frostfs_out=. --go-frostfs_opt=paths=import \
 			./api/util/proto/test/test.proto
 # Pull go dependencies
 dep:
 	@printf "⇒ Download requirements: "
 	@CGO_ENABLED=0 \
 	go mod download && echo OK
 	@printf "⇒ Tidy requirements: "
 	@CGO_ENABLED=0 \
 	go mod tidy -v && echo OK
 # Install linters
 lint-install:
 	@mkdir -p $(TMP_DIR)
 	@rm -rf $(TMP_DIR)/linters
 	@git -c advice.detachedHead=false clone --branch v$(TRUECLOUDLAB_LINT_VERSION) https://git.frostfs.info/TrueCloudLab/linters.git $(TMP_DIR)/linters
 	@@make -C $(TMP_DIR)/linters lib CGO_ENABLED=1 OUT_DIR=$(OUTPUT_LINT_DIR)
 	@rm -rf $(TMP_DIR)/linters
 	@rmdir $(TMP_DIR) 2>/dev/null || true
 	@CGO_ENABLED=1 GOBIN=$(LINT_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v$(LINT_VERSION)
 # Run linters
 lint:
 	@if [ ! -d "$(LINT_DIR)" ]; then \
 		echo "Run make lint-install"; \
 		exit 1; \
 	fi
 	$(LINT_DIR)/golangci-lint run
 # Run tests with race detection and produce coverage output
 cover:
 	@go test -v -race ./... -coverprofile=coverage.txt -covermode=atomic
 	@go tool cover -html=coverage.txt -o coverage.html
 # Reformat code
 format:
 	@echo "⇒ Processing gofmt check"
 	@gofmt -s -w ./
 	@echo "⇒ Processing goimports check"
 	@goimports -w ./
 policy:
 	@wget -q https://www.antlr.org/download/antlr-${ANTLR_VERSION}-complete.jar -O antlr4-tool.jar
 	@java -Xmx500M -cp antlr4-tool.jar org.antlr.v4.Tool -Dlanguage=Go \
 	-no-listener -visitor netmap/parser/Query.g4 netmap/parser/QueryLexer.g4
 # Run `make %` in truecloudlab/frostfs-sdk-go container(Golang+Java)
 docker/%:
 	@docker build -t truecloudlab/frostfs-sdk-go --platform linux/amd64 . > /dev/null
 	@docker run --rm -t \
 	-v `pwd`:/work \
 	-u "$$(id -u):$$(id -g)" \
 	--env HOME=/work \
 	truecloudlab/frostfs-sdk-go make $*
 # Synchronize tree service
 sync-tree:
 	@./syncTree.sh
 # Show this help prompt
 help:
 	@echo '  Usage:'
 	@echo ''
 	@echo '    make <target>'
 	@echo ''
 	@echo '  Targets:'
 	@echo ''
 	@awk '/^#/{ comment = substr($$0,3) } comment && /^[a-zA-Z][a-zA-Z0-9_-]+ ?:/{ print "   ", $$1, comment }' $(MAKEFILE_LIST) | column -t -s ':' | grep -v 'IGNORE' | sort -u
 # Activate pre-commit hooks
 pre-commit:
 	pre-commit install --hook-type pre-commit
 # Deactivate pre-commit hooks
 unpre-commit:
 	pre-commit uninstall --hook-type pre-commit
 # Run pre-commit hooks
 pre-commit-run:
 	@pre-commit run --all-files --hook-stage manual
--- a/README.md
+++ b/README.md
@ -1,132 +1,3 @@
-# frostfs-sdk-go
+# WIP area: this repo is just a fork!
 Go implementation of FrostFS SDK. It contains high-level version-independent wrappers
 for structures from [frostfs-api-go](https://git.frostfs.info/TrueCloudLab/frostfs-api-go) as well as
 helper functions for simplifying node/dApp implementations.
-## Repository structure
+Useful things may be published only in [other branches](../../../branches)
 ### accounting
 Contains fixed-point `Decimal` type for performing balance calculations.
 ### eacl
 Contains Extended ACL types for fine-grained access control.
 There is also a reference implementation of checking algorithm which is used in FrostFS node.
 ### checksum
 Contains `Checksum` type encapsulating checksum as well as it's kind.
 Currently Sha256 and [Tillich-Zemor hashsum](https://git.frostfs.info/TrueCloudLab/tzhash) are in use.
 ### owner
 `owner.ID` type represents single account interacting with FrostFS. In v2 version of protocol
 it is just raw bytes behing [base58-encoded address](https://docs.neo.org/docs/en-us/basic/concept/wallets.html#address)
 in Neo blockchain. Note that for historical reasons it contains
 version prefix and checksum in addition to script-hash.
 ### token
 Contains Bearer token type with several FrostFS-specific methods.
 ### ns
 In FrostFS there are 2 types of name resolution: DNS and NNS. NNS stands for Neo Name Service
 is just a [contract](https://git.frostfs.info/TrueCloudLab/frostfs-contract) deployed on a Neo blockchain.
 Basically, NNS is just a DNS-on-chain which can be used for resolving container nice-names as well
 as any other name in dApps. See our [CoreDNS plugin](https://github.com/nspcc-dev/coredns/tree/master/plugin/nns)
 for the example of how NNS can be integrated in DNS.
 ### session
 To help lightweight clients interact with FrostFS without sacrificing trust, FrostFS has a concept
 of session token. It is signed by client and allows any node with which a session is established
 to perform certain actions on behalf of the user.
 ### client
 Contains client for working with FrostFS.
 ```go
 var prmInit client.PrmInit
 prmInit.SetDefaultPrivateKey(key) // private key for request signing
 var c client.Client
 c.Init(prmInit)
 var prmDial client.PrmDial
 prmDial.SetServerURI("grpcs://localhost:40005") // endpoint address
 err := c.Dial(prmDial)
 if err != nil {
    return
 }
 ctx, cancel := context.WithTimeout(context.Background(), 5 * time.Second)
 defer cancel()
 var prm client.PrmBalanceGet
 prm.SetAccount(acc)
 res, err := c.BalanceGet(ctx, prm)
 if err != nil {
    return
 }
 fmt.Printf("Balance for %s: %v\n", acc, res.Amount())
 ```
 #### Response status
 In FrostFS every operation can fail on multiple levels, so a single `error` doesn't suffice,
 e.g. consider a case when object was put on 4 out of 5 replicas. Thus, all request execution
 details are contained in `Status` returned from every RPC call. dApp can inspect them
 if needed and perform any desired action. In the case above we may want to report
 these details to the user as well as retry an operation, possibly with different parameters.
 Status wire-format is extendable and each node can report any set of details it wants.
 The set of reserved status codes can be found in
 [FrostFS API](https://git.frostfs.info/TrueCloudLab/frostfs-api/src/branch/master/status/types.proto).
 ### policy
 Contains helpers allowing conversion of placing policy from/to JSON representation
 and SQL-like human-readable language.
 ```go
 p, _ := policy.Parse(`
    REP 2
    SELECT 6 FROM F
    FILTER StorageType EQ SSD AS F`)
 // Convert parsed policy back to human-readable text and print.
 println(strings.Join(policy.Encode(p), "\n"))
 ```
 ### netmap
 Contains CRUSH-like implementation of container node selection algorithm. Relevant details
 are described in this paper http://ceur-ws.org/Vol-2344/short10.pdf . Note that it can be
 outdated in some details.
 `netmap/json_tests` subfolder contains language-agnostic tests for selection algorithm.
 ```go
 import (
    "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
    "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
 )
 func placementNodes(addr *object.Address, p *netmap.PlacementPolicy, frostfsNodes []netmap.NodeInfo) {
    // Convert list of nodes in FrostFS API format to the intermediate representation.
    nodes := netmap.NodesFromInfo(nodes)
    // Create new netmap (errors are skipped for the sake of clarity).
    nm, _ := NewNetmap(nodes)
    // Calculate nodes of container.
    cn, _ := nm.GetContainerNodes(p, addr.ContainerID().ToV2().GetValue())
    // Return list of nodes for each replica to place object on in the order of priority.
    return nm.GetPlacementVectors(cn, addr.ObjectID().ToV2().GetValue())
 }
 ```
 ### pool
 Simple pool for managing connections to FrostFS nodes.
 ### acl, checksum, version, signature
 Contain simple API wrappers.
 ### logger
 Wrapper over `zap.Logger` which is used across FrostFS codebase.
 ### util
 Utilities for working with signature-related code.
--- a/accounting/decimal.go
+++ b/accounting/decimal.go
@ -1,64 +0,0 @@
 package accounting
 import "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 // Decimal represents decimal number for accounting operations.
 //
 // Decimal is mutually compatible with git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting.Decimal
 // message. See ReadFromV2 / WriteToV2 methods.
 //
 // Instances can be created using built-in var declaration.
 //
 // Note that direct typecast is not safe and may result in loss of compatibility:
 //
 //	_ = Decimal(accounting.Decimal{}) // not recommended
 type Decimal accounting.Decimal
 // ReadFromV2 reads Decimal from the accounting.Decimal message. Checks if the
 // message conforms to FrostFS API V2 protocol.
 //
 // See also WriteToV2.
 func (d *Decimal) ReadFromV2(m accounting.Decimal) error {
 	*d = Decimal(m)
 	return nil
 }
 // WriteToV2 writes Decimal to the accounting.Decimal message.
 // The message must not be nil.
 //
 // See also ReadFromV2.
 func (d Decimal) WriteToV2(m *accounting.Decimal) {
 	*m = (accounting.Decimal)(d)
 }
 // Value returns value of the decimal number.
 //
 // Zero Decimal has zero value.
 //
 // See also SetValue.
 func (d Decimal) Value() int64 {
 	return (*accounting.Decimal)(&d).GetValue()
 }
 // SetValue sets value of the decimal number.
 //
 // See also Value.
 func (d *Decimal) SetValue(v int64) {
 	(*accounting.Decimal)(d).SetValue(v)
 }
 // Precision returns precision of the decimal number.
 //
 // Zero Decimal has zero precision.
 //
 // See also SetPrecision.
 func (d Decimal) Precision() uint32 {
 	return (*accounting.Decimal)(&d).GetPrecision()
 }
 // SetPrecision sets precision of the decimal number.
 //
 // See also Precision.
 func (d *Decimal) SetPrecision(p uint32) {
 	(*accounting.Decimal)(d).SetPrecision(p)
 }
--- a/accounting/decimal_test.go
+++ b/accounting/decimal_test.go
@ -1,46 +0,0 @@
 package accounting_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
 	v2accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 	"github.com/stretchr/testify/require"
 )
 func TestDecimalData(t *testing.T) {
 	const v, p = 4, 2
 	var d accounting.Decimal
 	require.Zero(t, d.Value())
 	require.Zero(t, d.Precision())
 	d.SetValue(v)
 	d.SetPrecision(p)
 	require.EqualValues(t, v, d.Value())
 	require.EqualValues(t, p, d.Precision())
 }
 func TestDecimalMessageV2(t *testing.T) {
 	var (
 		d accounting.Decimal
 		m v2accounting.Decimal
 	)
 	m.SetValue(7)
 	m.SetPrecision(8)
 	require.NoError(t, d.ReadFromV2(m))
 	require.EqualValues(t, m.GetValue(), d.Value())
 	require.EqualValues(t, m.GetPrecision(), d.Precision())
 	var m2 v2accounting.Decimal
 	d.WriteToV2(&m2)
 	require.EqualValues(t, d.Value(), m2.GetValue())
 	require.EqualValues(t, d.Precision(), m2.GetPrecision())
 }
--- a/accounting/doc.go
+++ b/accounting/doc.go
@ -1,35 +0,0 @@
 /*
 Package accounting provides primitives to perform accounting operations in FrostFS.
 Decimal type provides functionality to process user balances. For example, when
 working with Fixed8 balance precision:
 	var dec accounting.Decimal
 	dec.SetValue(val)
 	dec.SetPrecision(8)
 Instances can be also used to process FrostFS API V2 protocol messages
 (see neo.fs.v2.accounting package in https://git.frostfs.info/TrueCloudLab/frostfs-api).
 On client side:
 	import "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 	var msg accounting.Decimal
 	dec.WriteToV2(&msg)
 	// send msg
 On server side:
 	// recv msg
 	var dec accounting.Decimal
 	dec.ReadFromV2(msg)
 	// process dec
 Using package types in an application is recommended to potentially work with
 different protocol versions with which these types are compatible.
 */
 package accounting
--- a/accounting/test/decimal.go
+++ b/accounting/test/decimal.go
@ -1,16 +0,0 @@
 package accountingtest
 import (
 	"math/rand"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
 )
 // Decimal returns random accounting.Decimal.
 func Decimal() *accounting.Decimal {
 	var d accounting.Decimal
 	d.SetValue(rand.Int63())
 	d.SetPrecision(rand.Uint32())
 	return &d
 }
--- a/accounting/test/doc.go
+++ b/accounting/test/doc.go
@ -1,13 +0,0 @@
 /*
 Package accountingtest provides functions for convenient testing of accounting package API.
 Note that importing the package into source files is highly discouraged.
 Random instance generation functions can be useful when testing expects any value, e.g.:
 	import accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting/test"
 	dec := accountingtest.Decimal()
 	// test the value
 */
 package accountingtest
--- a/ape/chain.go
+++ b/ape/chain.go
@ -1,52 +0,0 @@
 package ape
 import (
 	"errors"
 	"fmt"
 	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 )
 var (
 	ErrInvalidChainRepresentation = errors.New("invalid chain representation")
 )
 // ChainID is Chain's identifier.
 type ChainID []byte
 // Chain is an SDK representation for v2's Chain.
 //
 // Note that Chain (as well as v2's Chain) and all related entities
 // are NOT operated by Access-Policy-Engine (APE). The client is responsible
 // to convert these types to policy-engine entities.
 type Chain struct {
 	// Raw is the encoded chain kind.
 	// It assumes that Raw's bytes are the result of encoding provided by
 	// policy-engine package.
 	Raw []byte
 }
 // ToV2 converts Chain to v2.
 func (c *Chain) ToV2() *apeV2.Chain {
 	v2ct := new(apeV2.Chain)
 	if c.Raw != nil {
 		v2Raw := new(apeV2.ChainRaw)
 		v2Raw.SetRaw(c.Raw)
 		v2ct.SetKind(v2Raw)
 	}
 	return v2ct
 }
 // ReadFromV2 fills Chain from v2.
 func (c *Chain) ReadFromV2(v2ct *apeV2.Chain) error {
 	switch v := v2ct.GetKind().(type) {
 	default:
 		return fmt.Errorf("unsupported chain kind: %T", v)
 	case *apeV2.ChainRaw:
 		raw := v.GetRaw()
 		c.Raw = raw
 	}
 	return nil
 }
--- a/ape/chain_target.go
+++ b/ape/chain_target.go
@ -1,53 +0,0 @@
 package ape
 import (
 	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 )
 // TargetType is an SDK representation for v2's TargetType.
 type TargetType apeV2.TargetType
 const (
 	TargetTypeUndefined TargetType = iota
 	TargetTypeNamespace
 	TargetTypeContainer
 	TargetTypeUser
 	TargetTypeGroup
 )
 // ToV2 converts TargetType to v2.
 func (targetType TargetType) ToV2() apeV2.TargetType {
 	return apeV2.TargetType(targetType)
 }
 // FromV2 reads TargetType to v2.
 func (targetType *TargetType) FromV2(v2targetType apeV2.TargetType) {
 	*targetType = TargetType(v2targetType)
 }
 // ChainTarget is an SDK representation for v2's ChainTarget.
 //
 // Note that ChainTarget (as well as v2's ChainTarget) and all related entities
 // are NOT operated by Access-Policy-Engine (APE). The client is responsible
 // to convert these types to policy-engine entities.
 type ChainTarget struct {
 	TargetType TargetType
 	Name string
 }
 // ToV2 converts ChainTarget to v2.
 func (ct *ChainTarget) ToV2() *apeV2.ChainTarget {
 	v2ct := new(apeV2.ChainTarget)
 	v2ct.SetTargetType(ct.TargetType.ToV2())
 	v2ct.SetName(ct.Name)
 	return v2ct
 }
 // FromV2 reads ChainTarget frpm v2.
 func (ct *ChainTarget) FromV2(v2ct *apeV2.ChainTarget) {
 	ct.TargetType.FromV2(v2ct.GetTargetType())
 	ct.Name = v2ct.GetName()
 }
--- a/ape/chain_target_test.go
+++ b/ape/chain_target_test.go
@ -1,65 +0,0 @@
 package ape_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/ape"
 	"github.com/stretchr/testify/require"
 	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 )
 var (
 	m = map[ape.TargetType]apeV2.TargetType{
 		ape.TargetTypeUndefined: apeV2.TargetTypeUndefined,
 		ape.TargetTypeNamespace: apeV2.TargetTypeNamespace,
 		ape.TargetTypeContainer: apeV2.TargetTypeContainer,
 		ape.TargetTypeUser:      apeV2.TargetTypeUser,
 		ape.TargetTypeGroup:     apeV2.TargetTypeGroup,
 	}
 )
 func TestTargetType(t *testing.T) {
 	for typesdk, typev2 := range m {
 		t.Run("from sdk to v2 "+typev2.String(), func(t *testing.T) {
 			v2 := typesdk.ToV2()
 			require.Equal(t, v2, typev2)
 		})
 		t.Run("from v2 to sdk "+typev2.String(), func(t *testing.T) {
 			var typ ape.TargetType
 			typ.FromV2(typev2)
 			require.Equal(t, typesdk, typ)
 		})
 	}
 }
 func TestChainTarget(t *testing.T) {
 	var (
 		typ  = ape.TargetTypeNamespace
 		name = "namespaceXXYYZZ"
 	)
 	t.Run("from sdk to v2", func(t *testing.T) {
 		ct := ape.ChainTarget{
 			TargetType: typ,
 			Name:       name,
 		}
 		v2 := ct.ToV2()
 		require.Equal(t, m[typ], v2.GetTargetType())
 		require.Equal(t, name, v2.GetName())
 	})
 	t.Run("from v2 to sdk", func(t *testing.T) {
 		v2 := &apeV2.ChainTarget{}
 		v2.SetTargetType(m[typ])
 		v2.SetName(name)
 		var ct ape.ChainTarget
 		ct.FromV2(v2)
 		require.Equal(t, typ, ct.TargetType)
 		require.Equal(t, name, ct.Name)
 	})
 }
--- a/ape/chain_test.go
+++ b/ape/chain_test.go
@ -1,43 +0,0 @@
 package ape_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/ape"
 	"github.com/stretchr/testify/require"
 	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 )
 const (
 	encoded = `{"ID":"","Rules":[{"Status":"Allow","Actions":{"Inverted":false,"Names":["GetObject"]},"Resources":{"Inverted":false,"Names":["native:object/*"]},"Any":false,"Condition":[{"Op":"StringEquals","Object":"Resource","Key":"Department","Value":"HR"}]}],"MatchType":"DenyPriority"}`
 )
 func TestChainData(t *testing.T) {
 	t.Run("raw chain", func(t *testing.T) {
 		var c ape.Chain
 		b := []byte(encoded)
 		c.Raw = b
 		v2, ok := c.ToV2().GetKind().(*apeV2.ChainRaw)
 		require.True(t, ok)
 		require.Equal(t, b, v2.Raw)
 	})
 }
 func TestChainMessageV2(t *testing.T) {
 	b := []byte(encoded)
 	v2Raw := &apeV2.ChainRaw{}
 	v2Raw.SetRaw(b)
 	v2 := &apeV2.Chain{}
 	v2.SetKind(v2Raw)
 	var c ape.Chain
 	c.ReadFromV2(v2)
 	require.NotNil(t, c.Raw)
 	require.Equal(t, b, c.Raw)
 }
--- a/ape/grpc/types_frostfs.pb.go
+++ b/ape/grpc/types_frostfs.pb.go
@ -1,424 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 import (
 	json "encoding/json"
 	fmt "fmt"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 	strconv "strconv"
 )
 type TargetType int32
 const (
 	TargetType_UNDEFINED TargetType = 0
 	TargetType_NAMESPACE TargetType = 1
 	TargetType_CONTAINER TargetType = 2
 	TargetType_USER      TargetType = 3
 	TargetType_GROUP     TargetType = 4
 )
 var (
 	TargetType_name = map[int32]string{
 		0: "UNDEFINED",
 		1: "NAMESPACE",
 		2: "CONTAINER",
 		3: "USER",
 		4: "GROUP",
 	}
 	TargetType_value = map[string]int32{
 		"UNDEFINED": 0,
 		"NAMESPACE": 1,
 		"CONTAINER": 2,
 		"USER":      3,
 		"GROUP":     4,
 	}
 )
 func (x TargetType) String() string {
 	if v, ok := TargetType_name[int32(x)]; ok {
 		return v
 	}
 	return strconv.FormatInt(int64(x), 10)
 }
 func (x *TargetType) FromString(s string) bool {
 	if v, ok := TargetType_value[s]; ok {
 		*x = TargetType(v)
 		return true
 	}
 	return false
 }
 type ChainTarget struct {
 	Type TargetType `json:"type"`
 	Name string     `json:"name"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*ChainTarget)(nil)
 	_ encoding.ProtoUnmarshaler = (*ChainTarget)(nil)
 	_ json.Marshaler            = (*ChainTarget)(nil)
 	_ json.Unmarshaler          = (*ChainTarget)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *ChainTarget) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.EnumSize(1, int32(x.Type))
 	size += proto.StringSize(2, x.Name)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *ChainTarget) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *ChainTarget) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if int32(x.Type) != 0 {
 		mm.AppendInt32(1, int32(x.Type))
 	}
 	if len(x.Name) != 0 {
 		mm.AppendString(2, x.Name)
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *ChainTarget) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "ChainTarget")
 		}
 		switch fc.FieldNum {
 		case 1: // Type
 			data, ok := fc.Int32()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Type")
 			}
 			x.Type = TargetType(data)
 		case 2: // Name
 			data, ok := fc.String()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Name")
 			}
 			x.Name = data
 		}
 	}
 	return nil
 }
 func (x *ChainTarget) GetType() TargetType {
 	if x != nil {
 		return x.Type
 	}
 	return 0
 }
 func (x *ChainTarget) SetType(v TargetType) {
 	x.Type = v
 }
 func (x *ChainTarget) GetName() string {
 	if x != nil {
 		return x.Name
 	}
 	return ""
 }
 func (x *ChainTarget) SetName(v string) {
 	x.Name = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *ChainTarget) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *ChainTarget) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"type\":"
 		out.RawString(prefix)
 		v := int32(x.Type)
 		if vv, ok := TargetType_name[v]; ok {
 			out.String(vv)
 		} else {
 			out.Int32(v)
 		}
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"name\":"
 		out.RawString(prefix)
 		out.String(x.Name)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *ChainTarget) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *ChainTarget) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "type":
 			{
 				var f TargetType
 				var parsedValue TargetType
 				switch v := in.Interface().(type) {
 				case string:
 					if vv, ok := TargetType_value[v]; ok {
 						parsedValue = TargetType(vv)
 						break
 					}
 					vv, err := strconv.ParseInt(v, 10, 32)
 					if err != nil {
 						in.AddError(err)
 						return
 					}
 					parsedValue = TargetType(vv)
 				case float64:
 					parsedValue = TargetType(v)
 				}
 				f = parsedValue
 				x.Type = f
 			}
 		case "name":
 			{
 				var f string
 				f = in.String()
 				x.Name = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type Chain struct {
 	Kind isChain_Kind
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Chain)(nil)
 	_ encoding.ProtoUnmarshaler = (*Chain)(nil)
 	_ json.Marshaler            = (*Chain)(nil)
 	_ json.Unmarshaler          = (*Chain)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Chain) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	if inner, ok := x.Kind.(*Chain_Raw); ok {
 		size += proto.BytesSize(1, inner.Raw)
 	}
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Chain) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Chain) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if inner, ok := x.Kind.(*Chain_Raw); ok {
 		if len(inner.Raw) != 0 {
 			mm.AppendBytes(1, inner.Raw)
 		}
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Chain) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Chain")
 		}
 		switch fc.FieldNum {
 		case 1: // Raw
 			data, ok := fc.Bytes()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Raw")
 			}
 			x.Kind = &Chain_Raw{Raw: data}
 		}
 	}
 	return nil
 }
 func (x *Chain) GetKind() isChain_Kind {
 	if x != nil {
 		return x.Kind
 	}
 	return nil
 }
 func (x *Chain) SetKind(v isChain_Kind) {
 	x.Kind = v
 }
 func (x *Chain) GetRaw() []byte {
 	if xx, ok := x.GetKind().(*Chain_Raw); ok {
 		return xx.Raw
 	}
 	return nil
 }
 func (x *Chain) SetRaw(v *Chain_Raw) {
 	x.Kind = v
 }
 func (x *Chain_Raw) GetRaw() []byte {
 	if x != nil {
 		return x.Raw
 	}
 	return nil
 }
 func (x *Chain_Raw) SetRaw(v []byte) {
 	x.Raw = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Chain) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Chain) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	switch xx := x.Kind.(type) {
 	case *Chain_Raw:
 		{
 			if !first {
 				out.RawByte(',')
 			} else {
 				first = false
 			}
 			const prefix string = "\"raw\":"
 			out.RawString(prefix)
 			if xx.Raw != nil {
 				out.Base64Bytes(xx.Raw)
 			} else {
 				out.String("")
 			}
 		}
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Chain) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Chain) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "raw":
 			xx := new(Chain_Raw)
 			x.Kind = xx
 			{
 				var f []byte
 				f = in.Bytes()
 				xx.Raw = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type isChain_Kind interface {
 	isChain_Kind()
 }
 type Chain_Raw struct {
 	Raw []byte
 }
 func (*Chain_Raw) isChain_Kind() {}
--- a/ape/grpc/types_frostfs_fuzz.go
+++ b/ape/grpc/types_frostfs_fuzz.go
@ -1,45 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 func DoFuzzProtoChainTarget(data []byte) int {
 	msg := new(ChainTarget)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONChainTarget(data []byte) int {
 	msg := new(ChainTarget)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoChain(data []byte) int {
 	msg := new(Chain)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONChain(data []byte) int {
 	msg := new(Chain)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/ape/grpc/types_frostfs_test.go
+++ b/ape/grpc/types_frostfs_test.go
@ -1,31 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 import (
 	testing "testing"
 )
 func FuzzProtoChainTarget(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoChainTarget(data)
 	})
 }
 func FuzzJSONChainTarget(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONChainTarget(data)
 	})
 }
 func FuzzProtoChain(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoChain(data)
 	})
 }
 func FuzzJSONChain(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONChain(data)
 	})
 }
--- a/api/accounting/accounting.go
+++ b/api/accounting/accounting.go
@ -1,104 +0,0 @@
 package accounting
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
 )
 type BalanceRequestBody struct {
 	ownerID *refs.OwnerID
 }
 type BalanceResponseBody struct {
 	bal *Decimal
 }
 type Decimal struct {
 	val int64
 	prec uint32
 }
 type BalanceRequest struct {
 	body *BalanceRequestBody
 	session.RequestHeaders
 }
 type BalanceResponse struct {
 	body *BalanceResponseBody
 	session.ResponseHeaders
 }
 func (b *BalanceRequestBody) GetOwnerID() *refs.OwnerID {
 	if b != nil {
 		return b.ownerID
 	}
 	return nil
 }
 func (b *BalanceRequestBody) SetOwnerID(v *refs.OwnerID) {
 	b.ownerID = v
 }
 func (b *BalanceRequest) GetBody() *BalanceRequestBody {
 	if b != nil {
 		return b.body
 	}
 	return nil
 }
 func (b *BalanceRequest) SetBody(v *BalanceRequestBody) {
 	b.body = v
 }
 func (d *Decimal) GetValue() int64 {
 	if d != nil {
 		return d.val
 	}
 	return 0
 }
 func (d *Decimal) SetValue(v int64) {
 	d.val = v
 }
 func (d *Decimal) GetPrecision() uint32 {
 	if d != nil {
 		return d.prec
 	}
 	return 0
 }
 func (d *Decimal) SetPrecision(v uint32) {
 	d.prec = v
 }
 func (br *BalanceResponseBody) GetBalance() *Decimal {
 	if br != nil {
 		return br.bal
 	}
 	return nil
 }
 func (br *BalanceResponseBody) SetBalance(v *Decimal) {
 	br.bal = v
 }
 func (br *BalanceResponse) GetBody() *BalanceResponseBody {
 	if br != nil {
 		return br.body
 	}
 	return nil
 }
 func (br *BalanceResponse) SetBody(v *BalanceResponseBody) {
 	br.body = v
 }
--- a/api/accounting/convert.go
+++ b/api/accounting/convert.go
@ -1,178 +0,0 @@
 package accounting
 import (
 	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (b *BalanceRequestBody) ToGRPCMessage() grpc.Message {
 	var m *accounting.BalanceRequest_Body
 	if b != nil {
 		m = new(accounting.BalanceRequest_Body)
 		m.SetOwnerId(b.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
 	}
 	return m
 }
 func (b *BalanceRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*accounting.BalanceRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	ownerID := v.GetOwnerId()
 	if ownerID == nil {
 		b.ownerID = nil
 	} else {
 		if b.ownerID == nil {
 			b.ownerID = new(refs.OwnerID)
 		}
 		err = b.ownerID.FromGRPCMessage(ownerID)
 	}
 	return err
 }
 func (b *BalanceRequest) ToGRPCMessage() grpc.Message {
 	var m *accounting.BalanceRequest
 	if b != nil {
 		m = new(accounting.BalanceRequest)
 		m.SetBody(b.body.ToGRPCMessage().(*accounting.BalanceRequest_Body))
 		b.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (b *BalanceRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*accounting.BalanceRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		b.body = nil
 	} else {
 		if b.body == nil {
 			b.body = new(BalanceRequestBody)
 		}
 		err = b.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return b.RequestHeaders.FromMessage(v)
 }
 func (d *Decimal) ToGRPCMessage() grpc.Message {
 	var m *accounting.Decimal
 	if d != nil {
 		m = new(accounting.Decimal)
 		m.SetValue(d.val)
 		m.SetPrecision(d.prec)
 	}
 	return m
 }
 func (d *Decimal) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*accounting.Decimal)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	d.val = v.GetValue()
 	d.prec = v.GetPrecision()
 	return nil
 }
 func (br *BalanceResponseBody) ToGRPCMessage() grpc.Message {
 	var m *accounting.BalanceResponse_Body
 	if br != nil {
 		m = new(accounting.BalanceResponse_Body)
 		m.SetBalance(br.bal.ToGRPCMessage().(*accounting.Decimal))
 	}
 	return m
 }
 func (br *BalanceResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*accounting.BalanceResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	bal := v.GetBalance()
 	if bal == nil {
 		br.bal = nil
 	} else {
 		if br.bal == nil {
 			br.bal = new(Decimal)
 		}
 		err = br.bal.FromGRPCMessage(bal)
 	}
 	return err
 }
 func (br *BalanceResponse) ToGRPCMessage() grpc.Message {
 	var m *accounting.BalanceResponse
 	if br != nil {
 		m = new(accounting.BalanceResponse)
 		m.SetBody(br.body.ToGRPCMessage().(*accounting.BalanceResponse_Body))
 		br.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (br *BalanceResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*accounting.BalanceResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		br.body = nil
 	} else {
 		if br.body == nil {
 			br.body = new(BalanceResponseBody)
 		}
 		err = br.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return br.ResponseHeaders.FromMessage(v)
 }
--- a/api/accounting/grpc/service_frostfs.pb.go
+++ b/api/accounting/grpc/service_frostfs.pb.go
@ -1,768 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 import (
 	json "encoding/json"
 	fmt "fmt"
 	grpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	grpc1 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/grpc"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 )
 type BalanceRequest_Body struct {
 	OwnerId *grpc.OwnerID `json:"ownerId"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*BalanceRequest_Body)(nil)
 	_ encoding.ProtoUnmarshaler = (*BalanceRequest_Body)(nil)
 	_ json.Marshaler            = (*BalanceRequest_Body)(nil)
 	_ json.Unmarshaler          = (*BalanceRequest_Body)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *BalanceRequest_Body) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(1, x.OwnerId)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *BalanceRequest_Body) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *BalanceRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.OwnerId != nil {
 		x.OwnerId.EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *BalanceRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "BalanceRequest_Body")
 		}
 		switch fc.FieldNum {
 		case 1: // OwnerId
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "OwnerId")
 			}
 			x.OwnerId = new(grpc.OwnerID)
 			if err := x.OwnerId.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *BalanceRequest_Body) GetOwnerId() *grpc.OwnerID {
 	if x != nil {
 		return x.OwnerId
 	}
 	return nil
 }
 func (x *BalanceRequest_Body) SetOwnerId(v *grpc.OwnerID) {
 	x.OwnerId = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *BalanceRequest_Body) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *BalanceRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"ownerId\":"
 		out.RawString(prefix)
 		x.OwnerId.MarshalEasyJSON(out)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *BalanceRequest_Body) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *BalanceRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "ownerId":
 			{
 				var f *grpc.OwnerID
 				f = new(grpc.OwnerID)
 				f.UnmarshalEasyJSON(in)
 				x.OwnerId = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type BalanceRequest struct {
 	Body         *BalanceRequest_Body             `json:"body"`
 	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
 	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*BalanceRequest)(nil)
 	_ encoding.ProtoUnmarshaler = (*BalanceRequest)(nil)
 	_ json.Marshaler            = (*BalanceRequest)(nil)
 	_ json.Unmarshaler          = (*BalanceRequest)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *BalanceRequest) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(1, x.Body)
 	size += proto.NestedStructureSize(2, x.MetaHeader)
 	size += proto.NestedStructureSize(3, x.VerifyHeader)
 	return size
 }
 // ReadSignedData fills buf with signed data of x.
 // If buffer length is less than x.SignedDataSize(), new buffer is allocated.
 //
 // Returns any error encountered which did not allow writing the data completely.
 // Otherwise, returns the buffer in which the data is written.
 //
 // Structures with the same field values have the same signed data.
 func (x *BalanceRequest) SignedDataSize() int {
 	return x.GetBody().StableSize()
 }
 // SignedDataSize returns size of the request signed data in bytes.
 //
 // Structures with the same field values have the same signed data size.
 func (x *BalanceRequest) ReadSignedData(buf []byte) ([]byte, error) {
 	return x.GetBody().MarshalProtobuf(buf), nil
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *BalanceRequest) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *BalanceRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.Body != nil {
 		x.Body.EmitProtobuf(mm.AppendMessage(1))
 	}
 	if x.MetaHeader != nil {
 		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
 	}
 	if x.VerifyHeader != nil {
 		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *BalanceRequest) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "BalanceRequest")
 		}
 		switch fc.FieldNum {
 		case 1: // Body
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Body")
 			}
 			x.Body = new(BalanceRequest_Body)
 			if err := x.Body.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 2: // MetaHeader
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
 			}
 			x.MetaHeader = new(grpc1.RequestMetaHeader)
 			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 3: // VerifyHeader
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
 			}
 			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
 			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *BalanceRequest) GetBody() *BalanceRequest_Body {
 	if x != nil {
 		return x.Body
 	}
 	return nil
 }
 func (x *BalanceRequest) SetBody(v *BalanceRequest_Body) {
 	x.Body = v
 }
 func (x *BalanceRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
 	if x != nil {
 		return x.MetaHeader
 	}
 	return nil
 }
 func (x *BalanceRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
 	x.MetaHeader = v
 }
 func (x *BalanceRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
 	if x != nil {
 		return x.VerifyHeader
 	}
 	return nil
 }
 func (x *BalanceRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
 	x.VerifyHeader = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *BalanceRequest) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *BalanceRequest) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"body\":"
 		out.RawString(prefix)
 		x.Body.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"metaHeader\":"
 		out.RawString(prefix)
 		x.MetaHeader.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"verifyHeader\":"
 		out.RawString(prefix)
 		x.VerifyHeader.MarshalEasyJSON(out)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *BalanceRequest) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *BalanceRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "body":
 			{
 				var f *BalanceRequest_Body
 				f = new(BalanceRequest_Body)
 				f.UnmarshalEasyJSON(in)
 				x.Body = f
 			}
 		case "metaHeader":
 			{
 				var f *grpc1.RequestMetaHeader
 				f = new(grpc1.RequestMetaHeader)
 				f.UnmarshalEasyJSON(in)
 				x.MetaHeader = f
 			}
 		case "verifyHeader":
 			{
 				var f *grpc1.RequestVerificationHeader
 				f = new(grpc1.RequestVerificationHeader)
 				f.UnmarshalEasyJSON(in)
 				x.VerifyHeader = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type BalanceResponse_Body struct {
 	Balance *Decimal `json:"balance"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*BalanceResponse_Body)(nil)
 	_ encoding.ProtoUnmarshaler = (*BalanceResponse_Body)(nil)
 	_ json.Marshaler            = (*BalanceResponse_Body)(nil)
 	_ json.Unmarshaler          = (*BalanceResponse_Body)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *BalanceResponse_Body) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(1, x.Balance)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *BalanceResponse_Body) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *BalanceResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.Balance != nil {
 		x.Balance.EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *BalanceResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "BalanceResponse_Body")
 		}
 		switch fc.FieldNum {
 		case 1: // Balance
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Balance")
 			}
 			x.Balance = new(Decimal)
 			if err := x.Balance.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *BalanceResponse_Body) GetBalance() *Decimal {
 	if x != nil {
 		return x.Balance
 	}
 	return nil
 }
 func (x *BalanceResponse_Body) SetBalance(v *Decimal) {
 	x.Balance = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *BalanceResponse_Body) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *BalanceResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"balance\":"
 		out.RawString(prefix)
 		x.Balance.MarshalEasyJSON(out)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *BalanceResponse_Body) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *BalanceResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "balance":
 			{
 				var f *Decimal
 				f = new(Decimal)
 				f.UnmarshalEasyJSON(in)
 				x.Balance = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type BalanceResponse struct {
 	Body         *BalanceResponse_Body             `json:"body"`
 	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
 	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*BalanceResponse)(nil)
 	_ encoding.ProtoUnmarshaler = (*BalanceResponse)(nil)
 	_ json.Marshaler            = (*BalanceResponse)(nil)
 	_ json.Unmarshaler          = (*BalanceResponse)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *BalanceResponse) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(1, x.Body)
 	size += proto.NestedStructureSize(2, x.MetaHeader)
 	size += proto.NestedStructureSize(3, x.VerifyHeader)
 	return size
 }
 // ReadSignedData fills buf with signed data of x.
 // If buffer length is less than x.SignedDataSize(), new buffer is allocated.
 //
 // Returns any error encountered which did not allow writing the data completely.
 // Otherwise, returns the buffer in which the data is written.
 //
 // Structures with the same field values have the same signed data.
 func (x *BalanceResponse) SignedDataSize() int {
 	return x.GetBody().StableSize()
 }
 // SignedDataSize returns size of the request signed data in bytes.
 //
 // Structures with the same field values have the same signed data size.
 func (x *BalanceResponse) ReadSignedData(buf []byte) ([]byte, error) {
 	return x.GetBody().MarshalProtobuf(buf), nil
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *BalanceResponse) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *BalanceResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.Body != nil {
 		x.Body.EmitProtobuf(mm.AppendMessage(1))
 	}
 	if x.MetaHeader != nil {
 		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
 	}
 	if x.VerifyHeader != nil {
 		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *BalanceResponse) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "BalanceResponse")
 		}
 		switch fc.FieldNum {
 		case 1: // Body
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Body")
 			}
 			x.Body = new(BalanceResponse_Body)
 			if err := x.Body.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 2: // MetaHeader
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
 			}
 			x.MetaHeader = new(grpc1.ResponseMetaHeader)
 			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 3: // VerifyHeader
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
 			}
 			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
 			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *BalanceResponse) GetBody() *BalanceResponse_Body {
 	if x != nil {
 		return x.Body
 	}
 	return nil
 }
 func (x *BalanceResponse) SetBody(v *BalanceResponse_Body) {
 	x.Body = v
 }
 func (x *BalanceResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
 	if x != nil {
 		return x.MetaHeader
 	}
 	return nil
 }
 func (x *BalanceResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
 	x.MetaHeader = v
 }
 func (x *BalanceResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
 	if x != nil {
 		return x.VerifyHeader
 	}
 	return nil
 }
 func (x *BalanceResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
 	x.VerifyHeader = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *BalanceResponse) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *BalanceResponse) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"body\":"
 		out.RawString(prefix)
 		x.Body.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"metaHeader\":"
 		out.RawString(prefix)
 		x.MetaHeader.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"verifyHeader\":"
 		out.RawString(prefix)
 		x.VerifyHeader.MarshalEasyJSON(out)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *BalanceResponse) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *BalanceResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "body":
 			{
 				var f *BalanceResponse_Body
 				f = new(BalanceResponse_Body)
 				f.UnmarshalEasyJSON(in)
 				x.Body = f
 			}
 		case "metaHeader":
 			{
 				var f *grpc1.ResponseMetaHeader
 				f = new(grpc1.ResponseMetaHeader)
 				f.UnmarshalEasyJSON(in)
 				x.MetaHeader = f
 			}
 		case "verifyHeader":
 			{
 				var f *grpc1.ResponseVerificationHeader
 				f = new(grpc1.ResponseVerificationHeader)
 				f.UnmarshalEasyJSON(in)
 				x.VerifyHeader = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
--- a/api/accounting/grpc/service_frostfs_fuzz.go
+++ b/api/accounting/grpc/service_frostfs_fuzz.go
@ -1,45 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 func DoFuzzProtoBalanceRequest(data []byte) int {
 	msg := new(BalanceRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONBalanceRequest(data []byte) int {
 	msg := new(BalanceRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoBalanceResponse(data []byte) int {
 	msg := new(BalanceResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONBalanceResponse(data []byte) int {
 	msg := new(BalanceResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/accounting/grpc/service_frostfs_test.go
+++ b/api/accounting/grpc/service_frostfs_test.go
@ -1,31 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 import (
 	testing "testing"
 )
 func FuzzProtoBalanceRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoBalanceRequest(data)
 	})
 }
 func FuzzJSONBalanceRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONBalanceRequest(data)
 	})
 }
 func FuzzProtoBalanceResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoBalanceResponse(data)
 	})
 }
 func FuzzJSONBalanceResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONBalanceResponse(data)
 	})
 }
--- a/api/accounting/grpc/service_grpc.pb.go
+++ b/api/accounting/grpc/service_grpc.pb.go
@ -1,119 +0,0 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.3.0
 // - protoc             v5.27.2
 // source: api/accounting/grpc/service.proto
 package accounting
 import (
 	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 )
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
 // Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 const (
 	AccountingService_Balance_FullMethodName = "/neo.fs.v2.accounting.AccountingService/Balance"
 )
 // AccountingServiceClient is the client API for AccountingService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type AccountingServiceClient interface {
 	// Returns the amount of funds in GAS token for the requested FrostFS account.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// balance has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
 }
 type accountingServiceClient struct {
 	cc grpc.ClientConnInterface
 }
 func NewAccountingServiceClient(cc grpc.ClientConnInterface) AccountingServiceClient {
 	return &accountingServiceClient{cc}
 }
 func (c *accountingServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
 	out := new(BalanceResponse)
 	err := c.cc.Invoke(ctx, AccountingService_Balance_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // AccountingServiceServer is the server API for AccountingService service.
 // All implementations should embed UnimplementedAccountingServiceServer
 // for forward compatibility
 type AccountingServiceServer interface {
 	// Returns the amount of funds in GAS token for the requested FrostFS account.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// balance has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
 }
 // UnimplementedAccountingServiceServer should be embedded to have forward compatible implementations.
 type UnimplementedAccountingServiceServer struct {
 }
 func (UnimplementedAccountingServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
 }
 // UnsafeAccountingServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to AccountingServiceServer will
 // result in compilation errors.
 type UnsafeAccountingServiceServer interface {
 	mustEmbedUnimplementedAccountingServiceServer()
 }
 func RegisterAccountingServiceServer(s grpc.ServiceRegistrar, srv AccountingServiceServer) {
 	s.RegisterService(&AccountingService_ServiceDesc, srv)
 }
 func _AccountingService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(BalanceRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(AccountingServiceServer).Balance(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: AccountingService_Balance_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(AccountingServiceServer).Balance(ctx, req.(*BalanceRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // AccountingService_ServiceDesc is the grpc.ServiceDesc for AccountingService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var AccountingService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "neo.fs.v2.accounting.AccountingService",
 	HandlerType: (*AccountingServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "Balance",
 			Handler:    _AccountingService_Balance_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "api/accounting/grpc/service.proto",
 }
--- a/api/accounting/grpc/types_frostfs.pb.go
+++ b/api/accounting/grpc/types_frostfs.pb.go
@ -1,204 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 import (
 	json "encoding/json"
 	fmt "fmt"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 	strconv "strconv"
 )
 type Decimal struct {
 	Value     int64  `json:"value"`
 	Precision uint32 `json:"precision"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Decimal)(nil)
 	_ encoding.ProtoUnmarshaler = (*Decimal)(nil)
 	_ json.Marshaler            = (*Decimal)(nil)
 	_ json.Unmarshaler          = (*Decimal)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Decimal) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.Int64Size(1, x.Value)
 	size += proto.UInt32Size(2, x.Precision)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Decimal) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Decimal) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.Value != 0 {
 		mm.AppendInt64(1, x.Value)
 	}
 	if x.Precision != 0 {
 		mm.AppendUint32(2, x.Precision)
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Decimal) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Decimal")
 		}
 		switch fc.FieldNum {
 		case 1: // Value
 			data, ok := fc.Int64()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Value")
 			}
 			x.Value = data
 		case 2: // Precision
 			data, ok := fc.Uint32()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Precision")
 			}
 			x.Precision = data
 		}
 	}
 	return nil
 }
 func (x *Decimal) GetValue() int64 {
 	if x != nil {
 		return x.Value
 	}
 	return 0
 }
 func (x *Decimal) SetValue(v int64) {
 	x.Value = v
 }
 func (x *Decimal) GetPrecision() uint32 {
 	if x != nil {
 		return x.Precision
 	}
 	return 0
 }
 func (x *Decimal) SetPrecision(v uint32) {
 	x.Precision = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Decimal) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Decimal) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"value\":"
 		out.RawString(prefix)
 		out.RawByte('"')
 		out.Buffer.Buf = strconv.AppendInt(out.Buffer.Buf, x.Value, 10)
 		out.RawByte('"')
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"precision\":"
 		out.RawString(prefix)
 		out.Uint32(x.Precision)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Decimal) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Decimal) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "value":
 			{
 				var f int64
 				r := in.JsonNumber()
 				n := r.String()
 				v, err := strconv.ParseInt(n, 10, 64)
 				if err != nil {
 					in.AddError(err)
 					return
 				}
 				pv := int64(v)
 				f = pv
 				x.Value = f
 			}
 		case "precision":
 			{
 				var f uint32
 				r := in.JsonNumber()
 				n := r.String()
 				v, err := strconv.ParseUint(n, 10, 32)
 				if err != nil {
 					in.AddError(err)
 					return
 				}
 				pv := uint32(v)
 				f = pv
 				x.Precision = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
--- a/api/accounting/grpc/types_frostfs_fuzz.go
+++ b/api/accounting/grpc/types_frostfs_fuzz.go
@ -1,26 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 func DoFuzzProtoDecimal(data []byte) int {
 	msg := new(Decimal)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONDecimal(data []byte) int {
 	msg := new(Decimal)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/accounting/grpc/types_frostfs_test.go
+++ b/api/accounting/grpc/types_frostfs_test.go
@ -1,21 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package accounting
 import (
 	testing "testing"
 )
 func FuzzProtoDecimal(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoDecimal(data)
 	})
 }
 func FuzzJSONDecimal(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONDecimal(data)
 	})
 }
--- a/api/accounting/json.go
+++ b/api/accounting/json.go
@ -1,14 +0,0 @@
 package accounting
 import (
 	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (d *Decimal) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(d)
 }
 func (d *Decimal) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(d, data, new(accounting.Decimal))
 }
--- a/api/accounting/marshal.go
+++ b/api/accounting/marshal.go
@ -1,104 +0,0 @@
 package accounting
 import (
 	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 )
 const (
 	decimalValueField     = 1
 	decimalPrecisionField = 2
 	balanceReqBodyOwnerField = 1
 	balanceRespBodyDecimalField = 1
 )
 func (d *Decimal) StableMarshal(buf []byte) []byte {
 	if d == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, d.StableSize())
 	}
 	var offset int
 	offset += protoutil.Int64Marshal(decimalValueField, buf[offset:], d.val)
 	protoutil.UInt32Marshal(decimalPrecisionField, buf[offset:], d.prec)
 	return buf
 }
 func (d *Decimal) StableSize() (size int) {
 	if d == nil {
 		return 0
 	}
 	size += protoutil.Int64Size(decimalValueField, d.val)
 	size += protoutil.UInt32Size(decimalPrecisionField, d.prec)
 	return size
 }
 func (d *Decimal) Unmarshal(data []byte) error {
 	return message.Unmarshal(d, data, new(accounting.Decimal))
 }
 func (b *BalanceRequestBody) StableMarshal(buf []byte) []byte {
 	if b == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, b.StableSize())
 	}
 	protoutil.NestedStructureMarshal(balanceReqBodyOwnerField, buf, b.ownerID)
 	return buf
 }
 func (b *BalanceRequestBody) StableSize() (size int) {
 	if b == nil {
 		return 0
 	}
 	size = protoutil.NestedStructureSize(balanceReqBodyOwnerField, b.ownerID)
 	return size
 }
 func (b *BalanceRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(b, data, new(accounting.BalanceRequest_Body))
 }
 func (br *BalanceResponseBody) StableMarshal(buf []byte) []byte {
 	if br == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, br.StableSize())
 	}
 	protoutil.NestedStructureMarshal(balanceRespBodyDecimalField, buf, br.bal)
 	return buf
 }
 func (br *BalanceResponseBody) StableSize() (size int) {
 	if br == nil {
 		return 0
 	}
 	size = protoutil.NestedStructureSize(balanceRespBodyDecimalField, br.bal)
 	return size
 }
 func (br *BalanceResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(br, data, new(accounting.BalanceResponse_Body))
 }
--- a/api/accounting/message_test.go
+++ b/api/accounting/message_test.go
@ -1,19 +0,0 @@
 package accounting_test
 import (
 	"testing"
 	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
 )
 func TestMessage(t *testing.T) {
 	messagetest.TestRPCMessage(t,
 		func(empty bool) message.Message { return accountingtest.GenerateDecimal(empty) },
 		func(empty bool) message.Message { return accountingtest.GenerateBalanceRequestBody(empty) },
 		func(empty bool) message.Message { return accountingtest.GenerateBalanceRequest(empty) },
 		func(empty bool) message.Message { return accountingtest.GenerateBalanceResponseBody(empty) },
 		func(empty bool) message.Message { return accountingtest.GenerateBalanceResponse(empty) },
 	)
 }
--- a/api/accounting/test/generate.go
+++ b/api/accounting/test/generate.go
@ -1,64 +0,0 @@
 package accountingtest
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
 	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
 )
 func GenerateBalanceRequest(empty bool) *accounting.BalanceRequest {
 	m := new(accounting.BalanceRequest)
 	if !empty {
 		m.SetBody(GenerateBalanceRequestBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	return m
 }
 func GenerateBalanceRequestBody(empty bool) *accounting.BalanceRequestBody {
 	m := new(accounting.BalanceRequestBody)
 	if !empty {
 		m.SetOwnerID(accountingtest.GenerateOwnerID(false))
 	}
 	return m
 }
 func GenerateBalanceResponse(empty bool) *accounting.BalanceResponse {
 	m := new(accounting.BalanceResponse)
 	if !empty {
 		m.SetBody(GenerateBalanceResponseBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	return m
 }
 func GenerateBalanceResponseBody(empty bool) *accounting.BalanceResponseBody {
 	m := new(accounting.BalanceResponseBody)
 	if !empty {
 		m.SetBalance(GenerateDecimal(false))
 	}
 	return m
 }
 func GenerateDecimal(empty bool) *accounting.Decimal {
 	m := new(accounting.Decimal)
 	if !empty {
 		m.SetValue(1)
 		m.SetPrecision(2)
 	}
 	return m
 }
--- a/api/acl/bench_test.go
+++ b/api/acl/bench_test.go
@ -1,51 +0,0 @@
 package acl_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl"
 	aclGrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
 	acltest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/test"
 )
 func BenchmarkTable_ToGRPCMessage(b *testing.B) {
 	const size = 4
 	tb := new(acl.Table)
 	rs := make([]acl.Record, size)
 	for i := range rs {
 		fs := make([]acl.HeaderFilter, size)
 		for j := range fs {
 			fs[j] = *acltest.GenerateFilter(false)
 		}
 		ts := make([]acl.Target, size)
 		for j := range ts {
 			ts[j] = *acltest.GenerateTarget(false)
 		}
 		rs[i].SetFilters(fs)
 		rs[i].SetTargets(ts)
 	}
 	tb.SetRecords(rs)
 	raw := tb.ToGRPCMessage()
 	b.Run("to grpc message", func(b *testing.B) {
 		b.ReportAllocs()
 		for range b.N {
 			raw := tb.ToGRPCMessage()
 			if len(tb.GetRecords()) != len(raw.(*aclGrpc.EACLTable).Records) {
 				b.FailNow()
 			}
 		}
 	})
 	b.Run("from grpc message", func(b *testing.B) {
 		b.ReportAllocs()
 		for range b.N {
 			tb := new(acl.Table)
 			if tb.FromGRPCMessage(raw) != nil {
 				b.FailNow()
 			}
 		}
 	})
 }
--- a/api/acl/convert.go
+++ b/api/acl/convert.go
@ -1,592 +0,0 @@
 package acl
 import (
 	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 // RoleToGRPCField converts unified role enum into grpc enum.
 func RoleToGRPCField(t Role) acl.Role {
 	switch t {
 	case RoleUser:
 		return acl.Role_USER
 	case RoleSystem:
 		return acl.Role_SYSTEM
 	case RoleOthers:
 		return acl.Role_OTHERS
 	default:
 		return acl.Role_ROLE_UNSPECIFIED
 	}
 }
 // RoleFromGRPCField converts grpc enum into unified role enum.
 func RoleFromGRPCField(t acl.Role) Role {
 	switch t {
 	case acl.Role_USER:
 		return RoleUser
 	case acl.Role_SYSTEM:
 		return RoleSystem
 	case acl.Role_OTHERS:
 		return RoleOthers
 	default:
 		return RoleUnknown
 	}
 }
 // OperationToGRPCField converts unified operation enum into grpc enum.
 func OperationToGRPCField(t Operation) acl.Operation {
 	switch t {
 	case OperationPut:
 		return acl.Operation_PUT
 	case OperationDelete:
 		return acl.Operation_DELETE
 	case OperationGet:
 		return acl.Operation_GET
 	case OperationHead:
 		return acl.Operation_HEAD
 	case OperationSearch:
 		return acl.Operation_SEARCH
 	case OperationRange:
 		return acl.Operation_GETRANGE
 	case OperationRangeHash:
 		return acl.Operation_GETRANGEHASH
 	default:
 		return acl.Operation_OPERATION_UNSPECIFIED
 	}
 }
 // OperationFromGRPCField converts grpc enum into unified operation enum.
 func OperationFromGRPCField(t acl.Operation) Operation {
 	switch t {
 	case acl.Operation_PUT:
 		return OperationPut
 	case acl.Operation_DELETE:
 		return OperationDelete
 	case acl.Operation_GET:
 		return OperationGet
 	case acl.Operation_HEAD:
 		return OperationHead
 	case acl.Operation_SEARCH:
 		return OperationSearch
 	case acl.Operation_GETRANGE:
 		return OperationRange
 	case acl.Operation_GETRANGEHASH:
 		return OperationRangeHash
 	default:
 		return OperationUnknown
 	}
 }
 // ActionToGRPCField converts unified action enum into grpc enum.
 func ActionToGRPCField(t Action) acl.Action {
 	switch t {
 	case ActionDeny:
 		return acl.Action_DENY
 	case ActionAllow:
 		return acl.Action_ALLOW
 	default:
 		return acl.Action_ACTION_UNSPECIFIED
 	}
 }
 // ActionFromGRPCField converts grpc enum into unified action enum.
 func ActionFromGRPCField(t acl.Action) Action {
 	switch t {
 	case acl.Action_DENY:
 		return ActionDeny
 	case acl.Action_ALLOW:
 		return ActionAllow
 	default:
 		return ActionUnknown
 	}
 }
 // HeaderTypeToGRPCField converts unified header type enum into grpc enum.
 func HeaderTypeToGRPCField(t HeaderType) acl.HeaderType {
 	switch t {
 	case HeaderTypeRequest:
 		return acl.HeaderType_REQUEST
 	case HeaderTypeObject:
 		return acl.HeaderType_OBJECT
 	case HeaderTypeService:
 		return acl.HeaderType_SERVICE
 	default:
 		return acl.HeaderType_HEADER_UNSPECIFIED
 	}
 }
 // HeaderTypeFromGRPCField converts grpc enum into unified header type enum.
 func HeaderTypeFromGRPCField(t acl.HeaderType) HeaderType {
 	switch t {
 	case acl.HeaderType_REQUEST:
 		return HeaderTypeRequest
 	case acl.HeaderType_OBJECT:
 		return HeaderTypeObject
 	case acl.HeaderType_SERVICE:
 		return HeaderTypeService
 	default:
 		return HeaderTypeUnknown
 	}
 }
 // MatchTypeToGRPCField converts unified match type enum into grpc enum.
 func MatchTypeToGRPCField(t MatchType) acl.MatchType {
 	switch t {
 	case MatchTypeStringEqual:
 		return acl.MatchType_STRING_EQUAL
 	case MatchTypeStringNotEqual:
 		return acl.MatchType_STRING_NOT_EQUAL
 	default:
 		return acl.MatchType_MATCH_TYPE_UNSPECIFIED
 	}
 }
 // MatchTypeFromGRPCField converts grpc enum into unified match type enum.
 func MatchTypeFromGRPCField(t acl.MatchType) MatchType {
 	switch t {
 	case acl.MatchType_STRING_EQUAL:
 		return MatchTypeStringEqual
 	case acl.MatchType_STRING_NOT_EQUAL:
 		return MatchTypeStringNotEqual
 	default:
 		return MatchTypeUnknown
 	}
 }
 func (f *HeaderFilter) ToGRPCMessage() grpc.Message {
 	var m *acl.EACLRecord_Filter
 	if f != nil {
 		m = new(acl.EACLRecord_Filter)
 		m.SetKey(f.key)
 		m.SetValue(f.value)
 		m.SetHeaderType(HeaderTypeToGRPCField(f.hdrType))
 		m.SetMatchType(MatchTypeToGRPCField(f.matchType))
 	}
 	return m
 }
 func (f *HeaderFilter) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.EACLRecord_Filter)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	f.key = v.GetKey()
 	f.value = v.GetValue()
 	f.hdrType = HeaderTypeFromGRPCField(v.GetHeaderType())
 	f.matchType = MatchTypeFromGRPCField(v.GetMatchType())
 	return nil
 }
 func HeaderFiltersToGRPC(fs []HeaderFilter) (res []acl.EACLRecord_Filter) {
 	if fs != nil {
 		res = make([]acl.EACLRecord_Filter, 0, len(fs))
 		for i := range fs {
 			res = append(res, *fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
 		}
 	}
 	return
 }
 func HeaderFiltersFromGRPC(fs []acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
 	if fs != nil {
 		res = make([]HeaderFilter, len(fs))
 		for i := range fs {
 			err = res[i].FromGRPCMessage(&fs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (t *Target) ToGRPCMessage() grpc.Message {
 	var m *acl.EACLRecord_Target
 	if t != nil {
 		m = new(acl.EACLRecord_Target)
 		m.SetRole(RoleToGRPCField(t.role))
 		m.SetKeys(t.keys)
 	}
 	return m
 }
 func (t *Target) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.EACLRecord_Target)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	t.role = RoleFromGRPCField(v.GetRole())
 	t.keys = v.GetKeys()
 	return nil
 }
 func TargetsToGRPC(ts []Target) (res []acl.EACLRecord_Target) {
 	if ts != nil {
 		res = make([]acl.EACLRecord_Target, 0, len(ts))
 		for i := range ts {
 			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
 		}
 	}
 	return
 }
 func TargetsFromGRPC(fs []acl.EACLRecord_Target) (res []Target, err error) {
 	if fs != nil {
 		res = make([]Target, len(fs))
 		for i := range fs {
 			err = res[i].FromGRPCMessage(&fs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (r *Record) ToGRPCMessage() grpc.Message {
 	var m *acl.EACLRecord
 	if r != nil {
 		m = new(acl.EACLRecord)
 		m.SetOperation(OperationToGRPCField(r.op))
 		m.SetAction(ActionToGRPCField(r.action))
 		m.SetFilters(HeaderFiltersToGRPC(r.filters))
 		m.SetTargets(TargetsToGRPC(r.targets))
 	}
 	return m
 }
 func (r *Record) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.EACLRecord)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	r.filters, err = HeaderFiltersFromGRPC(v.GetFilters())
 	if err != nil {
 		return err
 	}
 	r.targets, err = TargetsFromGRPC(v.GetTargets())
 	if err != nil {
 		return err
 	}
 	r.op = OperationFromGRPCField(v.GetOperation())
 	r.action = ActionFromGRPCField(v.GetAction())
 	return nil
 }
 func RecordsToGRPC(ts []Record) (res []acl.EACLRecord) {
 	if ts != nil {
 		res = make([]acl.EACLRecord, 0, len(ts))
 		for i := range ts {
 			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord))
 		}
 	}
 	return
 }
 func RecordsFromGRPC(fs []acl.EACLRecord) (res []Record, err error) {
 	if fs != nil {
 		res = make([]Record, len(fs))
 		for i := range fs {
 			err = res[i].FromGRPCMessage(&fs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (t *Table) ToGRPCMessage() grpc.Message {
 	var m *acl.EACLTable
 	if t != nil {
 		m = new(acl.EACLTable)
 		m.SetVersion(t.version.ToGRPCMessage().(*refsGRPC.Version))
 		m.SetContainerId(t.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
 		m.SetRecords(RecordsToGRPC(t.records))
 	}
 	return m
 }
 func (t *Table) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.EACLTable)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cid := v.GetContainerId()
 	if cid == nil {
 		t.cid = nil
 	} else {
 		if t.cid == nil {
 			t.cid = new(refs.ContainerID)
 		}
 		err = t.cid.FromGRPCMessage(cid)
 		if err != nil {
 			return err
 		}
 	}
 	version := v.GetVersion()
 	if version == nil {
 		t.version = nil
 	} else {
 		if t.version == nil {
 			t.version = new(refs.Version)
 		}
 		err = t.version.FromGRPCMessage(version)
 		if err != nil {
 			return err
 		}
 	}
 	t.records, err = RecordsFromGRPC(v.GetRecords())
 	return err
 }
 func (l *TokenLifetime) ToGRPCMessage() grpc.Message {
 	var m *acl.BearerToken_Body_TokenLifetime
 	if l != nil {
 		m = new(acl.BearerToken_Body_TokenLifetime)
 		m.SetExp(l.exp)
 		m.SetIat(l.iat)
 		m.SetNbf(l.nbf)
 	}
 	return m
 }
 func (l *TokenLifetime) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.BearerToken_Body_TokenLifetime)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	l.exp = v.GetExp()
 	l.iat = v.GetIat()
 	l.nbf = v.GetNbf()
 	return nil
 }
 func (c *APEOverride) ToGRPCMessage() grpc.Message {
 	var m *acl.BearerToken_Body_APEOverride
 	if c != nil {
 		m = new(acl.BearerToken_Body_APEOverride)
 		m.SetTarget(c.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
 		if len(c.chains) > 0 {
 			apeChains := make([]apeGRPC.Chain, len(c.chains))
 			for i := range c.chains {
 				apeChains[i] = *c.chains[i].ToGRPCMessage().(*apeGRPC.Chain)
 			}
 			m.SetChains(apeChains)
 		}
 	}
 	return m
 }
 func (c *APEOverride) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.BearerToken_Body_APEOverride)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	if targetGRPC := v.GetTarget(); targetGRPC != nil {
 		if c.target == nil {
 			c.target = new(ape.ChainTarget)
 		}
 		if err := c.target.FromGRPCMessage(v.GetTarget()); err != nil {
 			return err
 		}
 	}
 	if apeChains := v.GetChains(); len(apeChains) > 0 {
 		c.chains = make([]*ape.Chain, len(apeChains))
 		for i := range apeChains {
 			c.chains[i] = new(ape.Chain)
 			if err := c.chains[i].FromGRPCMessage(&apeChains[i]); err != nil {
 				return err
 			}
 		}
 	}
 	return nil
 }
 func (bt *BearerTokenBody) ToGRPCMessage() grpc.Message {
 	var m *acl.BearerToken_Body
 	if bt != nil {
 		m = new(acl.BearerToken_Body)
 		m.SetOwnerId(bt.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
 		m.SetLifetime(bt.lifetime.ToGRPCMessage().(*acl.BearerToken_Body_TokenLifetime))
 		m.SetEaclTable(bt.eacl.ToGRPCMessage().(*acl.EACLTable))
 		m.SetAllowImpersonate(bt.impersonate)
 		m.SetApeOverride(bt.apeOverride.ToGRPCMessage().(*acl.BearerToken_Body_APEOverride))
 	}
 	return m
 }
 func (bt *BearerTokenBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.BearerToken_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	ownerID := v.GetOwnerId()
 	if ownerID == nil {
 		bt.ownerID = nil
 	} else {
 		if bt.ownerID == nil {
 			bt.ownerID = new(refs.OwnerID)
 		}
 		err = bt.ownerID.FromGRPCMessage(ownerID)
 		if err != nil {
 			return err
 		}
 	}
 	lifetime := v.GetLifetime()
 	if lifetime == nil {
 		bt.lifetime = nil
 	} else {
 		if bt.lifetime == nil {
 			bt.lifetime = new(TokenLifetime)
 		}
 		err = bt.lifetime.FromGRPCMessage(lifetime)
 		if err != nil {
 			return err
 		}
 	}
 	eacl := v.GetEaclTable()
 	if eacl == nil {
 		bt.eacl = nil
 	} else {
 		if bt.eacl == nil {
 			bt.eacl = new(Table)
 		}
 		if err = bt.eacl.FromGRPCMessage(eacl); err != nil {
 			return err
 		}
 	}
 	if apeOverrideGRPC := v.GetApeOverride(); apeOverrideGRPC != nil {
 		if bt.apeOverride == nil {
 			bt.apeOverride = new(APEOverride)
 		}
 		err = bt.apeOverride.FromGRPCMessage(apeOverrideGRPC)
 		if err != nil {
 			return err
 		}
 	}
 	bt.impersonate = v.GetAllowImpersonate()
 	return err
 }
 func (bt *BearerToken) ToGRPCMessage() grpc.Message {
 	var m *acl.BearerToken
 	if bt != nil {
 		m = new(acl.BearerToken)
 		m.SetBody(bt.body.ToGRPCMessage().(*acl.BearerToken_Body))
 		m.SetSignature(bt.sig.ToGRPCMessage().(*refsGRPC.Signature))
 	}
 	return m
 }
 func (bt *BearerToken) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*acl.BearerToken)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		bt.body = nil
 	} else {
 		if bt.body == nil {
 			bt.body = new(BearerTokenBody)
 		}
 		err = bt.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	sig := v.GetSignature()
 	if sig == nil {
 		bt.sig = nil
 	} else {
 		if bt.sig == nil {
 			bt.sig = new(refs.Signature)
 		}
 		err = bt.sig.FromGRPCMessage(sig)
 	}
 	return err
 }
--- a/api/acl/filters.go
+++ b/api/acl/filters.go
@ -1,33 +0,0 @@
 package acl
 // ObjectFilterPrefix is a prefix of key to object header value or property.
 const ObjectFilterPrefix = "$Object:"
 const (
 	// FilterObjectVersion is a filter key to "version" field of the object header.
 	FilterObjectVersion = ObjectFilterPrefix + "version"
 	// FilterObjectID is a filter key to "object_id" field of the object.
 	FilterObjectID = ObjectFilterPrefix + "objectID"
 	// FilterObjectContainerID is a filter key to "container_id" field of the object header.
 	FilterObjectContainerID = ObjectFilterPrefix + "containerID"
 	// FilterObjectOwnerID is a filter key to "owner_id" field of the object header.
 	FilterObjectOwnerID = ObjectFilterPrefix + "ownerID"
 	// FilterObjectCreationEpoch is a filter key to "creation_epoch" field of the object header.
 	FilterObjectCreationEpoch = ObjectFilterPrefix + "creationEpoch"
 	// FilterObjectPayloadLength is a filter key to "payload_length" field of the object header.
 	FilterObjectPayloadLength = ObjectFilterPrefix + "payloadLength"
 	// FilterObjectPayloadHash is a filter key to "payload_hash" field of the object header.
 	FilterObjectPayloadHash = ObjectFilterPrefix + "payloadHash"
 	// FilterObjectType is a filter key to "object_type" field of the object header.
 	FilterObjectType = ObjectFilterPrefix + "objectType"
 	// FilterObjectHomomorphicHash is a filter key to "homomorphic_hash" field of the object header.
 	FilterObjectHomomorphicHash = ObjectFilterPrefix + "homomorphicHash"
 )
--- a/api/acl/grpc/types_frostfs.pb.go
+++ b/api/acl/grpc/types_frostfs.pb.go
--- a/api/acl/grpc/types_frostfs_fuzz.go
+++ b/api/acl/grpc/types_frostfs_fuzz.go
@ -1,64 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package acl
 func DoFuzzProtoEACLRecord(data []byte) int {
 	msg := new(EACLRecord)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONEACLRecord(data []byte) int {
 	msg := new(EACLRecord)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoEACLTable(data []byte) int {
 	msg := new(EACLTable)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONEACLTable(data []byte) int {
 	msg := new(EACLTable)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoBearerToken(data []byte) int {
 	msg := new(BearerToken)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONBearerToken(data []byte) int {
 	msg := new(BearerToken)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/acl/grpc/types_frostfs_test.go
+++ b/api/acl/grpc/types_frostfs_test.go
@ -1,41 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package acl
 import (
 	testing "testing"
 )
 func FuzzProtoEACLRecord(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoEACLRecord(data)
 	})
 }
 func FuzzJSONEACLRecord(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONEACLRecord(data)
 	})
 }
 func FuzzProtoEACLTable(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoEACLTable(data)
 	})
 }
 func FuzzJSONEACLTable(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONEACLTable(data)
 	})
 }
 func FuzzProtoBearerToken(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoBearerToken(data)
 	})
 }
 func FuzzJSONBearerToken(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONBearerToken(data)
 	})
 }
--- a/api/acl/json.go
+++ b/api/acl/json.go
@ -1,70 +0,0 @@
 package acl
 import (
 	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (f *HeaderFilter) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(f)
 }
 func (f *HeaderFilter) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(f, data, new(acl.EACLRecord_Filter))
 }
 func (t *Target) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(t)
 }
 func (t *Target) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(t, data, new(acl.EACLRecord_Target))
 }
 func (a *APEOverride) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(a)
 }
 func (a *APEOverride) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(a, data, new(acl.BearerToken_Body_APEOverride))
 }
 func (r *Record) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(r)
 }
 func (r *Record) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(r, data, new(acl.EACLRecord))
 }
 func (t *Table) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(t)
 }
 func (t *Table) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(t, data, new(acl.EACLTable))
 }
 func (l *TokenLifetime) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(l)
 }
 func (l *TokenLifetime) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(l, data, new(acl.BearerToken_Body_TokenLifetime))
 }
 func (bt *BearerTokenBody) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(bt)
 }
 func (bt *BearerTokenBody) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(bt, data, new(acl.BearerToken_Body))
 }
 func (bt *BearerToken) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(bt)
 }
 func (bt *BearerToken) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(bt, data, new(acl.BearerToken))
 }
--- a/api/acl/marshal.go
+++ b/api/acl/marshal.go
@ -1,350 +0,0 @@
 package acl
 import (
 	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 )
 const (
 	filterHeaderTypeField = 1
 	filterMatchTypeField  = 2
 	filterNameField       = 3
 	filterValueField      = 4
 	targetTypeField = 1
 	targetKeysField = 2
 	recordOperationField = 1
 	recordActionField    = 2
 	recordFiltersField   = 3
 	recordTargetsField   = 4
 	tableVersionField     = 1
 	tableContainerIDField = 2
 	tableRecordsField     = 3
 	lifetimeExpirationField     = 1
 	lifetimeNotValidBeforeField = 2
 	lifetimeIssuedAtField       = 3
 	tokenAPEChainsTargetField = 1
 	tokenAPEChainsChainsField = 2
 	bearerTokenBodyACLField        = 1
 	bearerTokenBodyOwnerField      = 2
 	bearerTokenBodyLifetimeField   = 3
 	bearerTokenBodyImpersonate     = 4
 	bearerTokenTokenAPEChainsField = 5
 	bearerTokenBodyField      = 1
 	bearerTokenSignatureField = 2
 )
 // StableMarshal marshals unified acl table structure in a protobuf
 // compatible way without field order shuffle.
 func (t *Table) StableMarshal(buf []byte) []byte {
 	if t == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, t.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(tableVersionField, buf[offset:], t.version)
 	offset += protoutil.NestedStructureMarshal(tableContainerIDField, buf[offset:], t.cid)
 	for i := range t.records {
 		offset += protoutil.NestedStructureMarshal(tableRecordsField, buf[offset:], &t.records[i])
 	}
 	return buf
 }
 // StableSize of acl table structure marshalled by StableMarshal function.
 func (t *Table) StableSize() (size int) {
 	if t == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(tableVersionField, t.version)
 	size += protoutil.NestedStructureSize(tableContainerIDField, t.cid)
 	for i := range t.records {
 		size += protoutil.NestedStructureSize(tableRecordsField, &t.records[i])
 	}
 	return size
 }
 func (t *Table) Unmarshal(data []byte) error {
 	return message.Unmarshal(t, data, new(acl.EACLTable))
 }
 // StableMarshal marshals unified acl record structure in a protobuf
 // compatible way without field order shuffle.
 func (r *Record) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	var offset int
 	offset += protoutil.EnumMarshal(recordOperationField, buf[offset:], int32(r.op))
 	offset += protoutil.EnumMarshal(recordActionField, buf[offset:], int32(r.action))
 	for i := range r.filters {
 		offset += protoutil.NestedStructureMarshal(recordFiltersField, buf[offset:], &r.filters[i])
 	}
 	for i := range r.targets {
 		offset += protoutil.NestedStructureMarshal(recordTargetsField, buf[offset:], &r.targets[i])
 	}
 	return buf
 }
 // StableSize of acl record structure marshalled by StableMarshal function.
 func (r *Record) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.EnumSize(recordOperationField, int32(r.op))
 	size += protoutil.EnumSize(recordActionField, int32(r.action))
 	for i := range r.filters {
 		size += protoutil.NestedStructureSize(recordFiltersField, &r.filters[i])
 	}
 	for i := range r.targets {
 		size += protoutil.NestedStructureSize(recordTargetsField, &r.targets[i])
 	}
 	return size
 }
 func (r *Record) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(acl.EACLRecord))
 }
 // StableMarshal marshals unified header filter structure in a protobuf
 // compatible way without field order shuffle.
 func (f *HeaderFilter) StableMarshal(buf []byte) []byte {
 	if f == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, f.StableSize())
 	}
 	var offset int
 	offset += protoutil.EnumMarshal(filterHeaderTypeField, buf[offset:], int32(f.hdrType))
 	offset += protoutil.EnumMarshal(filterMatchTypeField, buf[offset:], int32(f.matchType))
 	offset += protoutil.StringMarshal(filterNameField, buf[offset:], f.key)
 	protoutil.StringMarshal(filterValueField, buf[offset:], f.value)
 	return buf
 }
 // StableSize of header filter structure marshalled by StableMarshal function.
 func (f *HeaderFilter) StableSize() (size int) {
 	if f == nil {
 		return 0
 	}
 	size += protoutil.EnumSize(filterHeaderTypeField, int32(f.hdrType))
 	size += protoutil.EnumSize(filterMatchTypeField, int32(f.matchType))
 	size += protoutil.StringSize(filterNameField, f.key)
 	size += protoutil.StringSize(filterValueField, f.value)
 	return size
 }
 func (f *HeaderFilter) Unmarshal(data []byte) error {
 	return message.Unmarshal(f, data, new(acl.EACLRecord_Filter))
 }
 // StableMarshal marshals unified role info structure in a protobuf
 // compatible way without field order shuffle.
 func (t *Target) StableMarshal(buf []byte) []byte {
 	if t == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, t.StableSize())
 	}
 	var offset int
 	offset += protoutil.EnumMarshal(targetTypeField, buf[offset:], int32(t.role))
 	protoutil.RepeatedBytesMarshal(targetKeysField, buf[offset:], t.keys)
 	return buf
 }
 // StableSize of role info structure marshalled by StableMarshal function.
 func (t *Target) StableSize() (size int) {
 	if t == nil {
 		return 0
 	}
 	size += protoutil.EnumSize(targetTypeField, int32(t.role))
 	size += protoutil.RepeatedBytesSize(targetKeysField, t.keys)
 	return size
 }
 func (t *Target) Unmarshal(data []byte) error {
 	return message.Unmarshal(t, data, new(acl.EACLRecord_Target))
 }
 func (l *TokenLifetime) StableMarshal(buf []byte) []byte {
 	if l == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, l.StableSize())
 	}
 	var offset int
 	offset += protoutil.UInt64Marshal(lifetimeExpirationField, buf[offset:], l.exp)
 	offset += protoutil.UInt64Marshal(lifetimeNotValidBeforeField, buf[offset:], l.nbf)
 	protoutil.UInt64Marshal(lifetimeIssuedAtField, buf[offset:], l.iat)
 	return buf
 }
 func (l *TokenLifetime) StableSize() (size int) {
 	if l == nil {
 		return 0
 	}
 	size += protoutil.UInt64Size(lifetimeExpirationField, l.exp)
 	size += protoutil.UInt64Size(lifetimeNotValidBeforeField, l.nbf)
 	size += protoutil.UInt64Size(lifetimeIssuedAtField, l.iat)
 	return size
 }
 func (l *TokenLifetime) Unmarshal(data []byte) error {
 	return message.Unmarshal(l, data, new(acl.BearerToken_Body_TokenLifetime))
 }
 func (c *APEOverride) StableMarshal(buf []byte) []byte {
 	if c == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, c.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(tokenAPEChainsTargetField, buf[offset:], c.target)
 	for i := range c.chains {
 		offset += protoutil.NestedStructureMarshal(tokenAPEChainsChainsField, buf[offset:], c.chains[i])
 	}
 	return buf
 }
 func (c *APEOverride) StableSize() (size int) {
 	if c == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(tokenAPEChainsTargetField, c.target)
 	for i := range c.chains {
 		size += protoutil.NestedStructureSize(tokenAPEChainsChainsField, c.chains[i])
 	}
 	return size
 }
 func (c *APEOverride) Unmarshal(data []byte) error {
 	return message.Unmarshal(c, data, new(acl.BearerToken_Body_APEOverride))
 }
 func (bt *BearerTokenBody) StableMarshal(buf []byte) []byte {
 	if bt == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, bt.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyACLField, buf[offset:], bt.eacl)
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyOwnerField, buf[offset:], bt.ownerID)
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyLifetimeField, buf[offset:], bt.lifetime)
 	offset += protoutil.BoolMarshal(bearerTokenBodyImpersonate, buf[offset:], bt.impersonate)
 	protoutil.NestedStructureMarshal(bearerTokenTokenAPEChainsField, buf[offset:], bt.apeOverride)
 	return buf
 }
 func (bt *BearerTokenBody) StableSize() (size int) {
 	if bt == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(bearerTokenBodyACLField, bt.eacl)
 	size += protoutil.NestedStructureSize(bearerTokenBodyOwnerField, bt.ownerID)
 	size += protoutil.NestedStructureSize(bearerTokenBodyLifetimeField, bt.lifetime)
 	size += protoutil.BoolSize(bearerTokenBodyImpersonate, bt.impersonate)
 	size += protoutil.NestedStructureSize(bearerTokenTokenAPEChainsField, bt.apeOverride)
 	return size
 }
 func (bt *BearerTokenBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(bt, data, new(acl.BearerToken_Body))
 }
 func (bt *BearerToken) StableMarshal(buf []byte) []byte {
 	if bt == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, bt.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyField, buf[offset:], bt.body)
 	protoutil.NestedStructureMarshal(bearerTokenSignatureField, buf[offset:], bt.sig)
 	return buf
 }
 func (bt *BearerToken) StableSize() (size int) {
 	if bt == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(bearerTokenBodyField, bt.body)
 	size += protoutil.NestedStructureSize(bearerTokenSignatureField, bt.sig)
 	return size
 }
 func (bt *BearerToken) Unmarshal(data []byte) error {
 	return message.Unmarshal(bt, data, new(acl.BearerToken))
 }
--- a/api/acl/message_test.go
+++ b/api/acl/message_test.go
@ -1,21 +0,0 @@
 package acl_test
 import (
 	"testing"
 	acltest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
 )
 func TestMessageConvert(t *testing.T) {
 	messagetest.TestRPCMessage(t,
 		func(empty bool) message.Message { return acltest.GenerateFilter(empty) },
 		func(empty bool) message.Message { return acltest.GenerateTarget(empty) },
 		func(empty bool) message.Message { return acltest.GenerateRecord(empty) },
 		func(empty bool) message.Message { return acltest.GenerateTable(empty) },
 		func(empty bool) message.Message { return acltest.GenerateTokenLifetime(empty) },
 		func(empty bool) message.Message { return acltest.GenerateBearerTokenBody(empty) },
 		func(empty bool) message.Message { return acltest.GenerateBearerToken(empty) },
 	)
 }
--- a/api/acl/string.go
+++ b/api/acl/string.go
@ -1,110 +0,0 @@
 package acl
 import (
 	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
 )
 // String returns string representation of Action.
 func (x Action) String() string {
 	return ActionToGRPCField(x).String()
 }
 // FromString parses Action from a string representation.
 // It is a reverse action to String().
 //
 // Returns true if s was parsed successfully.
 func (x *Action) FromString(s string) bool {
 	var g acl.Action
 	ok := g.FromString(s)
 	if ok {
 		*x = ActionFromGRPCField(g)
 	}
 	return ok
 }
 // String returns string representation of Role.
 func (x Role) String() string {
 	return RoleToGRPCField(x).String()
 }
 // FromString parses Role from a string representation.
 // It is a reverse action to String().
 //
 // Returns true if s was parsed successfully.
 func (x *Role) FromString(s string) bool {
 	var g acl.Role
 	ok := g.FromString(s)
 	if ok {
 		*x = RoleFromGRPCField(g)
 	}
 	return ok
 }
 // String returns string representation of Operation.
 func (x Operation) String() string {
 	return OperationToGRPCField(x).String()
 }
 // FromString parses Operation from a string representation.
 // It is a reverse action to String().
 //
 // Returns true if s was parsed successfully.
 func (x *Operation) FromString(s string) bool {
 	var g acl.Operation
 	ok := g.FromString(s)
 	if ok {
 		*x = OperationFromGRPCField(g)
 	}
 	return ok
 }
 // String returns string representation of MatchType.
 func (x MatchType) String() string {
 	return MatchTypeToGRPCField(x).String()
 }
 // FromString parses MatchType from a string representation.
 // It is a reverse action to String().
 //
 // Returns true if s was parsed successfully.
 func (x *MatchType) FromString(s string) bool {
 	var g acl.MatchType
 	ok := g.FromString(s)
 	if ok {
 		*x = MatchTypeFromGRPCField(g)
 	}
 	return ok
 }
 // String returns string representation of HeaderType.
 func (x HeaderType) String() string {
 	return HeaderTypeToGRPCField(x).String()
 }
 // FromString parses HeaderType from a string representation.
 // It is a reverse action to String().
 //
 // Returns true if s was parsed successfully.
 func (x *HeaderType) FromString(s string) bool {
 	var g acl.HeaderType
 	ok := g.FromString(s)
 	if ok {
 		*x = HeaderTypeFromGRPCField(g)
 	}
 	return ok
 }
--- a/api/acl/test/generate.go
+++ b/api/acl/test/generate.go
@ -1,144 +0,0 @@
 package acltest
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl"
 	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
 	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
 )
 func GenerateBearerToken(empty bool) *acl.BearerToken {
 	m := new(acl.BearerToken)
 	if !empty {
 		m.SetBody(GenerateBearerTokenBody(false))
 	}
 	m.SetSignature(accountingtest.GenerateSignature(empty))
 	return m
 }
 func GenerateBearerTokenBody(empty bool) *acl.BearerTokenBody {
 	m := new(acl.BearerTokenBody)
 	if !empty {
 		m.SetOwnerID(accountingtest.GenerateOwnerID(false))
 		m.SetLifetime(GenerateTokenLifetime(false))
 		m.SetAPEOverride(GenerateAPEOverride(empty))
 	}
 	return m
 }
 func GenerateAPEOverride(empty bool) *acl.APEOverride {
 	var m *acl.APEOverride
 	if !empty {
 		m = new(acl.APEOverride)
 		m.SetTarget(apetest.GenerateChainTarget(empty))
 		m.SetChains(apetest.GenerateRawChains(false, 3))
 	}
 	return m
 }
 func GenerateTable(empty bool) *acl.Table {
 	m := new(acl.Table)
 	if !empty {
 		m.SetRecords(GenerateRecords(false))
 		m.SetContainerID(accountingtest.GenerateContainerID(false))
 	}
 	m.SetVersion(accountingtest.GenerateVersion(empty))
 	return m
 }
 func GenerateRecords(empty bool) []acl.Record {
 	var rs []acl.Record
 	if !empty {
 		rs = append(rs,
 			*GenerateRecord(false),
 			*GenerateRecord(false),
 		)
 	}
 	return rs
 }
 func GenerateRecord(empty bool) *acl.Record {
 	m := new(acl.Record)
 	if !empty {
 		m.SetAction(acl.ActionAllow)
 		m.SetOperation(acl.OperationGet)
 		m.SetFilters(GenerateFilters(false))
 		m.SetTargets(GenerateTargets(false))
 	}
 	return m
 }
 func GenerateFilters(empty bool) []acl.HeaderFilter {
 	var fs []acl.HeaderFilter
 	if !empty {
 		fs = append(fs,
 			*GenerateFilter(false),
 			*GenerateFilter(false),
 		)
 	}
 	return fs
 }
 func GenerateFilter(empty bool) *acl.HeaderFilter {
 	m := new(acl.HeaderFilter)
 	if !empty {
 		m.SetKey("key")
 		m.SetValue("val")
 		m.SetHeaderType(acl.HeaderTypeRequest)
 		m.SetMatchType(acl.MatchTypeStringEqual)
 	}
 	return m
 }
 func GenerateTargets(empty bool) []acl.Target {
 	var ts []acl.Target
 	if !empty {
 		ts = append(ts,
 			*GenerateTarget(false),
 			*GenerateTarget(false),
 		)
 	}
 	return ts
 }
 func GenerateTarget(empty bool) *acl.Target {
 	m := new(acl.Target)
 	if !empty {
 		m.SetRole(acl.RoleSystem)
 		m.SetKeys([][]byte{{1}, {2}})
 	}
 	return m
 }
 func GenerateTokenLifetime(empty bool) *acl.TokenLifetime {
 	m := new(acl.TokenLifetime)
 	if !empty {
 		m.SetExp(1)
 		m.SetIat(2)
 		m.SetExp(3)
 	}
 	return m
 }
--- a/api/acl/types.go
+++ b/api/acl/types.go
@ -1,426 +0,0 @@
 package acl
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 )
 // HeaderFilter is a unified structure of FilterInfo
 // message from proto definition.
 type HeaderFilter struct {
 	hdrType HeaderType
 	matchType MatchType
 	key, value string
 }
 // Target is a unified structure of Target
 // message from proto definition.
 type Target struct {
 	role Role
 	keys [][]byte
 }
 // Record is a unified structure of EACLRecord
 // message from proto definition.
 type Record struct {
 	op Operation
 	action Action
 	filters []HeaderFilter
 	targets []Target
 }
 // Table is a unified structure of EACLTable
 // message from proto definition.
 type Table struct {
 	version *refs.Version
 	cid *refs.ContainerID
 	records []Record
 }
 type TokenLifetime struct {
 	exp, nbf, iat uint64
 }
 type APEOverride struct {
 	target *ape.ChainTarget
 	chains []*ape.Chain
 }
 type BearerTokenBody struct {
 	eacl *Table
 	ownerID *refs.OwnerID
 	lifetime *TokenLifetime
 	apeOverride *APEOverride
 	impersonate bool
 }
 type BearerToken struct {
 	body *BearerTokenBody
 	sig *refs.Signature
 }
 // Target is a unified enum of MatchType enum from proto definition.
 type MatchType uint32
 // HeaderType is a unified enum of HeaderType enum from proto definition.
 type HeaderType uint32
 // Action is a unified enum of Action enum from proto definition.
 type Action uint32
 // Operation is a unified enum of Operation enum from proto definition.
 type Operation uint32
 // Role is a unified enum of Role enum from proto definition.
 type Role uint32
 const (
 	MatchTypeUnknown MatchType = iota
 	MatchTypeStringEqual
 	MatchTypeStringNotEqual
 )
 const (
 	HeaderTypeUnknown HeaderType = iota
 	HeaderTypeRequest
 	HeaderTypeObject
 	HeaderTypeService
 )
 const (
 	ActionUnknown Action = iota
 	ActionAllow
 	ActionDeny
 )
 const (
 	OperationUnknown Operation = iota
 	OperationGet
 	OperationHead
 	OperationPut
 	OperationDelete
 	OperationSearch
 	OperationRange
 	OperationRangeHash
 )
 const (
 	RoleUnknown Role = iota
 	RoleUser
 	RoleSystem
 	RoleOthers
 )
 func (f *HeaderFilter) GetHeaderType() HeaderType {
 	if f != nil {
 		return f.hdrType
 	}
 	return HeaderTypeUnknown
 }
 func (f *HeaderFilter) SetHeaderType(v HeaderType) {
 	f.hdrType = v
 }
 func (f *HeaderFilter) GetMatchType() MatchType {
 	if f != nil {
 		return f.matchType
 	}
 	return MatchTypeUnknown
 }
 func (f *HeaderFilter) SetMatchType(v MatchType) {
 	f.matchType = v
 }
 func (f *HeaderFilter) GetKey() string {
 	if f != nil {
 		return f.key
 	}
 	return ""
 }
 func (f *HeaderFilter) SetKey(v string) {
 	f.key = v
 }
 func (f *HeaderFilter) GetValue() string {
 	if f != nil {
 		return f.value
 	}
 	return ""
 }
 func (f *HeaderFilter) SetValue(v string) {
 	f.value = v
 }
 func (t *Target) GetRole() Role {
 	if t != nil {
 		return t.role
 	}
 	return RoleUnknown
 }
 func (t *Target) SetRole(v Role) {
 	t.role = v
 }
 func (t *Target) GetKeys() [][]byte {
 	if t != nil {
 		return t.keys
 	}
 	return nil
 }
 func (t *Target) SetKeys(v [][]byte) {
 	t.keys = v
 }
 func (r *Record) GetOperation() Operation {
 	if r != nil {
 		return r.op
 	}
 	return OperationUnknown
 }
 func (r *Record) SetOperation(v Operation) {
 	r.op = v
 }
 func (r *Record) GetAction() Action {
 	if r != nil {
 		return r.action
 	}
 	return ActionUnknown
 }
 func (r *Record) SetAction(v Action) {
 	r.action = v
 }
 func (r *Record) GetFilters() []HeaderFilter {
 	if r != nil {
 		return r.filters
 	}
 	return nil
 }
 func (r *Record) SetFilters(v []HeaderFilter) {
 	r.filters = v
 }
 func (r *Record) GetTargets() []Target {
 	if r != nil {
 		return r.targets
 	}
 	return nil
 }
 func (r *Record) SetTargets(v []Target) {
 	r.targets = v
 }
 func (t *Table) GetVersion() *refs.Version {
 	if t != nil {
 		return t.version
 	}
 	return nil
 }
 func (t *Table) SetVersion(v *refs.Version) {
 	t.version = v
 }
 func (t *Table) GetContainerID() *refs.ContainerID {
 	if t != nil {
 		return t.cid
 	}
 	return nil
 }
 func (t *Table) SetContainerID(v *refs.ContainerID) {
 	t.cid = v
 }
 func (t *Table) GetRecords() []Record {
 	if t != nil {
 		return t.records
 	}
 	return nil
 }
 func (t *Table) SetRecords(v []Record) {
 	t.records = v
 }
 func (l *TokenLifetime) GetExp() uint64 {
 	if l != nil {
 		return l.exp
 	}
 	return 0
 }
 func (l *TokenLifetime) SetExp(v uint64) {
 	l.exp = v
 }
 func (l *TokenLifetime) GetNbf() uint64 {
 	if l != nil {
 		return l.nbf
 	}
 	return 0
 }
 func (l *TokenLifetime) SetNbf(v uint64) {
 	l.nbf = v
 }
 func (l *TokenLifetime) GetIat() uint64 {
 	if l != nil {
 		return l.iat
 	}
 	return 0
 }
 func (l *TokenLifetime) SetIat(v uint64) {
 	l.iat = v
 }
 func (bt *BearerTokenBody) GetEACL() *Table {
 	if bt != nil {
 		return bt.eacl
 	}
 	return nil
 }
 func (bt *BearerTokenBody) SetEACL(v *Table) {
 	bt.eacl = v
 }
 func (t *APEOverride) GetTarget() *ape.ChainTarget {
 	if t == nil {
 		return nil
 	}
 	return t.target
 }
 func (t *APEOverride) GetChains() []*ape.Chain {
 	if t == nil {
 		return nil
 	}
 	return t.chains
 }
 func (t *APEOverride) SetTarget(v *ape.ChainTarget) {
 	t.target = v
 }
 func (t *APEOverride) SetChains(v []*ape.Chain) {
 	t.chains = v
 }
 func (bt *BearerTokenBody) GetAPEOverride() *APEOverride {
 	if bt != nil {
 		return bt.apeOverride
 	}
 	return nil
 }
 func (bt *BearerTokenBody) SetAPEOverride(v *APEOverride) {
 	bt.apeOverride = v
 }
 func (bt *BearerTokenBody) GetOwnerID() *refs.OwnerID {
 	if bt != nil {
 		return bt.ownerID
 	}
 	return nil
 }
 func (bt *BearerTokenBody) SetOwnerID(v *refs.OwnerID) {
 	bt.ownerID = v
 }
 func (bt *BearerTokenBody) GetLifetime() *TokenLifetime {
 	if bt != nil {
 		return bt.lifetime
 	}
 	return nil
 }
 func (bt *BearerTokenBody) SetLifetime(v *TokenLifetime) {
 	bt.lifetime = v
 }
 func (bt *BearerTokenBody) GetImpersonate() bool {
 	if bt != nil {
 		return bt.impersonate
 	}
 	return false
 }
 func (bt *BearerTokenBody) SetImpersonate(v bool) {
 	bt.impersonate = v
 }
 func (bt *BearerToken) GetBody() *BearerTokenBody {
 	if bt != nil {
 		return bt.body
 	}
 	return nil
 }
 func (bt *BearerToken) SetBody(v *BearerTokenBody) {
 	bt.body = v
 }
 func (bt *BearerToken) GetSignature() *refs.Signature {
 	if bt != nil {
 		return bt.sig
 	}
 	return nil
 }
 func (bt *BearerToken) SetSignature(v *refs.Signature) {
 	bt.sig = v
 }
--- a/api/ape/convert.go
+++ b/api/ape/convert.go
@ -1,132 +0,0 @@
 package ape
 import (
 	"fmt"
 	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func TargetTypeToGRPCField(typ TargetType) ape.TargetType {
 	switch typ {
 	case TargetTypeNamespace:
 		return ape.TargetType_NAMESPACE
 	case TargetTypeContainer:
 		return ape.TargetType_CONTAINER
 	case TargetTypeUser:
 		return ape.TargetType_USER
 	case TargetTypeGroup:
 		return ape.TargetType_GROUP
 	default:
 		return ape.TargetType_UNDEFINED
 	}
 }
 func TargetTypeFromGRPCField(typ ape.TargetType) TargetType {
 	switch typ {
 	case ape.TargetType_NAMESPACE:
 		return TargetTypeNamespace
 	case ape.TargetType_CONTAINER:
 		return TargetTypeContainer
 	case ape.TargetType_USER:
 		return TargetTypeUser
 	case ape.TargetType_GROUP:
 		return TargetTypeGroup
 	default:
 		return TargetTypeUndefined
 	}
 }
 func TargetTypeToGRPC(typ TargetType) ape.TargetType {
 	return ape.TargetType(typ)
 }
 func TargetTypeFromGRPC(typ ape.TargetType) TargetType {
 	return TargetType(typ)
 }
 func (v2 *ChainTarget) ToGRPCMessage() grpc.Message {
 	var mgrpc *ape.ChainTarget
 	if v2 != nil {
 		mgrpc = new(ape.ChainTarget)
 		mgrpc.SetType(TargetTypeToGRPC(v2.GetTargetType()))
 		mgrpc.SetName(v2.GetName())
 	}
 	return mgrpc
 }
 func (v2 *ChainTarget) FromGRPCMessage(m grpc.Message) error {
 	mgrpc, ok := m.(*ape.ChainTarget)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, mgrpc)
 	}
 	v2.SetTargetType(TargetTypeFromGRPC(mgrpc.GetType()))
 	v2.SetName(mgrpc.GetName())
 	return nil
 }
 func (v2 *ChainRaw) ToGRPCMessage() grpc.Message {
 	var mgrpc *ape.Chain_Raw
 	if v2 != nil {
 		mgrpc = new(ape.Chain_Raw)
 		mgrpc.SetRaw(v2.GetRaw())
 	}
 	return mgrpc
 }
 func (v2 *ChainRaw) FromGRPCMessage(m grpc.Message) error {
 	mgrpc, ok := m.(*ape.Chain_Raw)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, mgrpc)
 	}
 	v2.SetRaw(mgrpc.GetRaw())
 	return nil
 }
 func (v2 *Chain) ToGRPCMessage() grpc.Message {
 	var mgrpc *ape.Chain
 	if v2 != nil {
 		mgrpc = new(ape.Chain)
 		switch chainKind := v2.GetKind().(type) {
 		default:
 			panic(fmt.Sprintf("unsupported chain kind: %T", chainKind))
 		case *ChainRaw:
 			mgrpc.SetKind(chainKind.ToGRPCMessage().(*ape.Chain_Raw))
 		}
 	}
 	return mgrpc
 }
 func (v2 *Chain) FromGRPCMessage(m grpc.Message) error {
 	mgrpc, ok := m.(*ape.Chain)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, mgrpc)
 	}
 	switch chainKind := mgrpc.GetKind().(type) {
 	default:
 		return fmt.Errorf("unsupported chain kind: %T", chainKind)
 	case *ape.Chain_Raw:
 		chainRaw := new(ChainRaw)
 		if err := chainRaw.FromGRPCMessage(chainKind); err != nil {
 			return err
 		}
 		v2.SetKind(chainRaw)
 	}
 	return nil
 }
--- a/api/ape/grpc/types_frostfs.pb.go
+++ b/api/ape/grpc/types_frostfs.pb.go
@ -1,430 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 import (
 	json "encoding/json"
 	fmt "fmt"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 	strconv "strconv"
 )
 type TargetType int32
 const (
 	TargetType_UNDEFINED TargetType = 0
 	TargetType_NAMESPACE TargetType = 1
 	TargetType_CONTAINER TargetType = 2
 	TargetType_USER      TargetType = 3
 	TargetType_GROUP     TargetType = 4
 )
 var (
 	TargetType_name = map[int32]string{
 		0: "UNDEFINED",
 		1: "NAMESPACE",
 		2: "CONTAINER",
 		3: "USER",
 		4: "GROUP",
 	}
 	TargetType_value = map[string]int32{
 		"UNDEFINED": 0,
 		"NAMESPACE": 1,
 		"CONTAINER": 2,
 		"USER":      3,
 		"GROUP":     4,
 	}
 )
 func (x TargetType) String() string {
 	if v, ok := TargetType_name[int32(x)]; ok {
 		return v
 	}
 	return strconv.FormatInt(int64(x), 10)
 }
 func (x *TargetType) FromString(s string) bool {
 	if v, ok := TargetType_value[s]; ok {
 		*x = TargetType(v)
 		return true
 	}
 	return false
 }
 type ChainTarget struct {
 	Type TargetType `json:"type"`
 	Name string     `json:"name"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*ChainTarget)(nil)
 	_ encoding.ProtoUnmarshaler = (*ChainTarget)(nil)
 	_ json.Marshaler            = (*ChainTarget)(nil)
 	_ json.Unmarshaler          = (*ChainTarget)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *ChainTarget) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.EnumSize(1, int32(x.Type))
 	size += proto.StringSize(2, x.Name)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *ChainTarget) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *ChainTarget) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if int32(x.Type) != 0 {
 		mm.AppendInt32(1, int32(x.Type))
 	}
 	if len(x.Name) != 0 {
 		mm.AppendString(2, x.Name)
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *ChainTarget) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "ChainTarget")
 		}
 		switch fc.FieldNum {
 		case 1: // Type
 			data, ok := fc.Int32()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Type")
 			}
 			x.Type = TargetType(data)
 		case 2: // Name
 			data, ok := fc.String()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Name")
 			}
 			x.Name = data
 		}
 	}
 	return nil
 }
 func (x *ChainTarget) GetType() TargetType {
 	if x != nil {
 		return x.Type
 	}
 	return 0
 }
 func (x *ChainTarget) SetType(v TargetType) {
 	x.Type = v
 }
 func (x *ChainTarget) GetName() string {
 	if x != nil {
 		return x.Name
 	}
 	return ""
 }
 func (x *ChainTarget) SetName(v string) {
 	x.Name = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *ChainTarget) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *ChainTarget) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"type\":"
 		out.RawString(prefix)
 		v := int32(x.Type)
 		if vv, ok := TargetType_name[v]; ok {
 			out.String(vv)
 		} else {
 			out.Int32(v)
 		}
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"name\":"
 		out.RawString(prefix)
 		out.String(x.Name)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *ChainTarget) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *ChainTarget) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "type":
 			{
 				var f TargetType
 				var parsedValue TargetType
 				switch v := in.Interface().(type) {
 				case string:
 					if vv, ok := TargetType_value[v]; ok {
 						parsedValue = TargetType(vv)
 						break
 					}
 					vv, err := strconv.ParseInt(v, 10, 32)
 					if err != nil {
 						in.AddError(err)
 						return
 					}
 					parsedValue = TargetType(vv)
 				case float64:
 					parsedValue = TargetType(v)
 				}
 				f = parsedValue
 				x.Type = f
 			}
 		case "name":
 			{
 				var f string
 				f = in.String()
 				x.Name = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type Chain struct {
 	Kind isChain_Kind
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Chain)(nil)
 	_ encoding.ProtoUnmarshaler = (*Chain)(nil)
 	_ json.Marshaler            = (*Chain)(nil)
 	_ json.Unmarshaler          = (*Chain)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Chain) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	if inner, ok := x.Kind.(*Chain_Raw); ok {
 		size += proto.BytesSize(1, inner.Raw)
 	}
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Chain) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Chain) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if inner, ok := x.Kind.(*Chain_Raw); ok {
 		if len(inner.Raw) != 0 {
 			mm.AppendBytes(1, inner.Raw)
 		}
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Chain) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Chain")
 		}
 		switch fc.FieldNum {
 		case 1: // Raw
 			data, ok := fc.Bytes()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Raw")
 			}
 			x.Kind = &Chain_Raw{Raw: data}
 		}
 	}
 	return nil
 }
 func (x *Chain) GetKind() isChain_Kind {
 	if x != nil {
 		return x.Kind
 	}
 	return nil
 }
 func (x *Chain) SetKind(v isChain_Kind) {
 	x.Kind = v
 }
 func (x *Chain) GetRaw() []byte {
 	if xx, ok := x.GetKind().(*Chain_Raw); ok {
 		return xx.Raw
 	}
 	return nil
 }
 func (x *Chain) SetRaw(v *Chain_Raw) {
 	x.Kind = v
 }
 func (x *Chain_Raw) GetRaw() []byte {
 	if x != nil {
 		return x.Raw
 	}
 	return nil
 }
 func (x *Chain_Raw) SetRaw(v []byte) {
 	x.Raw = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Chain) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Chain) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	switch xx := x.Kind.(type) {
 	case *Chain_Raw:
 		{
 			if !first {
 				out.RawByte(',')
 			} else {
 				first = false
 			}
 			const prefix string = "\"raw\":"
 			out.RawString(prefix)
 			if xx.Raw != nil {
 				out.Base64Bytes(xx.Raw)
 			} else {
 				out.String("")
 			}
 		}
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Chain) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Chain) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "raw":
 			xx := new(Chain_Raw)
 			x.Kind = xx
 			{
 				var f []byte
 				{
 					tmp := in.Bytes()
 					if len(tmp) == 0 {
 						tmp = nil
 					}
 					f = tmp
 				}
 				xx.Raw = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type isChain_Kind interface {
 	isChain_Kind()
 }
 type Chain_Raw struct {
 	Raw []byte
 }
 func (*Chain_Raw) isChain_Kind() {}
--- a/api/ape/grpc/types_frostfs_fuzz.go
+++ b/api/ape/grpc/types_frostfs_fuzz.go
@ -1,45 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 func DoFuzzProtoChainTarget(data []byte) int {
 	msg := new(ChainTarget)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONChainTarget(data []byte) int {
 	msg := new(ChainTarget)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoChain(data []byte) int {
 	msg := new(Chain)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONChain(data []byte) int {
 	msg := new(Chain)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/ape/grpc/types_frostfs_test.go
+++ b/api/ape/grpc/types_frostfs_test.go
@ -1,31 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package ape
 import (
 	testing "testing"
 )
 func FuzzProtoChainTarget(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoChainTarget(data)
 	})
 }
 func FuzzJSONChainTarget(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONChainTarget(data)
 	})
 }
 func FuzzProtoChain(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoChain(data)
 	})
 }
 func FuzzJSONChain(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONChain(data)
 	})
 }
--- a/api/ape/json.go
+++ b/api/ape/json.go
@ -1,14 +0,0 @@
 package ape
 import (
 	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (t *ChainTarget) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(t)
 }
 func (t *ChainTarget) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(t, data, new(ape.ChainTarget))
 }
--- a/api/ape/marshal.go
+++ b/api/ape/marshal.go
@ -1,92 +0,0 @@
 package ape
 import (
 	"fmt"
 	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 )
 const (
 	chainTargetTargetTypeField = 1
 	chainTargetNameField       = 2
 	chainRawField = 1
 )
 func (t *ChainTarget) StableSize() (size int) {
 	if t == nil {
 		return 0
 	}
 	size += proto.EnumSize(chainTargetTargetTypeField, int32(t.targeType))
 	size += proto.StringSize(chainTargetNameField, t.name)
 	return size
 }
 func (t *ChainTarget) StableMarshal(buf []byte) []byte {
 	if t == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, t.StableSize())
 	}
 	var offset int
 	offset += proto.EnumMarshal(chainTargetTargetTypeField, buf[offset:], int32(t.targeType))
 	proto.StringMarshal(chainTargetNameField, buf[offset:], t.name)
 	return buf
 }
 func (t *ChainTarget) Unmarshal(data []byte) error {
 	return message.Unmarshal(t, data, new(ape.ChainTarget))
 }
 func (c *Chain) StableSize() (size int) {
 	if c == nil {
 		return 0
 	}
 	switch v := c.GetKind().(type) {
 	case *ChainRaw:
 		if v != nil {
 			size += proto.BytesSize(chainRawField, v.GetRaw())
 		}
 	default:
 		panic(fmt.Sprintf("unsupported chain kind: %T", v))
 	}
 	return size
 }
 func (c *Chain) StableMarshal(buf []byte) []byte {
 	if c == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, c.StableSize())
 	}
 	var offset int
 	switch v := c.GetKind().(type) {
 	case *ChainRaw:
 		if v != nil {
 			proto.BytesMarshal(chainRawField, buf[offset:], v.GetRaw())
 		}
 	default:
 		panic(fmt.Sprintf("unsupported chain kind: %T", v))
 	}
 	return buf
 }
 func (c *Chain) Unmarshal(data []byte) error {
 	return message.Unmarshal(c, data, new(ape.Chain))
 }
--- a/api/ape/message_test.go
+++ b/api/ape/message_test.go
@ -1,15 +0,0 @@
 package ape_test
 import (
 	"testing"
 	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
 )
 func TestMessageConvert(t *testing.T) {
 	messagetest.TestRPCMessage(t,
 		func(empty bool) message.Message { return apetest.GenerateChainTarget(empty) },
 	)
 }
--- a/api/ape/string.go
+++ b/api/ape/string.go
@ -1,18 +0,0 @@
 package ape
 import (
 	apegrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 )
 func (tt TargetType) String() string {
 	return TargetTypeToGRPCField(tt).String()
 }
 func (tt *TargetType) FromString(s string) bool {
 	i, ok := apegrpc.TargetType_value[s]
 	if ok {
 		*tt = TargetType(i)
 	}
 	return ok
 }
--- a/api/ape/test/generate.go
+++ b/api/ape/test/generate.go
@ -1,71 +0,0 @@
 package test
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 )
 func GenerateRawChains(empty bool, n int) []*ape.Chain {
 	if empty {
 		return []*ape.Chain{}
 	}
 	res := make([]*ape.Chain, n)
 	for i := range res {
 		res[i] = GenerateRawChain(empty)
 	}
 	return res
 }
 func GenerateRawChain(empty bool) *ape.Chain {
 	chRaw := new(ape.ChainRaw)
 	if empty {
 		chRaw.SetRaw([]byte("{}"))
 	} else {
 		chRaw.SetRaw([]byte(`{
 			"ID": "",
 			"Rules": [
 			  {
 				"Status": "Allow",
 				"Actions": {
 				  "Inverted": false,
 				  "Names": [
 					"GetObject"
 				  ]
 				},
 				"Resources": {
 				  "Inverted": false,
 				  "Names": [
 					"native:object/*"
 				  ]
 				},
 				"Any": false,
 				"Condition": [
 				  {
 					"Op": "StringEquals",
 					"Object": "Resource",
 					"Key": "Department",
 					"Value": "HR"
 				  }
 				]
 			  }
 			],
 			"MatchType": "DenyPriority"
 			}`))
 	}
 	ch := new(ape.Chain)
 	ch.SetKind(chRaw)
 	return ch
 }
 func GenerateChainTarget(empty bool) *ape.ChainTarget {
 	m := new(ape.ChainTarget)
 	if !empty {
 		m.SetTargetType(ape.TargetTypeContainer)
 		m.SetName("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R")
 	}
 	return m
 }
--- a/api/ape/types.go
+++ b/api/ape/types.go
@ -1,79 +0,0 @@
 package ape
 type TargetType uint32
 const (
 	TargetTypeUndefined TargetType = iota
 	TargetTypeNamespace
 	TargetTypeContainer
 	TargetTypeUser
 	TargetTypeGroup
 )
 type ChainTarget struct {
 	targeType TargetType
 	name string
 }
 func (ct *ChainTarget) SetTargetType(targeType TargetType) {
 	ct.targeType = targeType
 }
 func (ct *ChainTarget) SetName(name string) {
 	ct.name = name
 }
 func (ct *ChainTarget) GetTargetType() TargetType {
 	if ct != nil {
 		return ct.targeType
 	}
 	return 0
 }
 func (ct *ChainTarget) GetName() string {
 	if ct != nil {
 		return ct.name
 	}
 	return ""
 }
 type chainKind interface {
 	isChainKind()
 }
 type Chain struct {
 	kind chainKind
 }
 func (c *Chain) SetKind(kind chainKind) {
 	c.kind = kind
 }
 func (c *Chain) GetKind() chainKind {
 	if c == nil {
 		return nil
 	}
 	return c.kind
 }
 type ChainRaw struct {
 	Raw []byte
 }
 func (*ChainRaw) isChainKind() {}
 func (c *ChainRaw) SetRaw(raw []byte) {
 	c.Raw = raw
 }
 func (c *ChainRaw) GetRaw() []byte {
 	if c == nil {
 		return nil
 	}
 	return c.Raw
 }
--- a/api/apemanager/convert.go
+++ b/api/apemanager/convert.go
@ -1,358 +0,0 @@
 package apemanager
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
 	apemanager "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (reqBody *AddChainRequestBody) ToGRPCMessage() grpc.Message {
 	var reqBodygrpc *apemanager.AddChainRequest_Body
 	if reqBody != nil {
 		reqBodygrpc = new(apemanager.AddChainRequest_Body)
 		reqBodygrpc.SetTarget(reqBody.GetTarget().ToGRPCMessage().(*apeGRPC.ChainTarget))
 		reqBodygrpc.SetChain(reqBody.GetChain().ToGRPCMessage().(*apeGRPC.Chain))
 	}
 	return reqBodygrpc
 }
 func (reqBody *AddChainRequestBody) FromGRPCMessage(m grpc.Message) error {
 	reqBodygrpc, ok := m.(*apemanager.AddChainRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqBodygrpc)
 	}
 	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
 		reqBody.target = new(ape.ChainTarget)
 		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
 			return err
 		}
 	}
 	if chaingrpc := reqBodygrpc.GetChain(); chaingrpc != nil {
 		reqBody.chain = new(ape.Chain)
 		if err := reqBody.GetChain().FromGRPCMessage(chaingrpc); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func (req *AddChainRequest) ToGRPCMessage() grpc.Message {
 	var reqgrpc *apemanager.AddChainRequest
 	if req != nil {
 		reqgrpc = new(apemanager.AddChainRequest)
 		reqgrpc.SetBody(req.GetBody().ToGRPCMessage().(*apemanager.AddChainRequest_Body))
 		req.RequestHeaders.ToMessage(reqgrpc)
 	}
 	return reqgrpc
 }
 func (req *AddChainRequest) FromGRPCMessage(m grpc.Message) error {
 	reqgrpc, ok := m.(*apemanager.AddChainRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqgrpc)
 	}
 	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
 		req.body = new(AddChainRequestBody)
 		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
 			return err
 		}
 	}
 	return req.RequestHeaders.FromMessage(reqgrpc)
 }
 func (respBody *AddChainResponseBody) ToGRPCMessage() grpc.Message {
 	var respBodygrpc *apemanager.AddChainResponse_Body
 	if respBody != nil {
 		respBodygrpc = new(apemanager.AddChainResponse_Body)
 		respBodygrpc.SetChainId(respBody.GetChainID())
 	}
 	return respBodygrpc
 }
 func (respBody *AddChainResponseBody) FromGRPCMessage(m grpc.Message) error {
 	respBodygrpc, ok := m.(*apemanager.AddChainResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respBodygrpc)
 	}
 	respBody.SetChainID(respBodygrpc.GetChainId())
 	return nil
 }
 func (resp *AddChainResponse) ToGRPCMessage() grpc.Message {
 	var respgrpc *apemanager.AddChainResponse
 	if resp != nil {
 		respgrpc = new(apemanager.AddChainResponse)
 		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.AddChainResponse_Body))
 		resp.ResponseHeaders.ToMessage(respgrpc)
 	}
 	return respgrpc
 }
 func (resp *AddChainResponse) FromGRPCMessage(m grpc.Message) error {
 	respgrpc, ok := m.(*apemanager.AddChainResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respgrpc)
 	}
 	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
 		resp.body = new(AddChainResponseBody)
 		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
 			return err
 		}
 	}
 	return resp.ResponseHeaders.FromMessage(respgrpc)
 }
 func (reqBody *RemoveChainRequestBody) ToGRPCMessage() grpc.Message {
 	var reqBodygrpc *apemanager.RemoveChainRequest_Body
 	if reqBody != nil {
 		reqBodygrpc = new(apemanager.RemoveChainRequest_Body)
 		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
 		reqBodygrpc.SetChainId(reqBody.GetChainID())
 	}
 	return reqBodygrpc
 }
 func (reqBody *RemoveChainRequestBody) FromGRPCMessage(m grpc.Message) error {
 	reqBodygrpc, ok := m.(*apemanager.RemoveChainRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqBodygrpc)
 	}
 	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
 		reqBody.target = new(ape.ChainTarget)
 		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
 			return err
 		}
 	}
 	reqBody.SetChainID(reqBodygrpc.GetChainId())
 	return nil
 }
 func (req *RemoveChainRequest) ToGRPCMessage() grpc.Message {
 	var reqgrpc *apemanager.RemoveChainRequest
 	if req != nil {
 		reqgrpc = new(apemanager.RemoveChainRequest)
 		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.RemoveChainRequest_Body))
 		req.RequestHeaders.ToMessage(reqgrpc)
 	}
 	return reqgrpc
 }
 func (req *RemoveChainRequest) FromGRPCMessage(m grpc.Message) error {
 	reqgrpc, ok := m.(*apemanager.RemoveChainRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqgrpc)
 	}
 	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
 		req.body = new(RemoveChainRequestBody)
 		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
 			return err
 		}
 	}
 	return req.RequestHeaders.FromMessage(reqgrpc)
 }
 func (respBody *RemoveChainResponseBody) ToGRPCMessage() grpc.Message {
 	var respBodygrpc *apemanager.RemoveChainResponse_Body
 	if respBody != nil {
 		respBodygrpc = new(apemanager.RemoveChainResponse_Body)
 	}
 	return respBodygrpc
 }
 func (respBody *RemoveChainResponseBody) FromGRPCMessage(m grpc.Message) error {
 	respBodygrpc, ok := m.(*apemanager.RemoveChainResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respBodygrpc)
 	}
 	return nil
 }
 func (resp *RemoveChainResponse) ToGRPCMessage() grpc.Message {
 	var respgrpc *apemanager.RemoveChainResponse
 	if resp != nil {
 		respgrpc = new(apemanager.RemoveChainResponse)
 		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.RemoveChainResponse_Body))
 		resp.ResponseHeaders.ToMessage(respgrpc)
 	}
 	return respgrpc
 }
 func (resp *RemoveChainResponse) FromGRPCMessage(m grpc.Message) error {
 	respgrpc, ok := m.(*apemanager.RemoveChainResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respgrpc)
 	}
 	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
 		resp.body = new(RemoveChainResponseBody)
 		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
 			return err
 		}
 	}
 	return resp.ResponseHeaders.FromMessage(respgrpc)
 }
 func (reqBody *ListChainsRequestBody) ToGRPCMessage() grpc.Message {
 	var reqBodygrpc *apemanager.ListChainsRequest_Body
 	if reqBody != nil {
 		reqBodygrpc = new(apemanager.ListChainsRequest_Body)
 		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
 	}
 	return reqBodygrpc
 }
 func (reqBody *ListChainsRequestBody) FromGRPCMessage(m grpc.Message) error {
 	reqBodygrpc, ok := m.(*apemanager.ListChainsRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqBodygrpc)
 	}
 	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
 		reqBody.target = new(ape.ChainTarget)
 		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func (req *ListChainsRequest) ToGRPCMessage() grpc.Message {
 	var reqgrpc *apemanager.ListChainsRequest
 	if req != nil {
 		reqgrpc = new(apemanager.ListChainsRequest)
 		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.ListChainsRequest_Body))
 		req.RequestHeaders.ToMessage(reqgrpc)
 	}
 	return reqgrpc
 }
 func (req *ListChainsRequest) FromGRPCMessage(m grpc.Message) error {
 	reqgrpc, ok := m.(*apemanager.ListChainsRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, reqgrpc)
 	}
 	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
 		req.body = new(ListChainsRequestBody)
 		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
 			return err
 		}
 	}
 	return req.RequestHeaders.FromMessage(reqgrpc)
 }
 func (respBody *ListChainsResponseBody) ToGRPCMessage() grpc.Message {
 	var respBodygrpc *apemanager.ListChainsResponse_Body
 	if respBody != nil {
 		respBodygrpc = new(apemanager.ListChainsResponse_Body)
 		chainsgrpc := make([]apeGRPC.Chain, 0, len(respBody.GetChains()))
 		for _, chain := range respBody.GetChains() {
 			chainsgrpc = append(chainsgrpc, *chain.ToGRPCMessage().(*apeGRPC.Chain))
 		}
 		respBodygrpc.SetChains(chainsgrpc)
 	}
 	return respBodygrpc
 }
 func (respBody *ListChainsResponseBody) FromGRPCMessage(m grpc.Message) error {
 	respBodygrpc, ok := m.(*apemanager.ListChainsResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respBodygrpc)
 	}
 	chains := make([]*ape.Chain, 0, len(respBodygrpc.GetChains()))
 	for _, chaingrpc := range respBodygrpc.GetChains() {
 		chain := new(ape.Chain)
 		if err := chain.FromGRPCMessage(&chaingrpc); err != nil {
 			return err
 		}
 		chains = append(chains, chain)
 	}
 	respBody.SetChains(chains)
 	return nil
 }
 func (resp *ListChainsResponse) ToGRPCMessage() grpc.Message {
 	var respgrpc *apemanager.ListChainsResponse
 	if resp != nil {
 		respgrpc = new(apemanager.ListChainsResponse)
 		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.ListChainsResponse_Body))
 		resp.ResponseHeaders.ToMessage(respgrpc)
 	}
 	return respgrpc
 }
 func (resp *ListChainsResponse) FromGRPCMessage(m grpc.Message) error {
 	respgrpc, ok := m.(*apemanager.ListChainsResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, respgrpc)
 	}
 	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
 		resp.body = new(ListChainsResponseBody)
 		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
 			return err
 		}
 	}
 	return resp.ResponseHeaders.FromMessage(respgrpc)
 }
--- a/api/apemanager/grpc/service_frostfs.pb.go
+++ b/api/apemanager/grpc/service_frostfs.pb.go
--- a/api/apemanager/grpc/service_frostfs_fuzz.go
+++ b/api/apemanager/grpc/service_frostfs_fuzz.go
@ -1,121 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package apemanager
 func DoFuzzProtoAddChainRequest(data []byte) int {
 	msg := new(AddChainRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONAddChainRequest(data []byte) int {
 	msg := new(AddChainRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoAddChainResponse(data []byte) int {
 	msg := new(AddChainResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONAddChainResponse(data []byte) int {
 	msg := new(AddChainResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoRemoveChainRequest(data []byte) int {
 	msg := new(RemoveChainRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONRemoveChainRequest(data []byte) int {
 	msg := new(RemoveChainRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoRemoveChainResponse(data []byte) int {
 	msg := new(RemoveChainResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONRemoveChainResponse(data []byte) int {
 	msg := new(RemoveChainResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoListChainsRequest(data []byte) int {
 	msg := new(ListChainsRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONListChainsRequest(data []byte) int {
 	msg := new(ListChainsRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoListChainsResponse(data []byte) int {
 	msg := new(ListChainsResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONListChainsResponse(data []byte) int {
 	msg := new(ListChainsResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/apemanager/grpc/service_frostfs_test.go
+++ b/api/apemanager/grpc/service_frostfs_test.go
@ -1,71 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package apemanager
 import (
 	testing "testing"
 )
 func FuzzProtoAddChainRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoAddChainRequest(data)
 	})
 }
 func FuzzJSONAddChainRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONAddChainRequest(data)
 	})
 }
 func FuzzProtoAddChainResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoAddChainResponse(data)
 	})
 }
 func FuzzJSONAddChainResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONAddChainResponse(data)
 	})
 }
 func FuzzProtoRemoveChainRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoRemoveChainRequest(data)
 	})
 }
 func FuzzJSONRemoveChainRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONRemoveChainRequest(data)
 	})
 }
 func FuzzProtoRemoveChainResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoRemoveChainResponse(data)
 	})
 }
 func FuzzJSONRemoveChainResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONRemoveChainResponse(data)
 	})
 }
 func FuzzProtoListChainsRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoListChainsRequest(data)
 	})
 }
 func FuzzJSONListChainsRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONListChainsRequest(data)
 	})
 }
 func FuzzProtoListChainsResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoListChainsResponse(data)
 	})
 }
 func FuzzJSONListChainsResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONListChainsResponse(data)
 	})
 }
--- a/api/apemanager/grpc/service_grpc.pb.go
+++ b/api/apemanager/grpc/service_grpc.pb.go
@ -1,245 +0,0 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.3.0
 // - protoc             v5.27.2
 // source: api/apemanager/grpc/service.proto
 package apemanager
 import (
 	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 )
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
 // Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 const (
 	APEManagerService_AddChain_FullMethodName    = "/frostfs.v2.apemanager.APEManagerService/AddChain"
 	APEManagerService_RemoveChain_FullMethodName = "/frostfs.v2.apemanager.APEManagerService/RemoveChain"
 	APEManagerService_ListChains_FullMethodName  = "/frostfs.v2.apemanager.APEManagerService/ListChains"
 )
 // APEManagerServiceClient is the client API for APEManagerService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type APEManagerServiceClient interface {
 	// Add a rule chain for a specific target to `Policy` smart contract.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   the chain has been successfully added;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	AddChain(ctx context.Context, in *AddChainRequest, opts ...grpc.CallOption) (*AddChainResponse, error)
 	// Remove a rule chain for a specific target from `Policy` smart contract.
 	// RemoveChain is an idempotent operation: removal of non-existing rule chain
 	// also means success.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   the chain has been successfully removed;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	RemoveChain(ctx context.Context, in *RemoveChainRequest, opts ...grpc.CallOption) (*RemoveChainResponse, error)
 	// List chains defined for a specific target from `Policy` smart contract.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   chains have been successfully listed;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	ListChains(ctx context.Context, in *ListChainsRequest, opts ...grpc.CallOption) (*ListChainsResponse, error)
 }
 type aPEManagerServiceClient struct {
 	cc grpc.ClientConnInterface
 }
 func NewAPEManagerServiceClient(cc grpc.ClientConnInterface) APEManagerServiceClient {
 	return &aPEManagerServiceClient{cc}
 }
 func (c *aPEManagerServiceClient) AddChain(ctx context.Context, in *AddChainRequest, opts ...grpc.CallOption) (*AddChainResponse, error) {
 	out := new(AddChainResponse)
 	err := c.cc.Invoke(ctx, APEManagerService_AddChain_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *aPEManagerServiceClient) RemoveChain(ctx context.Context, in *RemoveChainRequest, opts ...grpc.CallOption) (*RemoveChainResponse, error) {
 	out := new(RemoveChainResponse)
 	err := c.cc.Invoke(ctx, APEManagerService_RemoveChain_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *aPEManagerServiceClient) ListChains(ctx context.Context, in *ListChainsRequest, opts ...grpc.CallOption) (*ListChainsResponse, error) {
 	out := new(ListChainsResponse)
 	err := c.cc.Invoke(ctx, APEManagerService_ListChains_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // APEManagerServiceServer is the server API for APEManagerService service.
 // All implementations should embed UnimplementedAPEManagerServiceServer
 // for forward compatibility
 type APEManagerServiceServer interface {
 	// Add a rule chain for a specific target to `Policy` smart contract.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   the chain has been successfully added;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	AddChain(context.Context, *AddChainRequest) (*AddChainResponse, error)
 	// Remove a rule chain for a specific target from `Policy` smart contract.
 	// RemoveChain is an idempotent operation: removal of non-existing rule chain
 	// also means success.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   the chain has been successfully removed;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	RemoveChain(context.Context, *RemoveChainRequest) (*RemoveChainResponse, error)
 	// List chains defined for a specific target from `Policy` smart contract.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   chains have been successfully listed;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   container (as target) not found;
 	// - **APE_MANAGER_ACCESS_DENIED** (5120, SECTION_APE_MANAGER): \
 	//   the operation is denied by the service.
 	ListChains(context.Context, *ListChainsRequest) (*ListChainsResponse, error)
 }
 // UnimplementedAPEManagerServiceServer should be embedded to have forward compatible implementations.
 type UnimplementedAPEManagerServiceServer struct {
 }
 func (UnimplementedAPEManagerServiceServer) AddChain(context.Context, *AddChainRequest) (*AddChainResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AddChain not implemented")
 }
 func (UnimplementedAPEManagerServiceServer) RemoveChain(context.Context, *RemoveChainRequest) (*RemoveChainResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RemoveChain not implemented")
 }
 func (UnimplementedAPEManagerServiceServer) ListChains(context.Context, *ListChainsRequest) (*ListChainsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListChains not implemented")
 }
 // UnsafeAPEManagerServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to APEManagerServiceServer will
 // result in compilation errors.
 type UnsafeAPEManagerServiceServer interface {
 	mustEmbedUnimplementedAPEManagerServiceServer()
 }
 func RegisterAPEManagerServiceServer(s grpc.ServiceRegistrar, srv APEManagerServiceServer) {
 	s.RegisterService(&APEManagerService_ServiceDesc, srv)
 }
 func _APEManagerService_AddChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(AddChainRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(APEManagerServiceServer).AddChain(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: APEManagerService_AddChain_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(APEManagerServiceServer).AddChain(ctx, req.(*AddChainRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _APEManagerService_RemoveChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(RemoveChainRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(APEManagerServiceServer).RemoveChain(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: APEManagerService_RemoveChain_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(APEManagerServiceServer).RemoveChain(ctx, req.(*RemoveChainRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _APEManagerService_ListChains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ListChainsRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(APEManagerServiceServer).ListChains(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: APEManagerService_ListChains_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(APEManagerServiceServer).ListChains(ctx, req.(*ListChainsRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // APEManagerService_ServiceDesc is the grpc.ServiceDesc for APEManagerService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var APEManagerService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "frostfs.v2.apemanager.APEManagerService",
 	HandlerType: (*APEManagerServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "AddChain",
 			Handler:    _APEManagerService_AddChain_Handler,
 		},
 		{
 			MethodName: "RemoveChain",
 			Handler:    _APEManagerService_RemoveChain_Handler,
 		},
 		{
 			MethodName: "ListChains",
 			Handler:    _APEManagerService_ListChains_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "api/apemanager/grpc/service.proto",
 }
--- a/api/apemanager/marshal.go
+++ b/api/apemanager/marshal.go
@ -1,205 +0,0 @@
 package apemanager
 import (
 	apemanager "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 )
 const (
 	addChainReqBodyTargetField = 1
 	addChainReqBodyChainField  = 2
 	addChainRespBodyChainIDField = 1
 	removeChainReqBodyTargetField = 1
 	removeChainReqBodyChainField  = 2
 	/*
 		Fields for RemoveResponseBody are missed since RemoveResponseBody is empty.
 	*/
 	listChainsReqBodyTargetField = 1
 	listChainsRespBodyChainsField = 1
 )
 func (rb *AddChainRequestBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
 	size += proto.NestedStructureSize(addChainReqBodyChainField, rb.chain)
 	return size
 }
 func (rb *AddChainRequestBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	var offset int
 	offset += proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
 	proto.NestedStructureMarshal(addChainReqBodyChainField, buf[offset:], rb.chain)
 	return buf
 }
 func (rb *AddChainRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.AddChainRequest_Body))
 }
 func (rb *AddChainResponseBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	size += proto.BytesSize(addChainRespBodyChainIDField, rb.chainID)
 	return size
 }
 func (rb *AddChainResponseBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	var offset int
 	proto.BytesMarshal(addChainRespBodyChainIDField, buf[offset:], rb.chainID)
 	return buf
 }
 func (rb *AddChainResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.AddChainResponse_Body))
 }
 func (rb *RemoveChainRequestBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
 	size += proto.BytesSize(addChainReqBodyChainField, rb.chainID)
 	return size
 }
 func (rb *RemoveChainRequestBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	var offset int
 	offset += proto.NestedStructureMarshal(removeChainReqBodyTargetField, buf[offset:], rb.target)
 	proto.BytesMarshal(removeChainReqBodyChainField, buf[offset:], rb.chainID)
 	return buf
 }
 func (rb *RemoveChainRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.RemoveChainRequest_Body))
 }
 func (rb *RemoveChainResponseBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	return size
 }
 func (rb *RemoveChainResponseBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	return buf
 }
 func (rb *RemoveChainResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.RemoveChainResponse_Body))
 }
 func (rb *ListChainsRequestBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(listChainsReqBodyTargetField, rb.target)
 	return size
 }
 func (rb *ListChainsRequestBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	var offset int
 	proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
 	return buf
 }
 func (rb *ListChainsRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.ListChainsRequest_Body))
 }
 func (rb *ListChainsResponseBody) StableSize() (size int) {
 	if rb == nil {
 		return 0
 	}
 	for _, chain := range rb.GetChains() {
 		size += proto.NestedStructureSize(listChainsRespBodyChainsField, chain)
 	}
 	return size
 }
 func (rb *ListChainsResponseBody) StableMarshal(buf []byte) []byte {
 	if rb == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, rb.StableSize())
 	}
 	var offset int
 	for _, chain := range rb.GetChains() {
 		offset += proto.NestedStructureMarshal(listChainsRespBodyChainsField, buf[offset:], chain)
 	}
 	return buf
 }
 func (rb *ListChainsResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(rb, data, new(apemanager.ListChainsResponse_Body))
 }
--- a/api/apemanager/message_test.go
+++ b/api/apemanager/message_test.go
@ -1,26 +0,0 @@
 package apemanager_test
 import (
 	"testing"
 	apemanagertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
 )
 func TestMessageConvert(t *testing.T) {
 	messagetest.TestRPCMessage(t,
 		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequestBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequest(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponseBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponse(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequestBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequest(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponseBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponse(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequestBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequest(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponseBody(empty) },
 		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponse(empty) },
 	)
 }
--- a/api/apemanager/status.go
+++ b/api/apemanager/status.go
@ -1,76 +0,0 @@
 package apemanager
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
 	statusgrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/grpc"
 )
 // LocalizeFailStatus checks if passed global status.Code is related to ape manager failure and:
 //
 //	then localizes the code and returns true,
 //	else leaves the code unchanged and returns false.
 //
 // Arg must be non-nil.
 func LocalizeFailStatus(c *status.Code) bool {
 	return status.LocalizeIfInSection(c, uint32(statusgrpc.Section_SECTION_APE_MANAGER))
 }
 // GlobalizeFail globalizes local code of ape manager failure.
 //
 // Arg must be non-nil.
 func GlobalizeFail(c *status.Code) {
 	c.GlobalizeSection(uint32(statusgrpc.Section_SECTION_APE_MANAGER))
 }
 const (
 	// StatusAPEManagerAccessDenied is a local status.Code value for
 	// ACCESS_DENIED ape manager failure.
 	StatusAPEManagerAccessDenied status.Code = iota
 )
 const (
 	// detailAccessDeniedDesc is a StatusAccessDenied detail ID for
 	// human-readable description.
 	detailAccessDeniedDesc = iota
 )
 // WriteAccessDeniedDesc writes human-readable description of StatusAccessDenied
 // into status.Status as a detail. The status must not be nil.
 //
 // Existing details are expected to be ID-unique, otherwise undefined behavior.
 func WriteAccessDeniedDesc(st *status.Status, desc string) {
 	var found bool
 	st.IterateDetails(func(d *status.Detail) bool {
 		if d.ID() == detailAccessDeniedDesc {
 			found = true
 			d.SetValue([]byte(desc))
 		}
 		return found
 	})
 	if !found {
 		var d status.Detail
 		d.SetID(detailAccessDeniedDesc)
 		d.SetValue([]byte(desc))
 		st.AppendDetails(d)
 	}
 }
 // ReadAccessDeniedDesc looks up for status detail with human-readable description
 // of StatusAccessDenied. Returns empty string if detail is missing.
 func ReadAccessDeniedDesc(st status.Status) (desc string) {
 	st.IterateDetails(func(d *status.Detail) bool {
 		if d.ID() == detailAccessDeniedDesc {
 			desc = string(d.Value())
 			return true
 		}
 		return false
 	})
 	return
 }
--- a/api/apemanager/status_test.go
+++ b/api/apemanager/status_test.go
@ -1,30 +0,0 @@
 package apemanager_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
 	statustest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/test"
 	"github.com/stretchr/testify/require"
 )
 func TestStatusCodes(t *testing.T) {
 	statustest.TestCodes(t, apemanager.LocalizeFailStatus, apemanager.GlobalizeFail,
 		apemanager.StatusAPEManagerAccessDenied, 5120,
 	)
 }
 func TestAccessDeniedDesc(t *testing.T) {
 	var st status.Status
 	require.Empty(t, apemanager.ReadAccessDeniedDesc(st))
 	const desc = "some description"
 	apemanager.WriteAccessDeniedDesc(&st, desc)
 	require.Equal(t, desc, apemanager.ReadAccessDeniedDesc(st))
 	apemanager.WriteAccessDeniedDesc(&st, desc+"1")
 	require.Equal(t, desc+"1", apemanager.ReadAccessDeniedDesc(st))
 }
--- a/api/apemanager/test/generate.go
+++ b/api/apemanager/test/generate.go
@ -1,143 +0,0 @@
 package apemanagertest
 import (
 	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager"
 	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
 )
 func generateChainID(empty bool) []byte {
 	if empty {
 		return []byte{}
 	}
 	return []byte("616c6c6f774f626a476574436e72")
 }
 func GenerateAddChainRequestBody(empty bool) *apemanager.AddChainRequestBody {
 	m := new(apemanager.AddChainRequestBody)
 	if !empty {
 		m.SetTarget(apetest.GenerateChainTarget(empty))
 		m.SetChain(apetest.GenerateRawChain(empty))
 	}
 	return m
 }
 func GenerateAddChainRequest(empty bool) *apemanager.AddChainRequest {
 	m := new(apemanager.AddChainRequest)
 	if !empty {
 		m.SetBody(GenerateAddChainRequestBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	}
 	return m
 }
 func GenerateAddChainResponseBody(empty bool) *apemanager.AddChainResponseBody {
 	m := new(apemanager.AddChainResponseBody)
 	if !empty {
 		m.SetChainID(generateChainID(empty))
 	}
 	return m
 }
 func GenerateAddChainResponse(empty bool) *apemanager.AddChainResponse {
 	m := new(apemanager.AddChainResponse)
 	if !empty {
 		m.SetBody(GenerateAddChainResponseBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	}
 	return m
 }
 func GenerateRemoveChainRequestBody(empty bool) *apemanager.RemoveChainRequestBody {
 	m := new(apemanager.RemoveChainRequestBody)
 	if !empty {
 		m.SetChainID(generateChainID(empty))
 		m.SetTarget(apetest.GenerateChainTarget(empty))
 	}
 	return m
 }
 func GenerateRemoveChainRequest(empty bool) *apemanager.RemoveChainRequest {
 	m := new(apemanager.RemoveChainRequest)
 	if !empty {
 		m.SetBody(GenerateRemoveChainRequestBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	}
 	return m
 }
 func GenerateRemoveChainResponseBody(_ bool) *apemanager.RemoveChainResponseBody {
 	return new(apemanager.RemoveChainResponseBody)
 }
 func GenerateRemoveChainResponse(empty bool) *apemanager.RemoveChainResponse {
 	m := new(apemanager.RemoveChainResponse)
 	if !empty {
 		m.SetBody(GenerateRemoveChainResponseBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	}
 	return m
 }
 func GenerateListChainsRequestBody(empty bool) *apemanager.ListChainsRequestBody {
 	m := new(apemanager.ListChainsRequestBody)
 	if !empty {
 		m.SetTarget(apetest.GenerateChainTarget(empty))
 	}
 	return m
 }
 func GenerateListChainsRequest(empty bool) *apemanager.ListChainsRequest {
 	m := new(apemanager.ListChainsRequest)
 	if !empty {
 		m.SetBody(GenerateListChainsRequestBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	}
 	return m
 }
 func GenerateListChainsResponseBody(empty bool) *apemanager.ListChainsResponseBody {
 	m := new(apemanager.ListChainsResponseBody)
 	if !empty {
 		m.SetChains(apetest.GenerateRawChains(empty, 10))
 	}
 	return m
 }
 func GenerateListChainsResponse(empty bool) *apemanager.ListChainsResponse {
 	m := new(apemanager.ListChainsResponse)
 	if !empty {
 		m.SetBody(GenerateListChainsResponseBody(empty))
 		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	}
 	return m
 }
--- a/api/apemanager/types.go
+++ b/api/apemanager/types.go
@ -1,226 +0,0 @@
 package apemanager
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
 )
 type AddChainRequest struct {
 	body *AddChainRequestBody
 	session.RequestHeaders
 }
 func (r *AddChainRequest) SetBody(body *AddChainRequestBody) {
 	r.body = body
 }
 func (r *AddChainRequest) GetBody() *AddChainRequestBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type AddChainRequestBody struct {
 	target *ape.ChainTarget
 	chain *ape.Chain
 }
 func (rb *AddChainRequestBody) SetTarget(target *ape.ChainTarget) {
 	rb.target = target
 }
 func (rb *AddChainRequestBody) GetTarget() *ape.ChainTarget {
 	if rb == nil {
 		return nil
 	}
 	return rb.target
 }
 func (rb *AddChainRequestBody) SetChain(chain *ape.Chain) {
 	rb.chain = chain
 }
 func (rb *AddChainRequestBody) GetChain() *ape.Chain {
 	if rb == nil {
 		return nil
 	}
 	return rb.chain
 }
 type AddChainResponse struct {
 	body *AddChainResponseBody
 	session.ResponseHeaders
 }
 func (r *AddChainResponse) SetBody(body *AddChainResponseBody) {
 	r.body = body
 }
 func (r *AddChainResponse) GetBody() *AddChainResponseBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type AddChainResponseBody struct {
 	chainID []byte
 }
 func (rb *AddChainResponseBody) SetChainID(chainID []byte) {
 	rb.chainID = chainID
 }
 func (rb *AddChainResponseBody) GetChainID() []byte {
 	if rb == nil {
 		return nil
 	}
 	return rb.chainID
 }
 type RemoveChainRequest struct {
 	body *RemoveChainRequestBody
 	session.RequestHeaders
 }
 func (r *RemoveChainRequest) SetBody(body *RemoveChainRequestBody) {
 	r.body = body
 }
 func (r *RemoveChainRequest) GetBody() *RemoveChainRequestBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type RemoveChainRequestBody struct {
 	target *ape.ChainTarget
 	chainID []byte
 }
 func (rb *RemoveChainRequestBody) SetTarget(target *ape.ChainTarget) {
 	rb.target = target
 }
 func (rb *RemoveChainRequestBody) GetTarget() *ape.ChainTarget {
 	if rb == nil {
 		return nil
 	}
 	return rb.target
 }
 func (rb *RemoveChainRequestBody) SetChainID(chainID []byte) {
 	rb.chainID = chainID
 }
 func (rb *RemoveChainRequestBody) GetChainID() []byte {
 	if rb == nil {
 		return nil
 	}
 	return rb.chainID
 }
 type RemoveChainResponse struct {
 	body *RemoveChainResponseBody
 	session.ResponseHeaders
 }
 type RemoveChainResponseBody struct{}
 func (r *RemoveChainResponse) SetBody(body *RemoveChainResponseBody) {
 	r.body = body
 }
 func (r *RemoveChainResponse) GetBody() *RemoveChainResponseBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type ListChainsRequest struct {
 	body *ListChainsRequestBody
 	session.RequestHeaders
 }
 func (r *ListChainsRequest) SetBody(body *ListChainsRequestBody) {
 	r.body = body
 }
 func (r *ListChainsRequest) GetBody() *ListChainsRequestBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type ListChainsRequestBody struct {
 	target *ape.ChainTarget
 }
 func (rb *ListChainsRequestBody) SetTarget(target *ape.ChainTarget) {
 	rb.target = target
 }
 func (rb *ListChainsRequestBody) GetTarget() *ape.ChainTarget {
 	if rb == nil {
 		return nil
 	}
 	return rb.target
 }
 type ListChainsResponse struct {
 	body *ListChainsResponseBody
 	session.ResponseHeaders
 }
 func (r *ListChainsResponse) SetBody(body *ListChainsResponseBody) {
 	r.body = body
 }
 func (r *ListChainsResponse) GetBody() *ListChainsResponseBody {
 	if r == nil {
 		return nil
 	}
 	return r.body
 }
 type ListChainsResponseBody struct {
 	chains []*ape.Chain
 	session.RequestHeaders
 }
 func (r *ListChainsResponseBody) SetChains(chains []*ape.Chain) {
 	r.chains = chains
 }
 func (r *ListChainsResponseBody) GetChains() []*ape.Chain {
 	if r == nil {
 		return nil
 	}
 	return r.chains
 }
--- a/api/container/attributes.go
+++ b/api/container/attributes.go
@ -1,90 +0,0 @@
 package container
 // SysAttributePrefix is a prefix of key to system attribute.
 const SysAttributePrefix = "__SYSTEM__"
 const (
 	// SysAttributeName is a string of human-friendly container name registered as the domain in NNS contract.
 	SysAttributeName = SysAttributePrefix + "NAME"
 	// SysAttributeZone is a string of zone for container name.
 	SysAttributeZone = SysAttributePrefix + "ZONE"
 	// SysAttributeHomomorphicHashing is a container's homomorphic hashing state.
 	SysAttributeHomomorphicHashing = SysAttributePrefix + "DISABLE_HOMOMORPHIC_HASHING"
 )
 // SysAttributePrefixNeoFS is a prefix of key to system attribute.
 // Deprecated: use SysAttributePrefix.
 const SysAttributePrefixNeoFS = "__NEOFS__"
 const (
 	// SysAttributeNameNeoFS is a string of human-friendly container name registered as the domain in NNS contract.
 	// Deprecated: use SysAttributeName.
 	SysAttributeNameNeoFS = SysAttributePrefixNeoFS + "NAME"
 	// SysAttributeZoneNeoFS is a string of zone for container name.
 	// Deprecated: use SysAttributeZone.
 	SysAttributeZoneNeoFS = SysAttributePrefixNeoFS + "ZONE"
 	// SysAttributeHomomorphicHashingNeoFS is a container's homomorphic hashing state.
 	// Deprecated: use SysAttributeHomomorphicHashing.
 	SysAttributeHomomorphicHashingNeoFS = SysAttributePrefixNeoFS + "DISABLE_HOMOMORPHIC_HASHING"
 )
 // SysAttributeZoneDefault is a default value for SysAttributeZone attribute.
 const SysAttributeZoneDefault = "container"
 const disabledHomomorphicHashingValue = "true"
 // HomomorphicHashingState returns container's homomorphic
 // hashing state:
 //   - true if hashing is enabled;
 //   - false if hashing is disabled.
 //
 // All container's attributes must be unique, otherwise behavior
 // is undefined.
 //
 // See also SetHomomorphicHashingState.
 func (c Container) HomomorphicHashingState() bool {
 	for i := range c.attr {
 		if c.attr[i].GetKey() == SysAttributeHomomorphicHashing || c.attr[i].GetKey() == SysAttributeHomomorphicHashingNeoFS {
 			return c.attr[i].GetValue() != disabledHomomorphicHashingValue
 		}
 	}
 	return true
 }
 // SetHomomorphicHashingState sets homomorphic hashing state for
 // container.
 //
 // All container's attributes must be unique, otherwise behavior
 // is undefined.
 //
 // See also HomomorphicHashingState.
 func (c *Container) SetHomomorphicHashingState(enable bool) {
 	for i := range c.attr {
 		if c.attr[i].GetKey() == SysAttributeHomomorphicHashing || c.attr[i].GetKey() == SysAttributeHomomorphicHashingNeoFS {
 			if enable {
 				// approach without allocation/waste
 				// coping works since the attributes
 				// order is not important
 				c.attr[i] = c.attr[len(c.attr)-1]
 				c.attr = c.attr[:len(c.attr)-1]
 			} else {
 				c.attr[i].SetValue(disabledHomomorphicHashingValue)
 			}
 			return
 		}
 	}
 	if !enable {
 		attr := Attribute{}
 		attr.SetKey(SysAttributeHomomorphicHashing)
 		attr.SetValue(disabledHomomorphicHashingValue)
 		c.attr = append(c.attr, attr)
 	}
 }
--- a/api/container/attributes_test.go
+++ b/api/container/attributes_test.go
@ -1,59 +0,0 @@
 package container_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
 	containertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/test"
 	"github.com/stretchr/testify/require"
 )
 func TestContainer_HomomorphicHashingDisabled(t *testing.T) {
 	cnr := containertest.GenerateContainer(false)
 	t.Run("defaults", func(t *testing.T) {
 		require.True(t, cnr.HomomorphicHashingState())
 	})
 	t.Run("disabled", func(t *testing.T) {
 		attr := container.Attribute{}
 		attr.SetKey(container.SysAttributeHomomorphicHashing)
 		attr.SetValue("NOT_true")
 		cnr.SetAttributes(append(cnr.GetAttributes(), attr))
 		require.True(t, cnr.HomomorphicHashingState())
 		attr.SetValue("true")
 		cnr.SetAttributes([]container.Attribute{attr})
 		require.False(t, cnr.HomomorphicHashingState())
 	})
 }
 func TestContainer_SetHomomorphicHashingState(t *testing.T) {
 	cnr := containertest.GenerateContainer(false)
 	attrs := cnr.GetAttributes()
 	attrLen := len(attrs)
 	cnr.SetHomomorphicHashingState(true)
 	// enabling hashing should not add any new attributes
 	require.Equal(t, attrLen, len(cnr.GetAttributes()))
 	require.True(t, cnr.HomomorphicHashingState())
 	cnr.SetHomomorphicHashingState(false)
 	// disabling hashing should add exactly one attribute
 	require.Equal(t, attrLen+1, len(cnr.GetAttributes()))
 	require.False(t, cnr.HomomorphicHashingState())
 	cnr.SetHomomorphicHashingState(true)
 	// enabling hashing should remove 1 attribute if
 	// hashing was disabled before
 	require.Equal(t, attrLen, len(cnr.GetAttributes()))
 	require.True(t, cnr.HomomorphicHashingState())
 	// hashing operations should not change any other attributes
 	require.ElementsMatch(t, attrs, cnr.GetAttributes())
 }
--- a/api/container/convert.go
+++ b/api/container/convert.go
@ -1,764 +0,0 @@
 package container
 import (
 	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
 	netmapGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
 	sessionGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/grpc"
 )
 func (a *Attribute) ToGRPCMessage() grpc.Message {
 	var m *container.Container_Attribute
 	if a != nil {
 		m = new(container.Container_Attribute)
 		m.SetKey(a.key)
 		m.SetValue(a.val)
 	}
 	return m
 }
 func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.Container_Attribute)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	a.key = v.GetKey()
 	a.val = v.GetValue()
 	return nil
 }
 func AttributesToGRPC(xs []Attribute) (res []container.Container_Attribute) {
 	if xs != nil {
 		res = make([]container.Container_Attribute, 0, len(xs))
 		for i := range xs {
 			res = append(res, *xs[i].ToGRPCMessage().(*container.Container_Attribute))
 		}
 	}
 	return
 }
 func AttributesFromGRPC(xs []container.Container_Attribute) (res []Attribute, err error) {
 	if xs != nil {
 		res = make([]Attribute, len(xs))
 		for i := range xs {
 			err = res[i].FromGRPCMessage(&xs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (c *Container) ToGRPCMessage() grpc.Message {
 	var m *container.Container
 	if c != nil {
 		m = new(container.Container)
 		m.SetVersion(c.version.ToGRPCMessage().(*refsGRPC.Version))
 		m.SetOwnerId(c.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
 		m.SetPlacementPolicy(c.policy.ToGRPCMessage().(*netmapGRPC.PlacementPolicy))
 		m.SetAttributes(AttributesToGRPC(c.attr))
 		m.SetBasicAcl(c.basicACL)
 		m.SetNonce(c.nonce)
 	}
 	return m
 }
 func (c *Container) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.Container)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	version := v.GetVersion()
 	if version == nil {
 		c.version = nil
 	} else {
 		if c.version == nil {
 			c.version = new(refs.Version)
 		}
 		err = c.version.FromGRPCMessage(version)
 		if err != nil {
 			return err
 		}
 	}
 	ownerID := v.GetOwnerId()
 	if ownerID == nil {
 		c.ownerID = nil
 	} else {
 		if c.ownerID == nil {
 			c.ownerID = new(refs.OwnerID)
 		}
 		err = c.ownerID.FromGRPCMessage(ownerID)
 		if err != nil {
 			return err
 		}
 	}
 	policy := v.GetPlacementPolicy()
 	if policy == nil {
 		c.policy = nil
 	} else {
 		if c.policy == nil {
 			c.policy = new(netmap.PlacementPolicy)
 		}
 		err = c.policy.FromGRPCMessage(policy)
 		if err != nil {
 			return err
 		}
 	}
 	c.attr, err = AttributesFromGRPC(v.GetAttributes())
 	if err != nil {
 		return err
 	}
 	c.basicACL = v.GetBasicAcl()
 	c.nonce = v.GetNonce()
 	return nil
 }
 func toSignatureRFC6979(s *refs.Signature) *refsGRPC.SignatureRFC6979 {
 	var res *refsGRPC.SignatureRFC6979
 	if s != nil {
 		res = new(refsGRPC.SignatureRFC6979)
 		res.SetKey(s.GetKey())
 		res.SetSign(s.GetSign())
 	}
 	return res
 }
 func (r *PutRequestBody) ToGRPCMessage() grpc.Message {
 	var m *container.PutRequest_Body
 	if r != nil {
 		m = new(container.PutRequest_Body)
 		m.SetContainer(r.cnr.ToGRPCMessage().(*container.Container))
 		m.SetSignature(toSignatureRFC6979(r.sig))
 	}
 	return m
 }
 func (r *PutRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.PutRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cnr := v.GetContainer()
 	if cnr == nil {
 		r.cnr = nil
 	} else {
 		if r.cnr == nil {
 			r.cnr = new(Container)
 		}
 		err = r.cnr.FromGRPCMessage(cnr)
 		if err != nil {
 			return err
 		}
 	}
 	sig := v.GetSignature()
 	if sig == nil {
 		r.sig = nil
 	} else {
 		if r.sig == nil {
 			r.sig = new(refs.Signature)
 		}
 		r.sig.SetKey(sig.GetKey())
 		r.sig.SetSign(sig.GetSign())
 	}
 	return err
 }
 func (r *PutRequest) ToGRPCMessage() grpc.Message {
 	var m *container.PutRequest
 	if r != nil {
 		m = new(container.PutRequest)
 		m.SetBody(r.body.ToGRPCMessage().(*container.PutRequest_Body))
 		r.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *PutRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.PutRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(PutRequestBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.RequestHeaders.FromMessage(v)
 }
 func (r *PutResponseBody) ToGRPCMessage() grpc.Message {
 	var m *container.PutResponse_Body
 	if r != nil {
 		m = new(container.PutResponse_Body)
 		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
 	}
 	return m
 }
 func (r *PutResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.PutResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cid := v.GetContainerId()
 	if cid == nil {
 		r.cid = nil
 	} else {
 		if r.cid == nil {
 			r.cid = new(refs.ContainerID)
 		}
 		err = r.cid.FromGRPCMessage(cid)
 	}
 	return err
 }
 func (r *PutResponse) ToGRPCMessage() grpc.Message {
 	var m *container.PutResponse
 	if r != nil {
 		m = new(container.PutResponse)
 		m.SetBody(r.body.ToGRPCMessage().(*container.PutResponse_Body))
 		r.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *PutResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.PutResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(PutResponseBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.ResponseHeaders.FromMessage(v)
 }
 func (r *GetRequestBody) ToGRPCMessage() grpc.Message {
 	var m *container.GetRequest_Body
 	if r != nil {
 		m = new(container.GetRequest_Body)
 		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
 	}
 	return m
 }
 func (r *GetRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.GetRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cid := v.GetContainerId()
 	if cid == nil {
 		r.cid = nil
 	} else {
 		if r.cid == nil {
 			r.cid = new(refs.ContainerID)
 		}
 		err = r.cid.FromGRPCMessage(cid)
 	}
 	return err
 }
 func (r *GetRequest) ToGRPCMessage() grpc.Message {
 	var m *container.GetRequest
 	if r != nil {
 		m = new(container.GetRequest)
 		m.SetBody(r.body.ToGRPCMessage().(*container.GetRequest_Body))
 		r.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *GetRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.GetRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(GetRequestBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.RequestHeaders.FromMessage(v)
 }
 func (r *GetResponseBody) ToGRPCMessage() grpc.Message {
 	var m *container.GetResponse_Body
 	if r != nil {
 		m = new(container.GetResponse_Body)
 		m.SetContainer(r.cnr.ToGRPCMessage().(*container.Container))
 		m.SetSessionToken(r.token.ToGRPCMessage().(*sessionGRPC.SessionToken))
 		m.SetSignature(toSignatureRFC6979(r.sig))
 	}
 	return m
 }
 func (r *GetResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.GetResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cnr := v.GetContainer()
 	if cnr == nil {
 		r.cnr = nil
 	} else {
 		if r.cnr == nil {
 			r.cnr = new(Container)
 		}
 		err = r.cnr.FromGRPCMessage(cnr)
 	}
 	sig := v.GetSignature()
 	if sig == nil {
 		r.sig = nil
 	} else {
 		if r.sig == nil {
 			r.sig = new(refs.Signature)
 		}
 		r.sig.SetKey(sig.GetKey())
 		r.sig.SetSign(sig.GetSign())
 	}
 	token := v.GetSessionToken()
 	if token == nil {
 		r.token = nil
 	} else {
 		if r.token == nil {
 			r.token = new(session.Token)
 		}
 		err = r.token.FromGRPCMessage(token)
 	}
 	return err
 }
 func (r *GetResponse) ToGRPCMessage() grpc.Message {
 	var m *container.GetResponse
 	if r != nil {
 		m = new(container.GetResponse)
 		m.SetBody(r.body.ToGRPCMessage().(*container.GetResponse_Body))
 		r.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *GetResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.GetResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(GetResponseBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.ResponseHeaders.FromMessage(v)
 }
 func (r *DeleteRequestBody) ToGRPCMessage() grpc.Message {
 	var m *container.DeleteRequest_Body
 	if r != nil {
 		m = new(container.DeleteRequest_Body)
 		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
 		m.SetSignature(toSignatureRFC6979(r.sig))
 	}
 	return m
 }
 func (r *DeleteRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.DeleteRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	cid := v.GetContainerId()
 	if cid == nil {
 		r.cid = nil
 	} else {
 		if r.cid == nil {
 			r.cid = new(refs.ContainerID)
 		}
 		err = r.cid.FromGRPCMessage(cid)
 		if err != nil {
 			return err
 		}
 	}
 	sig := v.GetSignature()
 	if sig == nil {
 		r.sig = nil
 	} else {
 		if r.sig == nil {
 			r.sig = new(refs.Signature)
 		}
 		r.sig.SetKey(sig.GetKey())
 		r.sig.SetSign(sig.GetSign())
 	}
 	return err
 }
 func (r *DeleteRequest) ToGRPCMessage() grpc.Message {
 	var m *container.DeleteRequest
 	if r != nil {
 		m = new(container.DeleteRequest)
 		m.SetBody(r.body.ToGRPCMessage().(*container.DeleteRequest_Body))
 		r.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *DeleteRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.DeleteRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(DeleteRequestBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.RequestHeaders.FromMessage(v)
 }
 func (r *DeleteResponseBody) ToGRPCMessage() grpc.Message {
 	var m *container.DeleteResponse_Body
 	if r != nil {
 		m = new(container.DeleteResponse_Body)
 	}
 	return m
 }
 func (r *DeleteResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.DeleteResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	return nil
 }
 func (r *DeleteResponse) ToGRPCMessage() grpc.Message {
 	var m *container.DeleteResponse
 	if r != nil {
 		m = new(container.DeleteResponse)
 		m.SetBody(r.body.ToGRPCMessage().(*container.DeleteResponse_Body))
 		r.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *DeleteResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.DeleteResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(DeleteResponseBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.ResponseHeaders.FromMessage(v)
 }
 func (r *ListRequestBody) ToGRPCMessage() grpc.Message {
 	var m *container.ListRequest_Body
 	if r != nil {
 		m = new(container.ListRequest_Body)
 		m.SetOwnerId(r.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
 	}
 	return m
 }
 func (r *ListRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.ListRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	ownerID := v.GetOwnerId()
 	if ownerID == nil {
 		r.ownerID = nil
 	} else {
 		if r.ownerID == nil {
 			r.ownerID = new(refs.OwnerID)
 		}
 		err = r.ownerID.FromGRPCMessage(ownerID)
 	}
 	return err
 }
 func (r *ListRequest) ToGRPCMessage() grpc.Message {
 	var m *container.ListRequest
 	if r != nil {
 		m = new(container.ListRequest)
 		m.SetBody(r.body.ToGRPCMessage().(*container.ListRequest_Body))
 		r.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *ListRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.ListRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(ListRequestBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.RequestHeaders.FromMessage(v)
 }
 func (r *ListResponseBody) ToGRPCMessage() grpc.Message {
 	var m *container.ListResponse_Body
 	if r != nil {
 		m = new(container.ListResponse_Body)
 		m.SetContainerIds(refs.ContainerIDsToGRPCMessage(r.cidList))
 	}
 	return m
 }
 func (r *ListResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.ListResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	r.cidList, err = refs.ContainerIDsFromGRPCMessage(v.GetContainerIds())
 	return err
 }
 func (r *ListResponse) ToGRPCMessage() grpc.Message {
 	var m *container.ListResponse
 	if r != nil {
 		m = new(container.ListResponse)
 		m.SetBody(r.body.ToGRPCMessage().(*container.ListResponse_Body))
 		r.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (r *ListResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*container.ListResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		r.body = nil
 	} else {
 		if r.body == nil {
 			r.body = new(ListResponseBody)
 		}
 		err = r.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return r.ResponseHeaders.FromMessage(v)
 }
--- a/api/container/grpc/service_frostfs.pb.go
+++ b/api/container/grpc/service_frostfs.pb.go
--- a/api/container/grpc/service_frostfs_fuzz.go
+++ b/api/container/grpc/service_frostfs_fuzz.go
@ -1,159 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package container
 func DoFuzzProtoPutRequest(data []byte) int {
 	msg := new(PutRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONPutRequest(data []byte) int {
 	msg := new(PutRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoPutResponse(data []byte) int {
 	msg := new(PutResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONPutResponse(data []byte) int {
 	msg := new(PutResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoDeleteRequest(data []byte) int {
 	msg := new(DeleteRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONDeleteRequest(data []byte) int {
 	msg := new(DeleteRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoDeleteResponse(data []byte) int {
 	msg := new(DeleteResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONDeleteResponse(data []byte) int {
 	msg := new(DeleteResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoGetRequest(data []byte) int {
 	msg := new(GetRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONGetRequest(data []byte) int {
 	msg := new(GetRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoGetResponse(data []byte) int {
 	msg := new(GetResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONGetResponse(data []byte) int {
 	msg := new(GetResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoListRequest(data []byte) int {
 	msg := new(ListRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONListRequest(data []byte) int {
 	msg := new(ListRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoListResponse(data []byte) int {
 	msg := new(ListResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONListResponse(data []byte) int {
 	msg := new(ListResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/container/grpc/service_frostfs_test.go
+++ b/api/container/grpc/service_frostfs_test.go
@ -1,91 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package container
 import (
 	testing "testing"
 )
 func FuzzProtoPutRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoPutRequest(data)
 	})
 }
 func FuzzJSONPutRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONPutRequest(data)
 	})
 }
 func FuzzProtoPutResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoPutResponse(data)
 	})
 }
 func FuzzJSONPutResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONPutResponse(data)
 	})
 }
 func FuzzProtoDeleteRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoDeleteRequest(data)
 	})
 }
 func FuzzJSONDeleteRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONDeleteRequest(data)
 	})
 }
 func FuzzProtoDeleteResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoDeleteResponse(data)
 	})
 }
 func FuzzJSONDeleteResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONDeleteResponse(data)
 	})
 }
 func FuzzProtoGetRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoGetRequest(data)
 	})
 }
 func FuzzJSONGetRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONGetRequest(data)
 	})
 }
 func FuzzProtoGetResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoGetResponse(data)
 	})
 }
 func FuzzJSONGetResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONGetResponse(data)
 	})
 }
 func FuzzProtoListRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoListRequest(data)
 	})
 }
 func FuzzJSONListRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONListRequest(data)
 	})
 }
 func FuzzProtoListResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoListResponse(data)
 	})
 }
 func FuzzJSONListResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONListResponse(data)
 	})
 }
--- a/api/container/grpc/service_grpc.pb.go
+++ b/api/container/grpc/service_grpc.pb.go
@ -1,298 +0,0 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.3.0
 // - protoc             v5.27.2
 // source: api/container/grpc/service.proto
 package container
 import (
 	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 )
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
 // Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 const (
 	ContainerService_Put_FullMethodName    = "/neo.fs.v2.container.ContainerService/Put"
 	ContainerService_Delete_FullMethodName = "/neo.fs.v2.container.ContainerService/Delete"
 	ContainerService_Get_FullMethodName    = "/neo.fs.v2.container.ContainerService/Get"
 	ContainerService_List_FullMethodName   = "/neo.fs.v2.container.ContainerService/List"
 )
 // ContainerServiceClient is the client API for ContainerService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ContainerServiceClient interface {
 	// `Put` invokes `Container` smart contract's `Put` method and returns
 	// response immediately. After a new block is issued in sidechain, request is
 	// verified by Inner Ring nodes. After one more block in sidechain, the
 	// container is added into smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   request to save the container has been sent to the sidechain;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container create access denied.
 	Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error)
 	// `Delete` invokes `Container` smart contract's `Delete` method and returns
 	// response immediately. After a new block is issued in sidechain, request is
 	// verified by Inner Ring nodes. After one more block in sidechain, the
 	// container is added into smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   request to remove the container has been sent to the sidechain;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container delete access denied.
 	Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
 	// Returns container structure from `Container` smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   container has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   requested container not found;
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   access to container is denied.
 	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
 	// Returns all owner's containers from 'Container` smart contract' storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   container list has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container list access denied.
 	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
 }
 type containerServiceClient struct {
 	cc grpc.ClientConnInterface
 }
 func NewContainerServiceClient(cc grpc.ClientConnInterface) ContainerServiceClient {
 	return &containerServiceClient{cc}
 }
 func (c *containerServiceClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) {
 	out := new(PutResponse)
 	err := c.cc.Invoke(ctx, ContainerService_Put_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *containerServiceClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
 	out := new(DeleteResponse)
 	err := c.cc.Invoke(ctx, ContainerService_Delete_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *containerServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
 	out := new(GetResponse)
 	err := c.cc.Invoke(ctx, ContainerService_Get_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *containerServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
 	out := new(ListResponse)
 	err := c.cc.Invoke(ctx, ContainerService_List_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // ContainerServiceServer is the server API for ContainerService service.
 // All implementations should embed UnimplementedContainerServiceServer
 // for forward compatibility
 type ContainerServiceServer interface {
 	// `Put` invokes `Container` smart contract's `Put` method and returns
 	// response immediately. After a new block is issued in sidechain, request is
 	// verified by Inner Ring nodes. After one more block in sidechain, the
 	// container is added into smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   request to save the container has been sent to the sidechain;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container create access denied.
 	Put(context.Context, *PutRequest) (*PutResponse, error)
 	// `Delete` invokes `Container` smart contract's `Delete` method and returns
 	// response immediately. After a new block is issued in sidechain, request is
 	// verified by Inner Ring nodes. After one more block in sidechain, the
 	// container is added into smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   request to remove the container has been sent to the sidechain;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container delete access denied.
 	Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
 	// Returns container structure from `Container` smart contract storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   container has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_NOT_FOUND** (3072, SECTION_CONTAINER): \
 	//   requested container not found;
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   access to container is denied.
 	Get(context.Context, *GetRequest) (*GetResponse, error)
 	// Returns all owner's containers from 'Container` smart contract' storage.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS): \
 	//   container list has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON);
 	// - **CONTAINER_ACCESS_DENIED** (3074, SECTION_CONTAINER): \
 	//   container list access denied.
 	List(context.Context, *ListRequest) (*ListResponse, error)
 }
 // UnimplementedContainerServiceServer should be embedded to have forward compatible implementations.
 type UnimplementedContainerServiceServer struct {
 }
 func (UnimplementedContainerServiceServer) Put(context.Context, *PutRequest) (*PutResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Put not implemented")
 }
 func (UnimplementedContainerServiceServer) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
 }
 func (UnimplementedContainerServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
 }
 func (UnimplementedContainerServiceServer) List(context.Context, *ListRequest) (*ListResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
 }
 // UnsafeContainerServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to ContainerServiceServer will
 // result in compilation errors.
 type UnsafeContainerServiceServer interface {
 	mustEmbedUnimplementedContainerServiceServer()
 }
 func RegisterContainerServiceServer(s grpc.ServiceRegistrar, srv ContainerServiceServer) {
 	s.RegisterService(&ContainerService_ServiceDesc, srv)
 }
 func _ContainerService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(PutRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(ContainerServiceServer).Put(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: ContainerService_Put_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ContainerServiceServer).Put(ctx, req.(*PutRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _ContainerService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DeleteRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(ContainerServiceServer).Delete(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: ContainerService_Delete_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ContainerServiceServer).Delete(ctx, req.(*DeleteRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _ContainerService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(ContainerServiceServer).Get(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: ContainerService_Get_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ContainerServiceServer).Get(ctx, req.(*GetRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _ContainerService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ListRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(ContainerServiceServer).List(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: ContainerService_List_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ContainerServiceServer).List(ctx, req.(*ListRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // ContainerService_ServiceDesc is the grpc.ServiceDesc for ContainerService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var ContainerService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "neo.fs.v2.container.ContainerService",
 	HandlerType: (*ContainerServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "Put",
 			Handler:    _ContainerService_Put_Handler,
 		},
 		{
 			MethodName: "Delete",
 			Handler:    _ContainerService_Delete_Handler,
 		},
 		{
 			MethodName: "Get",
 			Handler:    _ContainerService_Get_Handler,
 		},
 		{
 			MethodName: "List",
 			Handler:    _ContainerService_List_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "api/container/grpc/service.proto",
 }
--- a/api/container/grpc/types_frostfs.pb.go
+++ b/api/container/grpc/types_frostfs.pb.go
@ -1,554 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package container
 import (
 	json "encoding/json"
 	fmt "fmt"
 	grpc1 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
 	grpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 	strconv "strconv"
 )
 type Container_Attribute struct {
 	Key   string `json:"key"`
 	Value string `json:"value"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Container_Attribute)(nil)
 	_ encoding.ProtoUnmarshaler = (*Container_Attribute)(nil)
 	_ json.Marshaler            = (*Container_Attribute)(nil)
 	_ json.Unmarshaler          = (*Container_Attribute)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Container_Attribute) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.StringSize(1, x.Key)
 	size += proto.StringSize(2, x.Value)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Container_Attribute) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Container_Attribute) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if len(x.Key) != 0 {
 		mm.AppendString(1, x.Key)
 	}
 	if len(x.Value) != 0 {
 		mm.AppendString(2, x.Value)
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Container_Attribute) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Container_Attribute")
 		}
 		switch fc.FieldNum {
 		case 1: // Key
 			data, ok := fc.String()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Key")
 			}
 			x.Key = data
 		case 2: // Value
 			data, ok := fc.String()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Value")
 			}
 			x.Value = data
 		}
 	}
 	return nil
 }
 func (x *Container_Attribute) GetKey() string {
 	if x != nil {
 		return x.Key
 	}
 	return ""
 }
 func (x *Container_Attribute) SetKey(v string) {
 	x.Key = v
 }
 func (x *Container_Attribute) GetValue() string {
 	if x != nil {
 		return x.Value
 	}
 	return ""
 }
 func (x *Container_Attribute) SetValue(v string) {
 	x.Value = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Container_Attribute) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Container_Attribute) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"key\":"
 		out.RawString(prefix)
 		out.String(x.Key)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"value\":"
 		out.RawString(prefix)
 		out.String(x.Value)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Container_Attribute) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Container_Attribute) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "key":
 			{
 				var f string
 				f = in.String()
 				x.Key = f
 			}
 		case "value":
 			{
 				var f string
 				f = in.String()
 				x.Value = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
 type Container struct {
 	Version         *grpc.Version          `json:"version"`
 	OwnerId         *grpc.OwnerID          `json:"ownerID"`
 	Nonce           []byte                 `json:"nonce"`
 	BasicAcl        uint32                 `json:"basicACL"`
 	Attributes      []Container_Attribute  `json:"attributes"`
 	PlacementPolicy *grpc1.PlacementPolicy `json:"placementPolicy"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Container)(nil)
 	_ encoding.ProtoUnmarshaler = (*Container)(nil)
 	_ json.Marshaler            = (*Container)(nil)
 	_ json.Unmarshaler          = (*Container)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Container) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	size += proto.NestedStructureSize(1, x.Version)
 	size += proto.NestedStructureSize(2, x.OwnerId)
 	size += proto.BytesSize(3, x.Nonce)
 	size += proto.UInt32Size(4, x.BasicAcl)
 	for i := range x.Attributes {
 		size += proto.NestedStructureSizeUnchecked(5, &x.Attributes[i])
 	}
 	size += proto.NestedStructureSize(6, x.PlacementPolicy)
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Container) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Container) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	if x.Version != nil {
 		x.Version.EmitProtobuf(mm.AppendMessage(1))
 	}
 	if x.OwnerId != nil {
 		x.OwnerId.EmitProtobuf(mm.AppendMessage(2))
 	}
 	if len(x.Nonce) != 0 {
 		mm.AppendBytes(3, x.Nonce)
 	}
 	if x.BasicAcl != 0 {
 		mm.AppendUint32(4, x.BasicAcl)
 	}
 	for i := range x.Attributes {
 		x.Attributes[i].EmitProtobuf(mm.AppendMessage(5))
 	}
 	if x.PlacementPolicy != nil {
 		x.PlacementPolicy.EmitProtobuf(mm.AppendMessage(6))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Container) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Container")
 		}
 		switch fc.FieldNum {
 		case 1: // Version
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Version")
 			}
 			x.Version = new(grpc.Version)
 			if err := x.Version.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 2: // OwnerId
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "OwnerId")
 			}
 			x.OwnerId = new(grpc.OwnerID)
 			if err := x.OwnerId.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 3: // Nonce
 			data, ok := fc.Bytes()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Nonce")
 			}
 			x.Nonce = data
 		case 4: // BasicAcl
 			data, ok := fc.Uint32()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "BasicAcl")
 			}
 			x.BasicAcl = data
 		case 5: // Attributes
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Attributes")
 			}
 			x.Attributes = append(x.Attributes, Container_Attribute{})
 			ff := &x.Attributes[len(x.Attributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		case 6: // PlacementPolicy
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "PlacementPolicy")
 			}
 			x.PlacementPolicy = new(grpc1.PlacementPolicy)
 			if err := x.PlacementPolicy.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *Container) GetVersion() *grpc.Version {
 	if x != nil {
 		return x.Version
 	}
 	return nil
 }
 func (x *Container) SetVersion(v *grpc.Version) {
 	x.Version = v
 }
 func (x *Container) GetOwnerId() *grpc.OwnerID {
 	if x != nil {
 		return x.OwnerId
 	}
 	return nil
 }
 func (x *Container) SetOwnerId(v *grpc.OwnerID) {
 	x.OwnerId = v
 }
 func (x *Container) GetNonce() []byte {
 	if x != nil {
 		return x.Nonce
 	}
 	return nil
 }
 func (x *Container) SetNonce(v []byte) {
 	x.Nonce = v
 }
 func (x *Container) GetBasicAcl() uint32 {
 	if x != nil {
 		return x.BasicAcl
 	}
 	return 0
 }
 func (x *Container) SetBasicAcl(v uint32) {
 	x.BasicAcl = v
 }
 func (x *Container) GetAttributes() []Container_Attribute {
 	if x != nil {
 		return x.Attributes
 	}
 	return nil
 }
 func (x *Container) SetAttributes(v []Container_Attribute) {
 	x.Attributes = v
 }
 func (x *Container) GetPlacementPolicy() *grpc1.PlacementPolicy {
 	if x != nil {
 		return x.PlacementPolicy
 	}
 	return nil
 }
 func (x *Container) SetPlacementPolicy(v *grpc1.PlacementPolicy) {
 	x.PlacementPolicy = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Container) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Container) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"version\":"
 		out.RawString(prefix)
 		x.Version.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"ownerID\":"
 		out.RawString(prefix)
 		x.OwnerId.MarshalEasyJSON(out)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"nonce\":"
 		out.RawString(prefix)
 		if x.Nonce != nil {
 			out.Base64Bytes(x.Nonce)
 		} else {
 			out.String("")
 		}
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"basicACL\":"
 		out.RawString(prefix)
 		out.Uint32(x.BasicAcl)
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"attributes\":"
 		out.RawString(prefix)
 		out.RawByte('[')
 		for i := range x.Attributes {
 			if i != 0 {
 				out.RawByte(',')
 			}
 			x.Attributes[i].MarshalEasyJSON(out)
 		}
 		out.RawByte(']')
 	}
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"placementPolicy\":"
 		out.RawString(prefix)
 		x.PlacementPolicy.MarshalEasyJSON(out)
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Container) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Container) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "version":
 			{
 				var f *grpc.Version
 				f = new(grpc.Version)
 				f.UnmarshalEasyJSON(in)
 				x.Version = f
 			}
 		case "ownerID":
 			{
 				var f *grpc.OwnerID
 				f = new(grpc.OwnerID)
 				f.UnmarshalEasyJSON(in)
 				x.OwnerId = f
 			}
 		case "nonce":
 			{
 				var f []byte
 				{
 					tmp := in.Bytes()
 					if len(tmp) == 0 {
 						tmp = nil
 					}
 					f = tmp
 				}
 				x.Nonce = f
 			}
 		case "basicACL":
 			{
 				var f uint32
 				r := in.JsonNumber()
 				n := r.String()
 				v, err := strconv.ParseUint(n, 10, 32)
 				if err != nil {
 					in.AddError(err)
 					return
 				}
 				pv := uint32(v)
 				f = pv
 				x.BasicAcl = f
 			}
 		case "attributes":
 			{
 				var f Container_Attribute
 				var list []Container_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
 					f = Container_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
 				}
 				x.Attributes = list
 				in.Delim(']')
 			}
 		case "placementPolicy":
 			{
 				var f *grpc1.PlacementPolicy
 				f = new(grpc1.PlacementPolicy)
 				f.UnmarshalEasyJSON(in)
 				x.PlacementPolicy = f
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
--- a/api/container/grpc/types_frostfs_fuzz.go
+++ b/api/container/grpc/types_frostfs_fuzz.go
@ -1,26 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package container
 func DoFuzzProtoContainer(data []byte) int {
 	msg := new(Container)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONContainer(data []byte) int {
 	msg := new(Container)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/container/grpc/types_frostfs_test.go
+++ b/api/container/grpc/types_frostfs_test.go
@ -1,21 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package container
 import (
 	testing "testing"
 )
 func FuzzProtoContainer(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoContainer(data)
 	})
 }
 func FuzzJSONContainer(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONContainer(data)
 	})
 }
--- a/api/container/json.go
+++ b/api/container/json.go
@ -1,22 +0,0 @@
 package container
 import (
 	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (a *Attribute) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(a)
 }
 func (a *Attribute) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(a, data, new(container.Container_Attribute))
 }
 func (c *Container) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(c)
 }
 func (c *Container) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(c, data, new(container.Container))
 }
--- a/api/container/marshal.go
+++ b/api/container/marshal.go
@ -1,345 +0,0 @@
 package container
 import (
 	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 )
 const (
 	attributeKeyField   = 1
 	attributeValueField = 2
 	containerVersionField    = 1
 	containerOwnerField      = 2
 	containerNonceField      = 3
 	containerBasicACLField   = 4
 	containerAttributesField = 5
 	containerPlacementField  = 6
 	putReqBodyContainerField = 1
 	putReqBodySignatureField = 2
 	putRespBodyIDField = 1
 	deleteReqBodyIDField        = 1
 	deleteReqBodySignatureField = 2
 	getReqBodyIDField = 1
 	getRespBodyContainerField = 1
 	getRespBodySignatureField = 2
 	getRespBodyTokenField     = 3
 	listReqBodyOwnerField = 1
 	listRespBodyIDsField = 1
 )
 func (a *Attribute) StableMarshal(buf []byte) []byte {
 	if a == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, a.StableSize())
 	}
 	var offset int
 	offset += protoutil.StringMarshal(attributeKeyField, buf[offset:], a.key)
 	protoutil.StringMarshal(attributeValueField, buf[offset:], a.val)
 	return buf
 }
 func (a *Attribute) StableSize() (size int) {
 	if a == nil {
 		return 0
 	}
 	size += protoutil.StringSize(attributeKeyField, a.key)
 	size += protoutil.StringSize(attributeValueField, a.val)
 	return size
 }
 func (a *Attribute) Unmarshal(data []byte) error {
 	return message.Unmarshal(a, data, new(container.Container_Attribute))
 }
 func (c *Container) StableMarshal(buf []byte) []byte {
 	if c == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, c.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(containerVersionField, buf[offset:], c.version)
 	offset += protoutil.NestedStructureMarshal(containerOwnerField, buf[offset:], c.ownerID)
 	offset += protoutil.BytesMarshal(containerNonceField, buf[offset:], c.nonce)
 	offset += protoutil.UInt32Marshal(containerBasicACLField, buf[offset:], c.basicACL)
 	for i := range c.attr {
 		offset += protoutil.NestedStructureMarshal(containerAttributesField, buf[offset:], &c.attr[i])
 	}
 	protoutil.NestedStructureMarshal(containerPlacementField, buf[offset:], c.policy)
 	return buf
 }
 func (c *Container) StableSize() (size int) {
 	if c == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(containerVersionField, c.version)
 	size += protoutil.NestedStructureSize(containerOwnerField, c.ownerID)
 	size += protoutil.BytesSize(containerNonceField, c.nonce)
 	size += protoutil.UInt32Size(containerBasicACLField, c.basicACL)
 	for i := range c.attr {
 		size += protoutil.NestedStructureSize(containerAttributesField, &c.attr[i])
 	}
 	size += protoutil.NestedStructureSize(containerPlacementField, c.policy)
 	return size
 }
 func (c *Container) Unmarshal(data []byte) error {
 	return message.Unmarshal(c, data, new(container.Container))
 }
 func (r *PutRequestBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(putReqBodyContainerField, buf[offset:], r.cnr)
 	protoutil.NestedStructureMarshal(putReqBodySignatureField, buf[offset:], r.sig)
 	return buf
 }
 func (r *PutRequestBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(putReqBodyContainerField, r.cnr)
 	size += protoutil.NestedStructureSize(putReqBodySignatureField, r.sig)
 	return size
 }
 func (r *PutRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.PutRequest_Body))
 }
 func (r *PutResponseBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	protoutil.NestedStructureMarshal(putRespBodyIDField, buf, r.cid)
 	return buf
 }
 func (r *PutResponseBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(putRespBodyIDField, r.cid)
 	return size
 }
 func (r *PutResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.PutResponse_Body))
 }
 func (r *DeleteRequestBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(deleteReqBodyIDField, buf[offset:], r.cid)
 	protoutil.NestedStructureMarshal(deleteReqBodySignatureField, buf[offset:], r.sig)
 	return buf
 }
 func (r *DeleteRequestBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(deleteReqBodyIDField, r.cid)
 	size += protoutil.NestedStructureSize(deleteReqBodySignatureField, r.sig)
 	return size
 }
 func (r *DeleteRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.DeleteRequest_Body))
 }
 func (r *DeleteResponseBody) StableMarshal(_ []byte) []byte {
 	return nil
 }
 func (r *DeleteResponseBody) StableSize() (size int) {
 	return 0
 }
 func (r *DeleteResponseBody) Unmarshal([]byte) error {
 	return nil
 }
 func (r *GetRequestBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	protoutil.NestedStructureMarshal(getReqBodyIDField, buf, r.cid)
 	return buf
 }
 func (r *GetRequestBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(getReqBodyIDField, r.cid)
 	return size
 }
 func (r *GetRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.GetRequest_Body))
 }
 func (r *GetResponseBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	var offset int
 	offset += protoutil.NestedStructureMarshal(getRespBodyContainerField, buf, r.cnr)
 	offset += protoutil.NestedStructureMarshal(getRespBodySignatureField, buf[offset:], r.sig)
 	protoutil.NestedStructureMarshal(getRespBodyTokenField, buf[offset:], r.token)
 	return buf
 }
 func (r *GetResponseBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(getRespBodyContainerField, r.cnr)
 	size += protoutil.NestedStructureSize(getRespBodySignatureField, r.sig)
 	size += protoutil.NestedStructureSize(getRespBodyTokenField, r.token)
 	return size
 }
 func (r *GetResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.GetResponse_Body))
 }
 func (r *ListRequestBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	protoutil.NestedStructureMarshal(listReqBodyOwnerField, buf, r.ownerID)
 	return buf
 }
 func (r *ListRequestBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	size += protoutil.NestedStructureSize(listReqBodyOwnerField, r.ownerID)
 	return size
 }
 func (r *ListRequestBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.ListRequest_Body))
 }
 func (r *ListResponseBody) StableMarshal(buf []byte) []byte {
 	if r == nil {
 		return []byte{}
 	}
 	if buf == nil {
 		buf = make([]byte, r.StableSize())
 	}
 	var offset int
 	for i := range r.cidList {
 		offset += protoutil.NestedStructureMarshal(listRespBodyIDsField, buf[offset:], &r.cidList[i])
 	}
 	return buf
 }
 func (r *ListResponseBody) StableSize() (size int) {
 	if r == nil {
 		return 0
 	}
 	for i := range r.cidList {
 		size += protoutil.NestedStructureSize(listRespBodyIDsField, &r.cidList[i])
 	}
 	return size
 }
 func (r *ListResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.ListResponse_Body))
 }
--- a/api/container/message_test.go
+++ b/api/container/message_test.go
@ -1,36 +0,0 @@
 package container_test
 import (
 	"testing"
 	containertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
 )
 func TestMessageConvert(t *testing.T) {
 	messagetest.TestRPCMessage(t,
 		func(empty bool) message.Message { return containertest.GenerateAttribute(empty) },
 		func(empty bool) message.Message { return containertest.GenerateContainer(empty) },
 		func(empty bool) message.Message { return containertest.GeneratePutRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GeneratePutRequest(empty) },
 		func(empty bool) message.Message { return containertest.GeneratePutResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GeneratePutResponse(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponse(empty) },
 		func(empty bool) message.Message { return containertest.GenerateDeleteRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateDeleteRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateDeleteResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateDeleteResponse(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListResponse(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponse(empty) },
 	)
 }
--- a/api/container/status.go
+++ b/api/container/status.go
@ -1,33 +0,0 @@
 package container
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
 	statusgrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/grpc"
 )
 // LocalizeFailStatus checks if passed global status.Code is related to container failure and:
 //
 //	then localizes the code and returns true,
 //	else leaves the code unchanged and returns false.
 //
 // Arg must not be nil.
 func LocalizeFailStatus(c *status.Code) bool {
 	return status.LocalizeIfInSection(c, uint32(statusgrpc.Section_SECTION_CONTAINER))
 }
 // GlobalizeFail globalizes local code of container failure.
 //
 // Arg must not be nil.
 func GlobalizeFail(c *status.Code) {
 	c.GlobalizeSection(uint32(statusgrpc.Section_SECTION_CONTAINER))
 }
 const (
 	// StatusNotFound is a local status.Code value for
 	// CONTAINER_NOT_FOUND container failure.
 	StatusNotFound status.Code = iota
 	// StatusEACLNotFound is a local status.Code value for
 	// EACL_NOT_FOUND failure.
 	StatusEACLNotFound
 )
--- a/api/container/status_test.go
+++ b/api/container/status_test.go
@ -1,15 +0,0 @@
 package container_test
 import (
 	"testing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
 	statustest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/test"
 )
 func TestStatusCodes(t *testing.T) {
 	statustest.TestCodes(t, container.LocalizeFailStatus, container.GlobalizeFail,
 		container.StatusNotFound, 3072,
 		container.StatusEACLNotFound, 3073,
 	)
 }
--- a/api/container/test/generate.go
+++ b/api/container/test/generate.go
@ -1,240 +0,0 @@
 package containertest
 import (
 	"crypto/rand"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
 	netmaptest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/test"
 	refstest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
 	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
 )
 func GenerateAttribute(empty bool) *container.Attribute {
 	m := new(container.Attribute)
 	if !empty {
 		m.SetKey("key")
 		m.SetValue("val")
 	}
 	return m
 }
 func GenerateAttributes(empty bool) []container.Attribute {
 	var res []container.Attribute
 	if !empty {
 		res = append(res,
 			*GenerateAttribute(false),
 			*GenerateAttribute(false),
 		)
 	}
 	return res
 }
 func GenerateContainer(empty bool) *container.Container {
 	m := new(container.Container)
 	if !empty {
 		nonce := make([]byte, 16)
 		_, _ = rand.Read(nonce)
 		m.SetBasicACL(12)
 		m.SetNonce(nonce)
 		m.SetOwnerID(refstest.GenerateOwnerID(false))
 		m.SetAttributes(GenerateAttributes(false))
 		m.SetPlacementPolicy(netmaptest.GeneratePlacementPolicy(false))
 	}
 	m.SetVersion(refstest.GenerateVersion(empty))
 	return m
 }
 func GeneratePutRequestBody(empty bool) *container.PutRequestBody {
 	m := new(container.PutRequestBody)
 	if !empty {
 		m.SetContainer(GenerateContainer(false))
 	}
 	m.SetSignature(refstest.GenerateSignature(empty))
 	return m
 }
 func GeneratePutRequest(empty bool) *container.PutRequest {
 	m := new(container.PutRequest)
 	if !empty {
 		m.SetBody(GeneratePutRequestBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	return m
 }
 func GeneratePutResponseBody(empty bool) *container.PutResponseBody {
 	m := new(container.PutResponseBody)
 	if !empty {
 		m.SetContainerID(refstest.GenerateContainerID(false))
 	}
 	return m
 }
 func GeneratePutResponse(empty bool) *container.PutResponse {
 	m := new(container.PutResponse)
 	if !empty {
 		m.SetBody(GeneratePutResponseBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	return m
 }
 func GenerateGetRequestBody(empty bool) *container.GetRequestBody {
 	m := new(container.GetRequestBody)
 	if !empty {
 		m.SetContainerID(refstest.GenerateContainerID(false))
 	}
 	return m
 }
 func GenerateGetRequest(empty bool) *container.GetRequest {
 	m := new(container.GetRequest)
 	if !empty {
 		m.SetBody(GenerateGetRequestBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	return m
 }
 func GenerateGetResponseBody(empty bool) *container.GetResponseBody {
 	m := new(container.GetResponseBody)
 	if !empty {
 		m.SetContainer(GenerateContainer(false))
 	}
 	m.SetSignature(refstest.GenerateSignature(empty))
 	m.SetSessionToken(sessiontest.GenerateSessionToken(empty))
 	return m
 }
 func GenerateGetResponse(empty bool) *container.GetResponse {
 	m := new(container.GetResponse)
 	if !empty {
 		m.SetBody(GenerateGetResponseBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	return m
 }
 func GenerateDeleteRequestBody(empty bool) *container.DeleteRequestBody {
 	m := new(container.DeleteRequestBody)
 	if !empty {
 		m.SetContainerID(refstest.GenerateContainerID(false))
 	}
 	m.SetSignature(refstest.GenerateSignature(empty))
 	return m
 }
 func GenerateDeleteRequest(empty bool) *container.DeleteRequest {
 	m := new(container.DeleteRequest)
 	if !empty {
 		m.SetBody(GenerateDeleteRequestBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	return m
 }
 func GenerateDeleteResponseBody(_ bool) *container.DeleteResponseBody {
 	m := new(container.DeleteResponseBody)
 	return m
 }
 func GenerateDeleteResponse(empty bool) *container.DeleteResponse {
 	m := new(container.DeleteResponse)
 	if !empty {
 		m.SetBody(GenerateDeleteResponseBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	return m
 }
 func GenerateListRequestBody(empty bool) *container.ListRequestBody {
 	m := new(container.ListRequestBody)
 	if !empty {
 		m.SetOwnerID(refstest.GenerateOwnerID(false))
 	}
 	return m
 }
 func GenerateListRequest(empty bool) *container.ListRequest {
 	m := new(container.ListRequest)
 	if !empty {
 		m.SetBody(GenerateListRequestBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
 	return m
 }
 func GenerateListResponseBody(empty bool) *container.ListResponseBody {
 	m := new(container.ListResponseBody)
 	if !empty {
 		m.SetContainerIDs(refstest.GenerateContainerIDs(false))
 	}
 	return m
 }
 func GenerateListResponse(empty bool) *container.ListResponse {
 	m := new(container.ListResponse)
 	if !empty {
 		m.SetBody(GenerateListResponseBody(false))
 	}
 	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
 	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
 	return m
 }
--- a/api/container/types.go
+++ b/api/container/types.go
@ -1,446 +0,0 @@
 package container
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
 )
 type Attribute struct {
 	key, val string
 }
 type Container struct {
 	version *refs.Version
 	ownerID *refs.OwnerID
 	nonce []byte
 	basicACL uint32
 	attr []Attribute
 	policy *netmap.PlacementPolicy
 }
 type PutRequestBody struct {
 	cnr *Container
 	sig *refs.Signature
 }
 type PutRequest struct {
 	body *PutRequestBody
 	session.RequestHeaders
 }
 type PutResponseBody struct {
 	cid *refs.ContainerID
 }
 type PutResponse struct {
 	body *PutResponseBody
 	session.ResponseHeaders
 }
 type GetRequestBody struct {
 	cid *refs.ContainerID
 }
 type GetRequest struct {
 	body *GetRequestBody
 	session.RequestHeaders
 }
 type GetResponseBody struct {
 	cnr *Container
 	token *session.Token
 	sig *refs.Signature
 }
 type GetResponse struct {
 	body *GetResponseBody
 	session.ResponseHeaders
 }
 type DeleteRequestBody struct {
 	cid *refs.ContainerID
 	sig *refs.Signature
 }
 type DeleteRequest struct {
 	body *DeleteRequestBody
 	session.RequestHeaders
 }
 type DeleteResponseBody struct{}
 type DeleteResponse struct {
 	body *DeleteResponseBody
 	session.ResponseHeaders
 }
 type ListRequestBody struct {
 	ownerID *refs.OwnerID
 }
 type ListRequest struct {
 	body *ListRequestBody
 	session.RequestHeaders
 }
 type ListResponseBody struct {
 	cidList []refs.ContainerID
 }
 type ListResponse struct {
 	body *ListResponseBody
 	session.ResponseHeaders
 }
 func (a *Attribute) GetKey() string {
 	if a != nil {
 		return a.key
 	}
 	return ""
 }
 func (a *Attribute) SetKey(v string) {
 	a.key = v
 }
 func (a *Attribute) GetValue() string {
 	if a != nil {
 		return a.val
 	}
 	return ""
 }
 func (a *Attribute) SetValue(v string) {
 	a.val = v
 }
 func (c *Container) GetVersion() *refs.Version {
 	if c != nil {
 		return c.version
 	}
 	return nil
 }
 func (c *Container) SetVersion(v *refs.Version) {
 	c.version = v
 }
 func (c *Container) GetOwnerID() *refs.OwnerID {
 	if c != nil {
 		return c.ownerID
 	}
 	return nil
 }
 func (c *Container) SetOwnerID(v *refs.OwnerID) {
 	c.ownerID = v
 }
 func (c *Container) GetNonce() []byte {
 	if c != nil {
 		return c.nonce
 	}
 	return nil
 }
 func (c *Container) SetNonce(v []byte) {
 	c.nonce = v
 }
 func (c *Container) GetBasicACL() uint32 {
 	if c != nil {
 		return c.basicACL
 	}
 	return 0
 }
 func (c *Container) SetBasicACL(v uint32) {
 	c.basicACL = v
 }
 func (c *Container) GetAttributes() []Attribute {
 	if c != nil {
 		return c.attr
 	}
 	return nil
 }
 func (c *Container) SetAttributes(v []Attribute) {
 	c.attr = v
 }
 func (c *Container) GetPlacementPolicy() *netmap.PlacementPolicy {
 	if c != nil {
 		return c.policy
 	}
 	return nil
 }
 func (c *Container) SetPlacementPolicy(v *netmap.PlacementPolicy) {
 	c.policy = v
 }
 func (r *PutRequestBody) GetContainer() *Container {
 	if r != nil {
 		return r.cnr
 	}
 	return nil
 }
 func (r *PutRequestBody) SetContainer(v *Container) {
 	r.cnr = v
 }
 func (r *PutRequestBody) GetSignature() *refs.Signature {
 	if r != nil {
 		return r.sig
 	}
 	return nil
 }
 func (r *PutRequestBody) SetSignature(v *refs.Signature) {
 	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
 	v.SetScheme(0)
 	r.sig = v
 }
 func (r *PutRequest) GetBody() *PutRequestBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *PutRequest) SetBody(v *PutRequestBody) {
 	r.body = v
 }
 func (r *PutResponseBody) GetContainerID() *refs.ContainerID {
 	if r != nil {
 		return r.cid
 	}
 	return nil
 }
 func (r *PutResponseBody) SetContainerID(v *refs.ContainerID) {
 	r.cid = v
 }
 func (r *PutResponse) GetBody() *PutResponseBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *PutResponse) SetBody(v *PutResponseBody) {
 	r.body = v
 }
 func (r *GetRequestBody) GetContainerID() *refs.ContainerID {
 	if r != nil {
 		return r.cid
 	}
 	return nil
 }
 func (r *GetRequestBody) SetContainerID(v *refs.ContainerID) {
 	r.cid = v
 }
 func (r *GetRequest) GetBody() *GetRequestBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *GetRequest) SetBody(v *GetRequestBody) {
 	r.body = v
 }
 func (r *GetResponseBody) GetContainer() *Container {
 	if r != nil {
 		return r.cnr
 	}
 	return nil
 }
 func (r *GetResponseBody) SetContainer(v *Container) {
 	r.cnr = v
 }
 // GetSessionToken returns token of the session within which requested
 // container was created.
 func (r *GetResponseBody) GetSessionToken() *session.Token {
 	if r != nil {
 		return r.token
 	}
 	return nil
 }
 // SetSessionToken sets token of the session within which requested
 // container was created.
 func (r *GetResponseBody) SetSessionToken(v *session.Token) {
 	r.token = v
 }
 // GetSignature returns signature of the requested container.
 func (r *GetResponseBody) GetSignature() *refs.Signature {
 	if r != nil {
 		return r.sig
 	}
 	return nil
 }
 // SetSignature sets signature of the requested container.
 func (r *GetResponseBody) SetSignature(v *refs.Signature) {
 	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
 	v.SetScheme(0)
 	r.sig = v
 }
 func (r *GetResponse) GetBody() *GetResponseBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *GetResponse) SetBody(v *GetResponseBody) {
 	r.body = v
 }
 func (r *DeleteRequestBody) GetContainerID() *refs.ContainerID {
 	if r != nil {
 		return r.cid
 	}
 	return nil
 }
 func (r *DeleteRequestBody) SetContainerID(v *refs.ContainerID) {
 	r.cid = v
 }
 func (r *DeleteRequestBody) GetSignature() *refs.Signature {
 	if r != nil {
 		return r.sig
 	}
 	return nil
 }
 func (r *DeleteRequestBody) SetSignature(v *refs.Signature) {
 	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
 	v.SetScheme(0)
 	r.sig = v
 }
 func (r *DeleteRequest) GetBody() *DeleteRequestBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *DeleteRequest) SetBody(v *DeleteRequestBody) {
 	r.body = v
 }
 func (r *DeleteResponse) GetBody() *DeleteResponseBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *DeleteResponse) SetBody(v *DeleteResponseBody) {
 	r.body = v
 }
 func (r *ListRequestBody) GetOwnerID() *refs.OwnerID {
 	if r != nil {
 		return r.ownerID
 	}
 	return nil
 }
 func (r *ListRequestBody) SetOwnerID(v *refs.OwnerID) {
 	r.ownerID = v
 }
 func (r *ListRequest) GetBody() *ListRequestBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *ListRequest) SetBody(v *ListRequestBody) {
 	r.body = v
 }
 func (r *ListResponseBody) GetContainerIDs() []refs.ContainerID {
 	if r != nil {
 		return r.cidList
 	}
 	return nil
 }
 func (r *ListResponseBody) SetContainerIDs(v []refs.ContainerID) {
 	r.cidList = v
 }
 func (r *ListResponse) GetBody() *ListResponseBody {
 	if r != nil {
 		return r.body
 	}
 	return nil
 }
 func (r *ListResponse) SetBody(v *ListResponseBody) {
 	r.body = v
 }
--- a/api/lock/grpc/types_frostfs.pb.go
+++ b/api/lock/grpc/types_frostfs.pb.go
@ -1,171 +0,0 @@
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package lock
 import (
 	json "encoding/json"
 	fmt "fmt"
 	grpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	pool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/pool"
 	proto "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
 	encoding "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/encoding"
 	easyproto "github.com/VictoriaMetrics/easyproto"
 	jlexer "github.com/mailru/easyjson/jlexer"
 	jwriter "github.com/mailru/easyjson/jwriter"
 )
 type Lock struct {
 	Members []grpc.ObjectID `json:"members"`
 }
 var (
 	_ encoding.ProtoMarshaler   = (*Lock)(nil)
 	_ encoding.ProtoUnmarshaler = (*Lock)(nil)
 	_ json.Marshaler            = (*Lock)(nil)
 	_ json.Unmarshaler          = (*Lock)(nil)
 )
 // StableSize returns the size of x in protobuf format.
 //
 // Structures with the same field values have the same binary size.
 func (x *Lock) StableSize() (size int) {
 	if x == nil {
 		return 0
 	}
 	for i := range x.Members {
 		size += proto.NestedStructureSizeUnchecked(1, &x.Members[i])
 	}
 	return size
 }
 // MarshalProtobuf implements the encoding.ProtoMarshaler interface.
 func (x *Lock) MarshalProtobuf(dst []byte) []byte {
 	m := pool.MarshalerPool.Get()
 	defer pool.MarshalerPool.Put(m)
 	x.EmitProtobuf(m.MessageMarshaler())
 	dst = m.Marshal(dst)
 	return dst
 }
 func (x *Lock) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 	if x == nil {
 		return
 	}
 	for i := range x.Members {
 		x.Members[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 // UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
 func (x *Lock) UnmarshalProtobuf(src []byte) (err error) {
 	var fc easyproto.FieldContext
 	for len(src) > 0 {
 		src, err = fc.NextField(src)
 		if err != nil {
 			return fmt.Errorf("cannot read next field in %s", "Lock")
 		}
 		switch fc.FieldNum {
 		case 1: // Members
 			data, ok := fc.MessageData()
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Members")
 			}
 			x.Members = append(x.Members, grpc.ObjectID{})
 			ff := &x.Members[len(x.Members)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
 		}
 	}
 	return nil
 }
 func (x *Lock) GetMembers() []grpc.ObjectID {
 	if x != nil {
 		return x.Members
 	}
 	return nil
 }
 func (x *Lock) SetMembers(v []grpc.ObjectID) {
 	x.Members = v
 }
 // MarshalJSON implements the json.Marshaler interface.
 func (x *Lock) MarshalJSON() ([]byte, error) {
 	w := jwriter.Writer{}
 	x.MarshalEasyJSON(&w)
 	return w.Buffer.BuildBytes(), w.Error
 }
 func (x *Lock) MarshalEasyJSON(out *jwriter.Writer) {
 	if x == nil {
 		out.RawString("null")
 		return
 	}
 	first := true
 	out.RawByte('{')
 	{
 		if !first {
 			out.RawByte(',')
 		} else {
 			first = false
 		}
 		const prefix string = "\"members\":"
 		out.RawString(prefix)
 		out.RawByte('[')
 		for i := range x.Members {
 			if i != 0 {
 				out.RawByte(',')
 			}
 			x.Members[i].MarshalEasyJSON(out)
 		}
 		out.RawByte(']')
 	}
 	out.RawByte('}')
 }
 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (x *Lock) UnmarshalJSON(data []byte) error {
 	r := jlexer.Lexer{Data: data}
 	x.UnmarshalEasyJSON(&r)
 	return r.Error()
 }
 func (x *Lock) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	isTopLevel := in.IsStart()
 	if in.IsNull() {
 		if isTopLevel {
 			in.Consumed()
 		}
 		in.Skip()
 		return
 	}
 	in.Delim('{')
 	for !in.IsDelim('}') {
 		key := in.UnsafeFieldName(false)
 		in.WantColon()
 		if in.IsNull() {
 			in.Skip()
 			in.WantComma()
 			continue
 		}
 		switch key {
 		case "members":
 			{
 				var f grpc.ObjectID
 				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
 					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
 				}
 				x.Members = list
 				in.Delim(']')
 			}
 		}
 		in.WantComma()
 	}
 	in.Delim('}')
 	if isTopLevel {
 		in.Consumed()
 	}
 }
--- a/api/lock/grpc/types_frostfs_fuzz.go
+++ b/api/lock/grpc/types_frostfs_fuzz.go
@ -1,26 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package lock
 func DoFuzzProtoLock(data []byte) int {
 	msg := new(Lock)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONLock(data []byte) int {
 	msg := new(Lock)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/lock/grpc/types_frostfs_test.go
+++ b/api/lock/grpc/types_frostfs_test.go
@ -1,21 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package lock
 import (
 	testing "testing"
 )
 func FuzzProtoLock(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoLock(data)
 	})
 }
 func FuzzJSONLock(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONLock(data)
 	})
 }
--- a/api/netmap/convert.go
+++ b/api/netmap/convert.go
@ -1,916 +0,0 @@
 package netmap
 import (
 	netmap "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
 	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
 )
 func (f *Filter) ToGRPCMessage() grpc.Message {
 	var m *netmap.Filter
 	if f != nil {
 		m = new(netmap.Filter)
 		m.SetKey(f.key)
 		m.SetValue(f.value)
 		m.SetName(f.name)
 		m.SetOp(OperationToGRPCMessage(f.op))
 		m.SetFilters(FiltersToGRPC(f.filters))
 	}
 	return m
 }
 func (f *Filter) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.Filter)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	f.filters, err = FiltersFromGRPC(v.GetFilters())
 	if err != nil {
 		return err
 	}
 	f.key = v.GetKey()
 	f.value = v.GetValue()
 	f.name = v.GetName()
 	f.op = OperationFromGRPCMessage(v.GetOp())
 	return nil
 }
 func FiltersToGRPC(fs []Filter) (res []netmap.Filter) {
 	if fs != nil {
 		res = make([]netmap.Filter, 0, len(fs))
 		for i := range fs {
 			res = append(res, *fs[i].ToGRPCMessage().(*netmap.Filter))
 		}
 	}
 	return
 }
 func FiltersFromGRPC(fs []netmap.Filter) (res []Filter, err error) {
 	if fs != nil {
 		res = make([]Filter, len(fs))
 		for i := range fs {
 			err = res[i].FromGRPCMessage(&fs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (s *Selector) ToGRPCMessage() grpc.Message {
 	var m *netmap.Selector
 	if s != nil {
 		m = new(netmap.Selector)
 		m.SetName(s.name)
 		m.SetAttribute(s.attribute)
 		m.SetFilter(s.filter)
 		m.SetCount(s.count)
 		m.SetClause(ClauseToGRPCMessage(s.clause))
 	}
 	return m
 }
 func (s *Selector) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.Selector)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	s.name = v.GetName()
 	s.attribute = v.GetAttribute()
 	s.filter = v.GetFilter()
 	s.count = v.GetCount()
 	s.clause = ClauseFromGRPCMessage(v.GetClause())
 	return nil
 }
 func SelectorsToGRPC(ss []Selector) (res []netmap.Selector) {
 	if ss != nil {
 		res = make([]netmap.Selector, 0, len(ss))
 		for i := range ss {
 			res = append(res, *ss[i].ToGRPCMessage().(*netmap.Selector))
 		}
 	}
 	return
 }
 func SelectorsFromGRPC(ss []netmap.Selector) (res []Selector, err error) {
 	if ss != nil {
 		res = make([]Selector, len(ss))
 		for i := range ss {
 			err = res[i].FromGRPCMessage(&ss[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (r *Replica) ToGRPCMessage() grpc.Message {
 	var m *netmap.Replica
 	if r != nil {
 		m = new(netmap.Replica)
 		m.SetSelector(r.selector)
 		m.SetCount(r.count)
 		m.EcDataCount = r.ecDataCount
 		m.EcParityCount = r.ecParityCount
 	}
 	return m
 }
 func (r *Replica) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.Replica)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	r.selector = v.GetSelector()
 	r.count = v.GetCount()
 	r.ecDataCount = v.GetEcDataCount()
 	r.ecParityCount = v.GetEcParityCount()
 	return nil
 }
 func ReplicasToGRPC(rs []Replica) (res []netmap.Replica) {
 	if rs != nil {
 		res = make([]netmap.Replica, 0, len(rs))
 		for i := range rs {
 			res = append(res, *rs[i].ToGRPCMessage().(*netmap.Replica))
 		}
 	}
 	return
 }
 func ReplicasFromGRPC(rs []netmap.Replica) (res []Replica, err error) {
 	if rs != nil {
 		res = make([]Replica, len(rs))
 		for i := range rs {
 			err = res[i].FromGRPCMessage(&rs[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (p *PlacementPolicy) ToGRPCMessage() grpc.Message {
 	var m *netmap.PlacementPolicy
 	if p != nil {
 		m = new(netmap.PlacementPolicy)
 		m.SetFilters(FiltersToGRPC(p.filters))
 		m.SetSelectors(SelectorsToGRPC(p.selectors))
 		m.SetReplicas(ReplicasToGRPC(p.replicas))
 		m.SetContainerBackupFactor(p.backupFactor)
 		m.SetUnique(p.unique)
 	}
 	return m
 }
 func (p *PlacementPolicy) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.PlacementPolicy)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	p.filters, err = FiltersFromGRPC(v.GetFilters())
 	if err != nil {
 		return err
 	}
 	p.selectors, err = SelectorsFromGRPC(v.GetSelectors())
 	if err != nil {
 		return err
 	}
 	p.replicas, err = ReplicasFromGRPC(v.GetReplicas())
 	if err != nil {
 		return err
 	}
 	p.backupFactor = v.GetContainerBackupFactor()
 	p.unique = v.GetUnique()
 	return nil
 }
 func ClauseToGRPCMessage(n Clause) netmap.Clause {
 	return netmap.Clause(n)
 }
 func ClauseFromGRPCMessage(n netmap.Clause) Clause {
 	return Clause(n)
 }
 func OperationToGRPCMessage(n Operation) netmap.Operation {
 	return netmap.Operation(n)
 }
 func OperationFromGRPCMessage(n netmap.Operation) Operation {
 	return Operation(n)
 }
 func NodeStateToGRPCMessage(n NodeState) netmap.NodeInfo_State {
 	return netmap.NodeInfo_State(n)
 }
 func NodeStateFromRPCMessage(n netmap.NodeInfo_State) NodeState {
 	return NodeState(n)
 }
 func (a *Attribute) ToGRPCMessage() grpc.Message {
 	var m *netmap.NodeInfo_Attribute
 	if a != nil {
 		m = new(netmap.NodeInfo_Attribute)
 		m.SetKey(a.key)
 		m.SetValue(a.value)
 		m.SetParents(a.parents)
 	}
 	return m
 }
 func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NodeInfo_Attribute)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	a.key = v.GetKey()
 	a.value = v.GetValue()
 	a.parents = v.GetParents()
 	return nil
 }
 func AttributesToGRPC(as []Attribute) (res []netmap.NodeInfo_Attribute) {
 	if as != nil {
 		res = make([]netmap.NodeInfo_Attribute, 0, len(as))
 		for i := range as {
 			res = append(res, *as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
 		}
 	}
 	return
 }
 func AttributesFromGRPC(as []netmap.NodeInfo_Attribute) (res []Attribute, err error) {
 	if as != nil {
 		res = make([]Attribute, len(as))
 		for i := range as {
 			err = res[i].FromGRPCMessage(&as[i])
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (ni *NodeInfo) ToGRPCMessage() grpc.Message {
 	var m *netmap.NodeInfo
 	if ni != nil {
 		m = new(netmap.NodeInfo)
 		m.SetPublicKey(ni.publicKey)
 		m.SetAddresses(ni.addresses)
 		m.SetState(NodeStateToGRPCMessage(ni.state))
 		m.SetAttributes(AttributesToGRPC(ni.attributes))
 	}
 	return m
 }
 func (ni *NodeInfo) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NodeInfo)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	ni.attributes, err = AttributesFromGRPC(v.GetAttributes())
 	if err != nil {
 		return err
 	}
 	ni.publicKey = v.GetPublicKey()
 	ni.addresses = v.GetAddresses()
 	ni.state = NodeStateFromRPCMessage(v.GetState())
 	return nil
 }
 func (l *LocalNodeInfoRequestBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.LocalNodeInfoRequest_Body
 	if l != nil {
 		m = new(netmap.LocalNodeInfoRequest_Body)
 	}
 	return m
 }
 func (l *LocalNodeInfoRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.LocalNodeInfoRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	return nil
 }
 func (l *LocalNodeInfoRequest) ToGRPCMessage() grpc.Message {
 	var m *netmap.LocalNodeInfoRequest
 	if l != nil {
 		m = new(netmap.LocalNodeInfoRequest)
 		m.SetBody(l.body.ToGRPCMessage().(*netmap.LocalNodeInfoRequest_Body))
 		l.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (l *LocalNodeInfoRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.LocalNodeInfoRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		l.body = nil
 	} else {
 		if l.body == nil {
 			l.body = new(LocalNodeInfoRequestBody)
 		}
 		err = l.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return l.RequestHeaders.FromMessage(v)
 }
 func (l *LocalNodeInfoResponseBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.LocalNodeInfoResponse_Body
 	if l != nil {
 		m = new(netmap.LocalNodeInfoResponse_Body)
 		m.SetVersion(l.version.ToGRPCMessage().(*refsGRPC.Version))
 		m.SetNodeInfo(l.nodeInfo.ToGRPCMessage().(*netmap.NodeInfo))
 	}
 	return m
 }
 func (l *LocalNodeInfoResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.LocalNodeInfoResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	version := v.GetVersion()
 	if version == nil {
 		l.version = nil
 	} else {
 		if l.version == nil {
 			l.version = new(refs.Version)
 		}
 		err = l.version.FromGRPCMessage(version)
 		if err != nil {
 			return err
 		}
 	}
 	nodeInfo := v.GetNodeInfo()
 	if nodeInfo == nil {
 		l.nodeInfo = nil
 	} else {
 		if l.nodeInfo == nil {
 			l.nodeInfo = new(NodeInfo)
 		}
 		err = l.nodeInfo.FromGRPCMessage(nodeInfo)
 	}
 	return err
 }
 func (l *LocalNodeInfoResponse) ToGRPCMessage() grpc.Message {
 	var m *netmap.LocalNodeInfoResponse
 	if l != nil {
 		m = new(netmap.LocalNodeInfoResponse)
 		m.SetBody(l.body.ToGRPCMessage().(*netmap.LocalNodeInfoResponse_Body))
 		l.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (l *LocalNodeInfoResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.LocalNodeInfoResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		l.body = nil
 	} else {
 		if l.body == nil {
 			l.body = new(LocalNodeInfoResponseBody)
 		}
 		err = l.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return l.ResponseHeaders.FromMessage(v)
 }
 func (x *NetworkParameter) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkConfig_Parameter
 	if x != nil {
 		m = new(netmap.NetworkConfig_Parameter)
 		m.SetKey(x.k)
 		m.SetValue(x.v)
 	}
 	return m
 }
 func (x *NetworkParameter) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkConfig_Parameter)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	x.k = v.GetKey()
 	x.v = v.GetValue()
 	return nil
 }
 func (x *NetworkConfig) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkConfig
 	if x != nil {
 		m = new(netmap.NetworkConfig)
 		var ps []netmap.NetworkConfig_Parameter
 		if ln := len(x.ps); ln > 0 {
 			ps = make([]netmap.NetworkConfig_Parameter, 0, ln)
 			for i := range ln {
 				ps = append(ps, *x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
 			}
 		}
 		m.SetParameters(ps)
 	}
 	return m
 }
 func (x *NetworkConfig) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkConfig)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var (
 		ps   []NetworkParameter
 		psV2 = v.GetParameters()
 	)
 	if psV2 != nil {
 		ln := len(psV2)
 		ps = make([]NetworkParameter, ln)
 		for i := range ln {
 			if err := ps[i].FromGRPCMessage(&psV2[i]); err != nil {
 				return err
 			}
 		}
 	}
 	x.ps = ps
 	return nil
 }
 func (i *NetworkInfo) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkInfo
 	if i != nil {
 		m = new(netmap.NetworkInfo)
 		m.SetMagicNumber(i.magicNum)
 		m.SetCurrentEpoch(i.curEpoch)
 		m.SetMsPerBlock(i.msPerBlock)
 		m.SetNetworkConfig(i.netCfg.ToGRPCMessage().(*netmap.NetworkConfig))
 	}
 	return m
 }
 func (i *NetworkInfo) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkInfo)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	netCfg := v.GetNetworkConfig()
 	if netCfg == nil {
 		i.netCfg = nil
 	} else {
 		if i.netCfg == nil {
 			i.netCfg = new(NetworkConfig)
 		}
 		err = i.netCfg.FromGRPCMessage(netCfg)
 		if err != nil {
 			return err
 		}
 	}
 	i.magicNum = v.GetMagicNumber()
 	i.curEpoch = v.GetCurrentEpoch()
 	i.msPerBlock = v.GetMsPerBlock()
 	return nil
 }
 func (l *NetworkInfoRequestBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkInfoRequest_Body
 	if l != nil {
 		m = new(netmap.NetworkInfoRequest_Body)
 	}
 	return m
 }
 func (l *NetworkInfoRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkInfoRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	return nil
 }
 func (l *NetworkInfoRequest) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkInfoRequest
 	if l != nil {
 		m = new(netmap.NetworkInfoRequest)
 		m.SetBody(l.body.ToGRPCMessage().(*netmap.NetworkInfoRequest_Body))
 		l.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (l *NetworkInfoRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkInfoRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		l.body = nil
 	} else {
 		if l.body == nil {
 			l.body = new(NetworkInfoRequestBody)
 		}
 		err = l.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return l.RequestHeaders.FromMessage(v)
 }
 func (i *NetworkInfoResponseBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkInfoResponse_Body
 	if i != nil {
 		m = new(netmap.NetworkInfoResponse_Body)
 		m.SetNetworkInfo(i.netInfo.ToGRPCMessage().(*netmap.NetworkInfo))
 	}
 	return m
 }
 func (i *NetworkInfoResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkInfoResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	netInfo := v.GetNetworkInfo()
 	if netInfo == nil {
 		i.netInfo = nil
 	} else {
 		if i.netInfo == nil {
 			i.netInfo = new(NetworkInfo)
 		}
 		err = i.netInfo.FromGRPCMessage(netInfo)
 	}
 	return err
 }
 func (l *NetworkInfoResponse) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetworkInfoResponse
 	if l != nil {
 		m = new(netmap.NetworkInfoResponse)
 		m.SetBody(l.body.ToGRPCMessage().(*netmap.NetworkInfoResponse_Body))
 		l.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (l *NetworkInfoResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetworkInfoResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		l.body = nil
 	} else {
 		if l.body == nil {
 			l.body = new(NetworkInfoResponseBody)
 		}
 		err = l.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return l.ResponseHeaders.FromMessage(v)
 }
 func (x *NetMap) ToGRPCMessage() grpc.Message {
 	var m *netmap.Netmap
 	if x != nil {
 		m = new(netmap.Netmap)
 		m.SetEpoch(x.epoch)
 		if x.nodes != nil {
 			nodes := make([]netmap.NodeInfo, len(x.nodes))
 			for i := range x.nodes {
 				nodes[i] = *x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
 			}
 			m.SetNodes(nodes)
 		}
 	}
 	return m
 }
 func (x *NetMap) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.Netmap)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	nodes := v.GetNodes()
 	if nodes == nil {
 		x.nodes = nil
 	} else {
 		x.nodes = make([]NodeInfo, len(nodes))
 		for i := range nodes {
 			err = x.nodes[i].FromGRPCMessage(&nodes[i])
 			if err != nil {
 				return err
 			}
 		}
 	}
 	x.epoch = v.GetEpoch()
 	return nil
 }
 func (x *SnapshotRequestBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetmapSnapshotRequest_Body
 	if x != nil {
 		m = new(netmap.NetmapSnapshotRequest_Body)
 	}
 	return m
 }
 func (x *SnapshotRequestBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetmapSnapshotRequest_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	return nil
 }
 func (x *SnapshotRequest) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetmapSnapshotRequest
 	if x != nil {
 		m = new(netmap.NetmapSnapshotRequest)
 		m.SetBody(x.body.ToGRPCMessage().(*netmap.NetmapSnapshotRequest_Body))
 		x.RequestHeaders.ToMessage(m)
 	}
 	return m
 }
 func (x *SnapshotRequest) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetmapSnapshotRequest)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		x.body = nil
 	} else {
 		if x.body == nil {
 			x.body = new(SnapshotRequestBody)
 		}
 		err = x.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return x.RequestHeaders.FromMessage(v)
 }
 func (x *SnapshotResponseBody) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetmapSnapshotResponse_Body
 	if x != nil {
 		m = new(netmap.NetmapSnapshotResponse_Body)
 		m.SetNetmap(x.netMap.ToGRPCMessage().(*netmap.Netmap))
 	}
 	return m
 }
 func (x *SnapshotResponseBody) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetmapSnapshotResponse_Body)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	netMap := v.GetNetmap()
 	if netMap == nil {
 		x.netMap = nil
 	} else {
 		if x.netMap == nil {
 			x.netMap = new(NetMap)
 		}
 		err = x.netMap.FromGRPCMessage(netMap)
 	}
 	return err
 }
 func (x *SnapshotResponse) ToGRPCMessage() grpc.Message {
 	var m *netmap.NetmapSnapshotResponse
 	if x != nil {
 		m = new(netmap.NetmapSnapshotResponse)
 		m.SetBody(x.body.ToGRPCMessage().(*netmap.NetmapSnapshotResponse_Body))
 		x.ResponseHeaders.ToMessage(m)
 	}
 	return m
 }
 func (x *SnapshotResponse) FromGRPCMessage(m grpc.Message) error {
 	v, ok := m.(*netmap.NetmapSnapshotResponse)
 	if !ok {
 		return message.NewUnexpectedMessageType(m, v)
 	}
 	var err error
 	body := v.GetBody()
 	if body == nil {
 		x.body = nil
 	} else {
 		if x.body == nil {
 			x.body = new(SnapshotResponseBody)
 		}
 		err = x.body.FromGRPCMessage(body)
 		if err != nil {
 			return err
 		}
 	}
 	return x.ResponseHeaders.FromMessage(v)
 }
--- a/api/netmap/grpc/service_frostfs.pb.go
+++ b/api/netmap/grpc/service_frostfs.pb.go
--- a/api/netmap/grpc/service_frostfs_fuzz.go
+++ b/api/netmap/grpc/service_frostfs_fuzz.go
@ -1,121 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package netmap
 func DoFuzzProtoLocalNodeInfoRequest(data []byte) int {
 	msg := new(LocalNodeInfoRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONLocalNodeInfoRequest(data []byte) int {
 	msg := new(LocalNodeInfoRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoLocalNodeInfoResponse(data []byte) int {
 	msg := new(LocalNodeInfoResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONLocalNodeInfoResponse(data []byte) int {
 	msg := new(LocalNodeInfoResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetworkInfoRequest(data []byte) int {
 	msg := new(NetworkInfoRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetworkInfoRequest(data []byte) int {
 	msg := new(NetworkInfoRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetworkInfoResponse(data []byte) int {
 	msg := new(NetworkInfoResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetworkInfoResponse(data []byte) int {
 	msg := new(NetworkInfoResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetmapSnapshotRequest(data []byte) int {
 	msg := new(NetmapSnapshotRequest)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetmapSnapshotRequest(data []byte) int {
 	msg := new(NetmapSnapshotRequest)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetmapSnapshotResponse(data []byte) int {
 	msg := new(NetmapSnapshotResponse)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetmapSnapshotResponse(data []byte) int {
 	msg := new(NetmapSnapshotResponse)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/netmap/grpc/service_frostfs_test.go
+++ b/api/netmap/grpc/service_frostfs_test.go
@ -1,71 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package netmap
 import (
 	testing "testing"
 )
 func FuzzProtoLocalNodeInfoRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoLocalNodeInfoRequest(data)
 	})
 }
 func FuzzJSONLocalNodeInfoRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONLocalNodeInfoRequest(data)
 	})
 }
 func FuzzProtoLocalNodeInfoResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoLocalNodeInfoResponse(data)
 	})
 }
 func FuzzJSONLocalNodeInfoResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONLocalNodeInfoResponse(data)
 	})
 }
 func FuzzProtoNetworkInfoRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetworkInfoRequest(data)
 	})
 }
 func FuzzJSONNetworkInfoRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetworkInfoRequest(data)
 	})
 }
 func FuzzProtoNetworkInfoResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetworkInfoResponse(data)
 	})
 }
 func FuzzJSONNetworkInfoResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetworkInfoResponse(data)
 	})
 }
 func FuzzProtoNetmapSnapshotRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetmapSnapshotRequest(data)
 	})
 }
 func FuzzJSONNetmapSnapshotRequest(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetmapSnapshotRequest(data)
 	})
 }
 func FuzzProtoNetmapSnapshotResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetmapSnapshotResponse(data)
 	})
 }
 func FuzzJSONNetmapSnapshotResponse(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetmapSnapshotResponse(data)
 	})
 }
--- a/api/netmap/grpc/service_grpc.pb.go
+++ b/api/netmap/grpc/service_grpc.pb.go
@ -1,227 +0,0 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.3.0
 // - protoc             v5.27.2
 // source: api/netmap/grpc/service.proto
 package netmap
 import (
 	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 )
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
 // Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 const (
 	NetmapService_LocalNodeInfo_FullMethodName  = "/neo.fs.v2.netmap.NetmapService/LocalNodeInfo"
 	NetmapService_NetworkInfo_FullMethodName    = "/neo.fs.v2.netmap.NetmapService/NetworkInfo"
 	NetmapService_NetmapSnapshot_FullMethodName = "/neo.fs.v2.netmap.NetmapService/NetmapSnapshot"
 )
 // NetmapServiceClient is the client API for NetmapService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type NetmapServiceClient interface {
 	// Get NodeInfo structure from the particular node directly.
 	// Node information can be taken from `Netmap` smart contract. In some cases,
 	// though, one may want to get recent information directly or to talk to the
 	// node not yet present in the `Network Map` to find out what API version can
 	// be used for further communication. This can be also used to check if a node
 	// is up and running.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the server has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	LocalNodeInfo(ctx context.Context, in *LocalNodeInfoRequest, opts ...grpc.CallOption) (*LocalNodeInfoResponse, error)
 	// Read recent information about the FrostFS network.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the current network state has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	NetworkInfo(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfoResponse, error)
 	// Returns network map snapshot of the current FrostFS epoch.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the current network map has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	NetmapSnapshot(ctx context.Context, in *NetmapSnapshotRequest, opts ...grpc.CallOption) (*NetmapSnapshotResponse, error)
 }
 type netmapServiceClient struct {
 	cc grpc.ClientConnInterface
 }
 func NewNetmapServiceClient(cc grpc.ClientConnInterface) NetmapServiceClient {
 	return &netmapServiceClient{cc}
 }
 func (c *netmapServiceClient) LocalNodeInfo(ctx context.Context, in *LocalNodeInfoRequest, opts ...grpc.CallOption) (*LocalNodeInfoResponse, error) {
 	out := new(LocalNodeInfoResponse)
 	err := c.cc.Invoke(ctx, NetmapService_LocalNodeInfo_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *netmapServiceClient) NetworkInfo(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfoResponse, error) {
 	out := new(NetworkInfoResponse)
 	err := c.cc.Invoke(ctx, NetmapService_NetworkInfo_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *netmapServiceClient) NetmapSnapshot(ctx context.Context, in *NetmapSnapshotRequest, opts ...grpc.CallOption) (*NetmapSnapshotResponse, error) {
 	out := new(NetmapSnapshotResponse)
 	err := c.cc.Invoke(ctx, NetmapService_NetmapSnapshot_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // NetmapServiceServer is the server API for NetmapService service.
 // All implementations should embed UnimplementedNetmapServiceServer
 // for forward compatibility
 type NetmapServiceServer interface {
 	// Get NodeInfo structure from the particular node directly.
 	// Node information can be taken from `Netmap` smart contract. In some cases,
 	// though, one may want to get recent information directly or to talk to the
 	// node not yet present in the `Network Map` to find out what API version can
 	// be used for further communication. This can be also used to check if a node
 	// is up and running.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the server has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	LocalNodeInfo(context.Context, *LocalNodeInfoRequest) (*LocalNodeInfoResponse, error)
 	// Read recent information about the FrostFS network.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the current network state has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	NetworkInfo(context.Context, *NetworkInfoRequest) (*NetworkInfoResponse, error)
 	// Returns network map snapshot of the current FrostFS epoch.
 	//
 	// Statuses:
 	// - **OK** (0, SECTION_SUCCESS):
 	// information about the current network map has been successfully read;
 	// - Common failures (SECTION_FAILURE_COMMON).
 	NetmapSnapshot(context.Context, *NetmapSnapshotRequest) (*NetmapSnapshotResponse, error)
 }
 // UnimplementedNetmapServiceServer should be embedded to have forward compatible implementations.
 type UnimplementedNetmapServiceServer struct {
 }
 func (UnimplementedNetmapServiceServer) LocalNodeInfo(context.Context, *LocalNodeInfoRequest) (*LocalNodeInfoResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method LocalNodeInfo not implemented")
 }
 func (UnimplementedNetmapServiceServer) NetworkInfo(context.Context, *NetworkInfoRequest) (*NetworkInfoResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method NetworkInfo not implemented")
 }
 func (UnimplementedNetmapServiceServer) NetmapSnapshot(context.Context, *NetmapSnapshotRequest) (*NetmapSnapshotResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method NetmapSnapshot not implemented")
 }
 // UnsafeNetmapServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to NetmapServiceServer will
 // result in compilation errors.
 type UnsafeNetmapServiceServer interface {
 	mustEmbedUnimplementedNetmapServiceServer()
 }
 func RegisterNetmapServiceServer(s grpc.ServiceRegistrar, srv NetmapServiceServer) {
 	s.RegisterService(&NetmapService_ServiceDesc, srv)
 }
 func _NetmapService_LocalNodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(LocalNodeInfoRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(NetmapServiceServer).LocalNodeInfo(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: NetmapService_LocalNodeInfo_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(NetmapServiceServer).LocalNodeInfo(ctx, req.(*LocalNodeInfoRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _NetmapService_NetworkInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(NetworkInfoRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(NetmapServiceServer).NetworkInfo(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: NetmapService_NetworkInfo_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(NetmapServiceServer).NetworkInfo(ctx, req.(*NetworkInfoRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _NetmapService_NetmapSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(NetmapSnapshotRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(NetmapServiceServer).NetmapSnapshot(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: NetmapService_NetmapSnapshot_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(NetmapServiceServer).NetmapSnapshot(ctx, req.(*NetmapSnapshotRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // NetmapService_ServiceDesc is the grpc.ServiceDesc for NetmapService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var NetmapService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "neo.fs.v2.netmap.NetmapService",
 	HandlerType: (*NetmapServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "LocalNodeInfo",
 			Handler:    _NetmapService_LocalNodeInfo_Handler,
 		},
 		{
 			MethodName: "NetworkInfo",
 			Handler:    _NetmapService_NetworkInfo_Handler,
 		},
 		{
 			MethodName: "NetmapSnapshot",
 			Handler:    _NetmapService_NetmapSnapshot_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "api/netmap/grpc/service.proto",
 }
--- a/api/netmap/grpc/types_frostfs.pb.go
+++ b/api/netmap/grpc/types_frostfs.pb.go
--- a/api/netmap/grpc/types_frostfs_fuzz.go
+++ b/api/netmap/grpc/types_frostfs_fuzz.go
@ -1,159 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package netmap
 func DoFuzzProtoFilter(data []byte) int {
 	msg := new(Filter)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONFilter(data []byte) int {
 	msg := new(Filter)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoSelector(data []byte) int {
 	msg := new(Selector)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONSelector(data []byte) int {
 	msg := new(Selector)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoReplica(data []byte) int {
 	msg := new(Replica)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONReplica(data []byte) int {
 	msg := new(Replica)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoPlacementPolicy(data []byte) int {
 	msg := new(PlacementPolicy)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONPlacementPolicy(data []byte) int {
 	msg := new(PlacementPolicy)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNodeInfo(data []byte) int {
 	msg := new(NodeInfo)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNodeInfo(data []byte) int {
 	msg := new(NodeInfo)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetmap(data []byte) int {
 	msg := new(Netmap)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetmap(data []byte) int {
 	msg := new(Netmap)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetworkConfig(data []byte) int {
 	msg := new(NetworkConfig)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetworkConfig(data []byte) int {
 	msg := new(NetworkConfig)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
 func DoFuzzProtoNetworkInfo(data []byte) int {
 	msg := new(NetworkInfo)
 	if err := msg.UnmarshalProtobuf(data); err != nil {
 		return 0
 	}
 	_ = msg.MarshalProtobuf(nil)
 	return 1
 }
 func DoFuzzJSONNetworkInfo(data []byte) int {
 	msg := new(NetworkInfo)
 	if err := msg.UnmarshalJSON(data); err != nil {
 		return 0
 	}
 	_, err := msg.MarshalJSON()
 	if err != nil {
 		panic(err)
 	}
 	return 1
 }
--- a/api/netmap/grpc/types_frostfs_test.go
+++ b/api/netmap/grpc/types_frostfs_test.go
@ -1,91 +0,0 @@
 //go:build gofuzz
 // +build gofuzz
 // Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
 package netmap
 import (
 	testing "testing"
 )
 func FuzzProtoFilter(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoFilter(data)
 	})
 }
 func FuzzJSONFilter(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONFilter(data)
 	})
 }
 func FuzzProtoSelector(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoSelector(data)
 	})
 }
 func FuzzJSONSelector(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONSelector(data)
 	})
 }
 func FuzzProtoReplica(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoReplica(data)
 	})
 }
 func FuzzJSONReplica(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONReplica(data)
 	})
 }
 func FuzzProtoPlacementPolicy(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoPlacementPolicy(data)
 	})
 }
 func FuzzJSONPlacementPolicy(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONPlacementPolicy(data)
 	})
 }
 func FuzzProtoNodeInfo(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNodeInfo(data)
 	})
 }
 func FuzzJSONNodeInfo(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNodeInfo(data)
 	})
 }
 func FuzzProtoNetmap(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetmap(data)
 	})
 }
 func FuzzJSONNetmap(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetmap(data)
 	})
 }
 func FuzzProtoNetworkConfig(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetworkConfig(data)
 	})
 }
 func FuzzJSONNetworkConfig(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetworkConfig(data)
 	})
 }
 func FuzzProtoNetworkInfo(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzProtoNetworkInfo(data)
 	})
 }
 func FuzzJSONNetworkInfo(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
 		DoFuzzJSONNetworkInfo(data)
 	})
 }
--- a/Show more
+++ b/Show more
		`@ -1 +0,0 @@`
			`.* @TrueCloudLab/storage-core @TrueCloudLab/storage-services`