Merge pull request #51575 from smerkviladze/25.0-add-windows-integration-tests

[25.0 backport] integration: add Windows network driver and isolation tests

.github/workflows/.windows.yml

@@ -32,8 +32,8 @@ env:
   GOTESTLIST_VERSION: v0.3.1
   TESTSTAT_VERSION: v0.1.25
   WINDOWS_BASE_IMAGE: mcr.microsoft.com/windows/servercore
-  WINDOWS_BASE_TAG_2019: ltsc2019
   WINDOWS_BASE_TAG_2022: ltsc2022
+  WINDOWS_BASE_TAG_2025: ltsc2025
   TEST_IMAGE_NAME: moby:test
   TEST_CTN_NAME: moby
   DOCKER_BUILDKIT: 0
@@ -65,8 +65,8 @@ jobs:
         run: |
           New-Item -ItemType "directory" -Path "${{ github.workspace }}\go-build"
           New-Item -ItemType "directory" -Path "${{ github.workspace }}\go\pkg\mod"
-          If ("${{ inputs.os }}" -eq "windows-2019") {
-            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2019 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
+          If ("${{ inputs.os }}" -eq "windows-2025") {
+            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2025 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           } ElseIf ("${{ inputs.os }}" -eq "windows-2022") {
             echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2022 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           }
@@ -145,8 +145,8 @@ jobs:
           New-Item -ItemType "directory" -Path "${{ github.workspace }}\go-build"
           New-Item -ItemType "directory" -Path "${{ github.workspace }}\go\pkg\mod"
           New-Item -ItemType "directory" -Path "bundles"
-          If ("${{ inputs.os }}" -eq "windows-2019") {
-            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2019 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
+          If ("${{ inputs.os }}" -eq "windows-2025") {
+            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2025 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           } ElseIf ("${{ inputs.os }}" -eq "windows-2022") {
             echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2022 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           }
@@ -319,8 +319,8 @@ jobs:
         name: Init
         run: |
           New-Item -ItemType "directory" -Path "bundles"
-          If ("${{ inputs.os }}" -eq "windows-2019") {
-            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2019 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
+          If ("${{ inputs.os }}" -eq "windows-2025") {
+            echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2025 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           } ElseIf ("${{ inputs.os }}" -eq "windows-2022") {
             echo "WINDOWS_BASE_IMAGE_TAG=${{ env.WINDOWS_BASE_TAG_2022 }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
           }

.github/workflows/arm64.yml

@@ -86,7 +86,7 @@ jobs:
           targets: dev
           set: |
             *.cache-from=type=gha,scope=dev-arm64
-            *.cache-to=type=gha,scope=dev-arm64,mode=max
+            *.cache-to=type=gha,scope=dev-arm64
             *.output=type=cacheonly
 
   test-unit:

.github/workflows/test.yml

@@ -41,6 +41,7 @@ jobs:
         mode:
           - ""
           - systemd
+          - firewalld
     steps:
       -
         name: Prepare
@@ -58,7 +59,7 @@ jobs:
           targets: dev
           set: |
             *.cache-from=type=gha,scope=dev${{ matrix.mode }}
-            *.cache-to=type=gha,scope=dev${{ matrix.mode }},mode=max
+            *.cache-to=type=gha,scope=dev${{ matrix.mode }}
             *.output=type=cacheonly
 
   test:

.github/workflows/windows-2022.yml

@@ -14,12 +14,9 @@ concurrency:
   cancel-in-progress: true
 
 on:
+  schedule:
+    - cron: '0 10 * * *'
   workflow_dispatch:
-  push:
-    branches:
-      - 'master'
-      - '[0-9]+.[0-9]+'
-  pull_request:
 
 jobs:
   validate-dco:

.github/workflows/windows-2025.yml

@@ -1,4 +1,4 @@
-name: windows-2019
+name: windows-2025
 
 # Default to 'contents: read', which grants actions to read commits.
 #
@@ -14,9 +14,13 @@ concurrency:
   cancel-in-progress: true
 
 on:
-  schedule:
-    - cron: '0 10 * * *'
   workflow_dispatch:
+  push:
+    branches:
+      - 'master'
+      - '[0-9]+.[0-9]+'
+      - '[0-9]+.x'
+  pull_request:
 
 jobs:
   validate-dco:
@@ -37,6 +41,6 @@ jobs:
       matrix:
         storage: ${{ fromJson(needs.test-prepare.outputs.matrix) }}
     with:
-      os: windows-2019
+      os: windows-2025
       storage: ${{ matrix.storage }}
       send_coverage: false

Dockerfile.windows

@@ -255,14 +255,11 @@ RUN `
   Remove-Item C:\gitsetup.zip; `
   `
   Write-Host INFO: Downloading containerd; `
-  Install-Package -Force 7Zip4PowerShell; `
   $location='https://github.com/containerd/containerd/releases/download/'+$Env:CONTAINERD_VERSION+'/containerd-'+$Env:CONTAINERD_VERSION.TrimStart('v')+'-windows-amd64.tar.gz'; `
   Download-File $location C:\containerd.tar.gz; `
   New-Item -Path C:\containerd -ItemType Directory; `
-  Expand-7Zip C:\containerd.tar.gz C:\; `
-  Expand-7Zip C:\containerd.tar C:\containerd; `
+  tar -xzf C:\containerd.tar.gz -C C:\containerd; `
   Remove-Item C:\containerd.tar.gz; `
-  Remove-Item C:\containerd.tar; `
   `
   # Ensure all directories exist that we will require below....
   $srcDir = """$Env:GOPATH`\src\github.com\docker\docker\bundles"""; `

cmd/dockerd/daemon.go

@@ -9,7 +9,9 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -67,6 +69,14 @@ import (
 	"tags.cncf.io/container-device-interface/pkg/cdi"
 )
 
+// strongTLSCiphers defines a secure, modern set of TLS cipher suites for use by the daemon.
+var strongTLSCiphers = []uint16{
+	tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+	tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+}
+
 // DaemonCli represents the daemon CLI.
 type DaemonCli struct {
 	*config.Config
@@ -779,6 +789,18 @@ func newAPIServerTLSConfig(config *config.Config) (*tls.Config, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, "invalid TLS configuration")
 		}
+		// Optionally enforce strong TLS ciphers via the environment variable DOCKER_DISABLE_WEAK_CIPHERS.
+		// When set to true, weak TLS ciphers are disabled, restricting the daemon to a modern, secure
+		// subset of cipher suites.
+		if disableWeakCiphers := os.Getenv("DOCKER_DISABLE_WEAK_CIPHERS"); disableWeakCiphers != "" {
+			disable, err := strconv.ParseBool(disableWeakCiphers)
+			if err != nil {
+				return nil, errors.Wrap(err, "invalid value for DOCKER_DISABLE_WEAK_CIPHERS")
+			}
+			if disable {
+				tlsConfig.CipherSuites = slices.Clone(strongTLSCiphers)
+			}
+		}
 	}
 
 	return tlsConfig, nil

hack/validate/vendor

@@ -5,27 +5,30 @@ set -e
 SCRIPTDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPTDIR}/.validate"
 
-tidy_files=('vendor.mod' 'vendor.sum')
+modules_files=('man/go.mod' 'vendor.mod')
+tidy_files=("${modules_files[@]}" 'man/go.sum' 'vendor.sum')
 vendor_files=("${tidy_files[@]}" 'vendor/')
 
-validate_vendor_tidy() {
+validate_tidy_modules() {
+	# check that all go.mod files exist in HEAD; go.sum files are generated by 'go mod tidy'
+	# so we don't need to check for their existence beforehand
+	for f in "${modules_files[@]}"; do
+		if [ ! -f "$f" ]; then
+			echo >&2 "ERROR: missing $f"
+			return 1
+		fi
+	done
 	# run mod tidy
 	./hack/vendor.sh tidy
 	# check if any files have changed
-	git diff --quiet HEAD -- "${tidy_files[@]}"
+	git diff --quiet HEAD -- "${tidy_files[@]}" && [ -z "$(git ls-files --others --exclude-standard)" ]
 }
 
 validate_vendor_diff() {
-	mapfile -t changed_files < <(validate_diff --diff-filter=ACMR --name-only -- "${vendor_files[@]}")
-
-	if [ -n "${TEST_FORCE_VALIDATE:-}" ] || [ "${#changed_files[@]}" -gt 0 ]; then
-		# recreate vendor/
-		./hack/vendor.sh vendor
-		# check if any files have changed
-		git diff --quiet HEAD -- "${vendor_files[@]}"
-	else
-		echo >&2 'INFO: no vendor changes in diff; skipping vendor check.'
-	fi
+	# recreate vendor/
+	./hack/vendor.sh vendor
+	# check if any files have changed
+	git diff --quiet HEAD -- "${vendor_files[@]}" && [ -z "$(git ls-files --others --exclude-standard)" ]
 }
 
 validate_vendor_license() {
@@ -37,16 +40,22 @@ validate_vendor_license() {
 	done < <(awk '/^# /{ print $2 }' vendor/modules.txt)
 }
 
-if validate_vendor_tidy && validate_vendor_diff && validate_vendor_license; then
+if validate_tidy_modules && validate_vendor_diff && validate_vendor_license; then
 	echo >&2 'PASS: Vendoring has been performed correctly!'
 else
 	{
 		echo 'FAIL: Vendoring was not performed correctly!'
 		echo
-		echo 'The following files changed during re-vendor:'
-		echo
-		git diff --name-status HEAD -- "${vendor_files[@]}"
-		echo
+		if [ -n "$(git ls-files --others --exclude-standard)" ]; then
+			echo 'The following files are missing:'
+			git ls-files --others --exclude-standard
+			echo
+		fi
+		if [ -n "$(git diff --name-status HEAD -- "${vendor_files[@]}")" ]; then
+			echo 'The following files changed during re-vendor:'
+			git diff --name-status HEAD -- "${vendor_files[@]}"
+			echo
+		fi
 		echo 'Please revendor with hack/vendor.sh'
 		echo
 		git diff --diff-filter=M -- "${vendor_files[@]}"

hack/vendor.sh

@@ -7,15 +7,32 @@
 set -e
 
 SCRIPTDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPTDIR/.." && pwd)"
 
 tidy() (
+	(
 		set -x
 		"${SCRIPTDIR}"/with-go-mod.sh go mod tidy -modfile vendor.mod -compat 1.18
+	)
+
+	(
+		set -x
+		cd man
+		go mod tidy
+	)
 )
 
 vendor() (
+	(
 		set -x
 		"${SCRIPTDIR}"/with-go-mod.sh go mod vendor -modfile vendor.mod
+	)
+
+	(
+		set -x
+		cd man
+		go mod vendor
+	)
 )
 
 help() {

integration/container/copy_test.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/docker/docker/api/types"
@@ -31,6 +32,8 @@ func TestCopyFromContainerPathDoesNotExist(t *testing.T) {
 	assert.Check(t, is.ErrorContains(err, "Could not find the file /dne in container "+cid))
 }
 
+// TestCopyFromContainerPathIsNotDir tests that an error is returned when
+// trying to create a directory on a path that's a file.
 func TestCopyFromContainerPathIsNotDir(t *testing.T) {
 	skip.If(t, testEnv.UsingSnapshotter(), "FIXME: https://github.com/moby/moby/issues/47107")
 	ctx := setupTest(t)
@@ -38,14 +41,29 @@ func TestCopyFromContainerPathIsNotDir(t *testing.T) {
 	apiClient := testEnv.APIClient()
 	cid := container.Create(ctx, t, apiClient)
 
-	path := "/etc/passwd/"
-	expected := "not a directory"
+	// Pick a path that already exists as a file; on Linux "/etc/passwd"
+	// is expected to be there, so we pick that for convenience.
+	existingFile := "/etc/passwd/"
+	expected := []string{"not a directory"}
 	if testEnv.DaemonInfo.OSType == "windows" {
-		path = "c:/windows/system32/drivers/etc/hosts/"
-		expected = "The filename, directory name, or volume label syntax is incorrect."
+		existingFile = "c:/windows/system32/drivers/etc/hosts/"
+
+		// Depending on the version of Windows, this produces a "ERROR_INVALID_NAME" (Windows < 2025),
+		// or a "ERROR_DIRECTORY" (Windows 2025); https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-
+		expected = []string{
+			"The directory name is invalid.",                                     // ERROR_DIRECTORY
+			"The filename, directory name, or volume label syntax is incorrect.", // ERROR_INVALID_NAME
+		}
 	}
-	_, _, err := apiClient.CopyFromContainer(ctx, cid, path)
-	assert.Assert(t, is.ErrorContains(err, expected))
+	_, _, err := apiClient.CopyFromContainer(ctx, cid, existingFile)
+	var found bool
+	for _, expErr := range expected {
+		if err != nil && strings.Contains(err.Error(), expErr) {
+			found = true
+			break
+		}
+	}
+	assert.Check(t, found, "Expected error to be one of %v, but got %v", expected, err)
 }
 
 func TestCopyToContainerPathDoesNotExist(t *testing.T) {

integration/container/isolation_windows_test.go

@@ -0,0 +1,412 @@
+package container // import "github.com/docker/docker/integration/container"
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/mount"
+	"github.com/docker/docker/api/types/volume"
+	"github.com/docker/docker/integration/internal/container"
+	"github.com/docker/docker/testutil"
+	"gotest.tools/v3/assert"
+	is "gotest.tools/v3/assert/cmp"
+)
+
+// TestWindowsProcessIsolation validates process isolation on Windows.
+func TestWindowsProcessIsolation(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	testcases := []struct {
+		name        string
+		description string
+		validate    func(t *testing.T, ctx context.Context, id string)
+	}{
+		{
+			name:        "Process isolation basic container lifecycle",
+			description: "Validate container can start, run, and stop with process isolation",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				// Verify container is running
+				ctrInfo := container.Inspect(ctx, t, apiClient, id)
+				assert.Check(t, is.Equal(ctrInfo.State.Running, true))
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.Isolation, containertypes.IsolationProcess))
+
+				execCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+				defer cancel()
+				res := container.ExecT(execCtx, t, apiClient, id, []string{"cmd", "/c", "echo", "test"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+				assert.Check(t, strings.Contains(res.Stdout(), "test"))
+			},
+		},
+		{
+			name:        "Process isolation filesystem access",
+			description: "Validate filesystem operations work correctly with process isolation",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+				defer cancel()
+
+				// Create a test file
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"cmd", "/c", "echo test123 > C:\\testfile.txt"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+
+				// Read the test file
+				execCtx2, cancel2 := context.WithTimeout(ctx, 10*time.Second)
+				defer cancel2()
+				res2 := container.ExecT(execCtx2, t, apiClient, id,
+					[]string{"cmd", "/c", "type", "C:\\testfile.txt"})
+				assert.Check(t, is.Equal(res2.ExitCode, 0))
+				assert.Check(t, strings.Contains(res2.Stdout(), "test123"))
+			},
+		},
+		{
+			name:        "Process isolation network connectivity",
+			description: "Validate network connectivity works with process isolation",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+				defer cancel()
+
+				// Test localhost connectivity
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"ping", "-n", "1", "-w", "3000", "localhost"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+				assert.Check(t, strings.Contains(res.Stdout(), "Reply from") ||
+					strings.Contains(res.Stdout(), "Received = 1"))
+			},
+		},
+		{
+			name:        "Process isolation environment variables",
+			description: "Validate environment variables are properly isolated",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+				defer cancel()
+
+				// Check that container has expected environment variables
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"cmd", "/c", "set"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+
+				// Should have Windows-specific environment variables
+				stdout := res.Stdout()
+				assert.Check(t, strings.Contains(stdout, "COMPUTERNAME") ||
+					strings.Contains(stdout, "OS=Windows"))
+			},
+		},
+		{
+			name:        "Process isolation CPU access",
+			description: "Validate container can access CPU information",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+				defer cancel()
+
+				// Check NUMBER_OF_PROCESSORS environment variable
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"cmd", "/c", "echo", "%NUMBER_OF_PROCESSORS%"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+
+				// Should return a number
+				output := strings.TrimSpace(res.Stdout())
+				assert.Check(t, output != "" && output != "%NUMBER_OF_PROCESSORS%",
+					"NUMBER_OF_PROCESSORS not set")
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := testutil.StartSpan(ctx, t)
+
+			// Create and start container with process isolation
+			id := container.Run(ctx, t, apiClient,
+				container.WithIsolation(containertypes.IsolationProcess),
+				container.WithCmd("ping", "-t", "localhost"),
+			)
+			defer apiClient.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+			tc.validate(t, ctx, id)
+		})
+	}
+}
+
+// TestWindowsHyperVIsolation validates Hyper-V isolation on Windows.
+func TestWindowsHyperVIsolation(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	testcases := []struct {
+		name        string
+		description string
+		validate    func(t *testing.T, ctx context.Context, id string)
+	}{
+		{
+			name:        "Hyper-V isolation basic container lifecycle",
+			description: "Validate container can start, run, and stop with Hyper-V isolation",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				// Verify container is running
+				ctrInfo := container.Inspect(ctx, t, apiClient, id)
+				assert.Check(t, is.Equal(ctrInfo.State.Running, true))
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.Isolation, containertypes.IsolationHyperV))
+
+				// Execute a simple command
+				execCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+				defer cancel()
+				res := container.ExecT(execCtx, t, apiClient, id, []string{"cmd", "/c", "echo", "hyperv-test"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+				assert.Check(t, strings.Contains(res.Stdout(), "hyperv-test"))
+			},
+		},
+		{
+			name:        "Hyper-V isolation filesystem operations",
+			description: "Validate filesystem isolation with Hyper-V",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+				defer cancel()
+
+				// Test file creation
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"cmd", "/c", "echo hyperv-file > C:\\hvtest.txt"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+
+				// Test file read
+				execCtx2, cancel2 := context.WithTimeout(ctx, 15*time.Second)
+				defer cancel2()
+				res2 := container.ExecT(execCtx2, t, apiClient, id,
+					[]string{"cmd", "/c", "type", "C:\\hvtest.txt"})
+				assert.Check(t, is.Equal(res2.ExitCode, 0))
+				assert.Check(t, strings.Contains(res2.Stdout(), "hyperv-file"))
+			},
+		},
+		{
+			name:        "Hyper-V isolation network connectivity",
+			description: "Validate network works with Hyper-V isolation",
+			validate: func(t *testing.T, ctx context.Context, id string) {
+				execCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+				defer cancel()
+
+				// Test localhost connectivity
+				res := container.ExecT(execCtx, t, apiClient, id,
+					[]string{"ping", "-n", "1", "-w", "5000", "localhost"})
+				assert.Check(t, is.Equal(res.ExitCode, 0))
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := testutil.StartSpan(ctx, t)
+
+			// Create and start container with Hyper-V isolation
+			id := container.Run(ctx, t, apiClient,
+				container.WithIsolation(containertypes.IsolationHyperV),
+				container.WithCmd("ping", "-t", "localhost"),
+			)
+			defer apiClient.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+			tc.validate(t, ctx, id)
+		})
+	}
+}
+
+// TestWindowsIsolationComparison validates that both isolation modes can coexist
+// and that containers can be created with different isolation modes on Windows.
+func TestWindowsIsolationComparison(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	// Create container with process isolation
+	processID := container.Run(ctx, t, apiClient,
+		container.WithIsolation(containertypes.IsolationProcess),
+		container.WithCmd("ping", "-t", "localhost"),
+	)
+	defer apiClient.ContainerRemove(ctx, processID, containertypes.RemoveOptions{Force: true})
+
+	processInfo := container.Inspect(ctx, t, apiClient, processID)
+	assert.Check(t, is.Equal(processInfo.HostConfig.Isolation, containertypes.IsolationProcess))
+	assert.Check(t, is.Equal(processInfo.State.Running, true))
+
+	// Create container with Hyper-V isolation
+	hypervID := container.Run(ctx, t, apiClient,
+		container.WithIsolation(containertypes.IsolationHyperV),
+		container.WithCmd("ping", "-t", "localhost"),
+	)
+	defer apiClient.ContainerRemove(ctx, hypervID, containertypes.RemoveOptions{Force: true})
+
+	hypervInfo := container.Inspect(ctx, t, apiClient, hypervID)
+	assert.Check(t, is.Equal(hypervInfo.HostConfig.Isolation, containertypes.IsolationHyperV))
+	assert.Check(t, is.Equal(hypervInfo.State.Running, true))
+
+	// Verify both containers can run simultaneously
+	processInfo2 := container.Inspect(ctx, t, apiClient, processID)
+	hypervInfo2 := container.Inspect(ctx, t, apiClient, hypervID)
+	assert.Check(t, is.Equal(processInfo2.State.Running, true))
+	assert.Check(t, is.Equal(hypervInfo2.State.Running, true))
+}
+
+// TestWindowsProcessIsolationResourceConstraints validates resource constraints
+// work correctly with process isolation on Windows.
+func TestWindowsProcessIsolationResourceConstraints(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	testcases := []struct {
+		name           string
+		cpuShares      int64
+		nanoCPUs       int64
+		memoryLimit    int64
+		cpuCount       int64
+		validateConfig func(t *testing.T, ctrInfo types.ContainerJSON)
+	}{
+		{
+			name:      "CPU shares constraint - config only",
+			cpuShares: 512,
+			// Note: CPU shares are accepted by the API but NOT enforced on Windows.
+			// This test only verifies the configuration is stored correctly.
+			// Actual enforcement does not work - containers get equal CPU regardless of shares.
+			// Use NanoCPUs (--cpus flag) for actual CPU limiting on Windows.
+			validateConfig: func(t *testing.T, ctrInfo types.ContainerJSON) {
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.CPUShares, int64(512)))
+			},
+		},
+		{
+			name:     "CPU limit (NanoCPUs) constraint",
+			nanoCPUs: 2000000000, // 2.0 CPUs
+			// NanoCPUs enforce hard CPU limits on Windows (unlike CPUShares which don't work)
+			validateConfig: func(t *testing.T, ctrInfo types.ContainerJSON) {
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.NanoCPUs, int64(2000000000)))
+			},
+		},
+		{
+			name:        "Memory limit constraint",
+			memoryLimit: 512 * 1024 * 1024, // 512MB
+			// Memory limits enforce hard limits on container memory usage
+			validateConfig: func(t *testing.T, ctrInfo types.ContainerJSON) {
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.Memory, int64(512*1024*1024)))
+			},
+		},
+		{
+			name:     "CPU count constraint",
+			cpuCount: 2,
+			// CPU count limits the number of CPUs available to the container
+			validateConfig: func(t *testing.T, ctrInfo types.ContainerJSON) {
+				assert.Check(t, is.Equal(ctrInfo.HostConfig.CPUCount, int64(2)))
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := testutil.StartSpan(ctx, t)
+
+			opts := []func(*container.TestContainerConfig){
+				container.WithIsolation(containertypes.IsolationProcess),
+				container.WithCmd("ping", "-t", "localhost"),
+			}
+
+			if tc.cpuShares > 0 {
+				opts = append(opts, func(config *container.TestContainerConfig) {
+					config.HostConfig.CPUShares = tc.cpuShares
+				})
+			}
+
+			if tc.nanoCPUs > 0 {
+				opts = append(opts, func(config *container.TestContainerConfig) {
+					config.HostConfig.NanoCPUs = tc.nanoCPUs
+				})
+			}
+
+			if tc.memoryLimit > 0 {
+				opts = append(opts, func(config *container.TestContainerConfig) {
+					config.HostConfig.Memory = tc.memoryLimit
+				})
+			}
+
+			if tc.cpuCount > 0 {
+				opts = append(opts, func(config *container.TestContainerConfig) {
+					config.HostConfig.CPUCount = tc.cpuCount
+				})
+			}
+
+			id := container.Run(ctx, t, apiClient, opts...)
+			defer apiClient.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+			ctrInfo := container.Inspect(ctx, t, apiClient, id)
+			tc.validateConfig(t, ctrInfo)
+		})
+	}
+}
+
+// TestWindowsProcessIsolationVolumeMount validates volume mounting with process isolation on Windows.
+func TestWindowsProcessIsolationVolumeMount(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	volumeName := "process-iso-test-volume"
+	volRes, err := apiClient.VolumeCreate(ctx, volume.CreateOptions{
+		Name: volumeName,
+	})
+	assert.NilError(t, err)
+	defer func() {
+		// Force volume removal in case container cleanup fails
+		apiClient.VolumeRemove(ctx, volRes.Name, true)
+	}()
+
+	// Create container with volume mount
+	id := container.Run(ctx, t, apiClient,
+		container.WithIsolation(containertypes.IsolationProcess),
+		container.WithCmd("ping", "-t", "localhost"),
+		container.WithMount(mount.Mount{
+			Type:   mount.TypeVolume,
+			Source: volumeName,
+			Target: "C:\\data",
+		}),
+	)
+	defer apiClient.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+	// Write data to mounted volume
+	execCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	res := container.ExecT(execCtx, t, apiClient, id,
+		[]string{"cmd", "/c", "echo volume-test > C:\\data\\test.txt"})
+	assert.Check(t, is.Equal(res.ExitCode, 0))
+
+	// Read data from mounted volume
+	execCtx2, cancel2 := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel2()
+	res2 := container.ExecT(execCtx2, t, apiClient, id,
+		[]string{"cmd", "/c", "type", "C:\\data\\test.txt"})
+	assert.Check(t, is.Equal(res2.ExitCode, 0))
+	assert.Check(t, strings.Contains(res2.Stdout(), "volume-test"))
+
+	// Verify container has volume mount
+	ctrInfo := container.Inspect(ctx, t, apiClient, id)
+	assert.Check(t, len(ctrInfo.Mounts) == 1)
+	assert.Check(t, is.Equal(ctrInfo.Mounts[0].Type, mount.TypeVolume))
+	assert.Check(t, is.Equal(ctrInfo.Mounts[0].Name, volumeName))
+}
+
+// TestWindowsHyperVIsolationResourceLimits validates resource limits work with Hyper-V isolation.
+// This ensures Windows can properly enforce resource constraints on Hyper-V containers.
+func TestWindowsHyperVIsolationResourceLimits(t *testing.T) {
+	ctx := setupTest(t)
+	apiClient := testEnv.APIClient()
+
+	// Create container with memory limit
+	memoryLimit := int64(512 * 1024 * 1024) // 512MB
+	id := container.Run(ctx, t, apiClient,
+		container.WithIsolation(containertypes.IsolationHyperV),
+		container.WithCmd("ping", "-t", "localhost"),
+		func(config *container.TestContainerConfig) {
+			config.HostConfig.Memory = memoryLimit
+		},
+	)
+	defer apiClient.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+	// Verify resource limit is set
+	ctrInfo := container.Inspect(ctx, t, apiClient, id)
+	assert.Check(t, is.Equal(ctrInfo.HostConfig.Memory, memoryLimit))
+	assert.Check(t, is.Equal(ctrInfo.HostConfig.Isolation, containertypes.IsolationHyperV))
+}

integration/networking/bridge_test.go

@@ -238,7 +238,7 @@ func TestBridgeICCWindows(t *testing.T) {
 			pingCmd := []string{"ping", "-n", "1", "-w", "3000", ctr1Name}
 
 			const ctr2Name = "ctr2"
-			attachCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+			attachCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
 			defer cancel()
 			res := container.RunAttach(attachCtx, t, c,
 				container.WithName(ctr2Name),

integration/networking/drivers_windows_test.go

@@ -0,0 +1,378 @@
+package networking
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/integration/internal/container"
+	"github.com/docker/docker/integration/internal/network"
+	"github.com/docker/docker/testutil"
+	"github.com/docker/go-connections/nat"
+	"gotest.tools/v3/assert"
+	is "gotest.tools/v3/assert/cmp"
+	"gotest.tools/v3/poll"
+	"gotest.tools/v3/skip"
+)
+
+// TestWindowsNetworkDrivers validates Windows-specific network drivers for Windows.
+// Tests: NAT, Transparent, and L2Bridge network drivers.
+func TestWindowsNetworkDrivers(t *testing.T) {
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	testcases := []struct {
+		name   string
+		driver string
+	}{
+		{
+			// NAT connectivity is already tested in TestBridgeICCWindows (bridge_test.go),
+			// so we only validate network creation here.
+			name:   "NAT driver network creation",
+			driver: "nat",
+		},
+		{
+			// Only test creation of a Transparent driver network, connectivity depends on external
+			// network infrastructure.
+			name:   "Transparent driver network creation",
+			driver: "transparent",
+		},
+		{
+			// L2Bridge driver requires specific host network adapter configuration, test will skip
+			// if host configuration is missing.
+			name:   "L2Bridge driver network creation",
+			driver: "l2bridge",
+		},
+	}
+
+	for tcID, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := testutil.StartSpan(ctx, t)
+
+			netName := fmt.Sprintf("test-%s-%d", tc.driver, tcID)
+
+			// Create network with specified driver
+			netResp, err := c.NetworkCreate(ctx, netName, types.NetworkCreate{
+				Driver: tc.driver,
+			})
+			if err != nil {
+				// L2Bridge may fail if host network configuration is not available
+				if tc.driver == "l2bridge" {
+					errStr := strings.ToLower(err.Error())
+					if strings.Contains(errStr, "the network does not have a subnet for this endpoint") {
+						t.Skipf("Driver %s requires host network configuration: %v", tc.driver, err)
+					}
+				}
+				t.Fatalf("Failed to create network with %s driver: %v", tc.driver, err)
+			}
+			defer network.RemoveNoError(ctx, t, c, netName)
+
+			// Inspect network to validate driver is correctly set
+			netInfo, err := c.NetworkInspect(ctx, netResp.ID, types.NetworkInspectOptions{})
+			assert.NilError(t, err)
+			assert.Check(t, is.Equal(netInfo.Driver, tc.driver), "Network driver mismatch")
+			assert.Check(t, is.Equal(netInfo.Name, netName), "Network name mismatch")
+		})
+	}
+}
+
+// TestWindowsNATDriverPortMapping validates NAT port mapping by testing host connectivity.
+func TestWindowsNATDriverPortMapping(t *testing.T) {
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	// Use default NAT network which supports port mapping
+	netName := "nat"
+
+	// PowerShell HTTP listener on port 80
+	psScript := `
+		$listener = New-Object System.Net.HttpListener
+		$listener.Prefixes.Add('http://+:80/')
+		$listener.Start()
+		while ($listener.IsListening) {
+			$context = $listener.GetContext()
+			$response = $context.Response
+			$content = [System.Text.Encoding]::UTF8.GetBytes('OK')
+			$response.ContentLength64 = $content.Length
+			$response.OutputStream.Write($content, 0, $content.Length)
+			$response.OutputStream.Close()
+		}
+	`
+
+	// Create container with port mapping 80->8080
+	ctrName := "port-mapping-test"
+	id := container.Run(ctx, t, c,
+		container.WithName(ctrName),
+		container.WithCmd("powershell", "-Command", psScript),
+		container.WithNetworkMode(netName),
+		container.WithExposedPorts("80/tcp"),
+		container.WithPortMap(nat.PortMap{
+			"80/tcp": []nat.PortBinding{{HostPort: "8080"}},
+		}),
+	)
+	defer c.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+	// Verify port mapping metadata
+	ctrInfo := container.Inspect(ctx, t, c, id)
+	portKey := nat.Port("80/tcp")
+	assert.Check(t, ctrInfo.NetworkSettings.Ports[portKey] != nil, "Port mapping not found")
+	assert.Check(t, len(ctrInfo.NetworkSettings.Ports[portKey]) > 0, "No host port binding")
+	assert.Check(t, is.Equal(ctrInfo.NetworkSettings.Ports[portKey][0].HostPort, "8080"))
+
+	// Test actual connectivity from host to container via mapped port
+	httpClient := &http.Client{Timeout: 2 * time.Second}
+	checkHTTP := func(t poll.LogT) poll.Result {
+		resp, err := httpClient.Get("http://localhost:8080")
+		if err != nil {
+			return poll.Continue("connection failed: %v", err)
+		}
+		defer resp.Body.Close()
+
+		body, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return poll.Continue("failed to read body: %v", err)
+		}
+
+		if !strings.Contains(string(body), "OK") {
+			return poll.Continue("unexpected response body: %s", string(body))
+		}
+		return poll.Success()
+	}
+
+	poll.WaitOn(t, checkHTTP, poll.WithTimeout(10*time.Second))
+}
+
+// TestWindowsNetworkDNSResolution validates DNS resolution on Windows networks.
+func TestWindowsNetworkDNSResolution(t *testing.T) {
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	testcases := []struct {
+		name       string
+		driver     string
+		customDNS  bool
+		dnsServers []string
+	}{
+		{
+			name:   "Default NAT network DNS resolution",
+			driver: "nat",
+		},
+		{
+			name:       "Custom DNS servers on NAT network",
+			driver:     "nat",
+			customDNS:  true,
+			dnsServers: []string{"8.8.8.8", "8.8.4.4"},
+		},
+	}
+
+	for tcID, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := testutil.StartSpan(ctx, t)
+
+			netName := fmt.Sprintf("test-dns-%s-%d", tc.driver, tcID)
+
+			// Create network with optional custom DNS
+			netOpts := []func(*types.NetworkCreate){
+				network.WithDriver(tc.driver),
+			}
+			if tc.customDNS {
+				// Note: DNS options may need to be set via network options on Windows
+				for _, dns := range tc.dnsServers {
+					netOpts = append(netOpts, network.WithOption("com.docker.network.windowsshim.dnsservers", dns))
+				}
+			}
+
+			network.CreateNoError(ctx, t, c, netName, netOpts...)
+			defer network.RemoveNoError(ctx, t, c, netName)
+
+			// Create container and verify DNS resolution
+			ctrName := fmt.Sprintf("dns-test-%d", tcID)
+			id := container.Run(ctx, t, c,
+				container.WithName(ctrName),
+				container.WithNetworkMode(netName),
+			)
+			defer c.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+			// Test DNS resolution by pinging container by name from another container
+			pingCmd := []string{"ping", "-n", "1", "-w", "3000", ctrName}
+
+			attachCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+			defer cancel()
+			res := container.RunAttach(attachCtx, t, c,
+				container.WithCmd(pingCmd...),
+				container.WithNetworkMode(netName),
+			)
+			defer c.ContainerRemove(ctx, res.ContainerID, containertypes.RemoveOptions{Force: true})
+
+			assert.Check(t, is.Equal(res.ExitCode, 0), "DNS resolution failed")
+			assert.Check(t, is.Contains(res.Stdout.String(), "Sent = 1, Received = 1, Lost = 0"))
+		})
+	}
+}
+
+// TestWindowsNetworkLifecycle validates network lifecycle operations on Windows.
+// Tests network creation, container attachment, detachment, and deletion.
+func TestWindowsNetworkLifecycle(t *testing.T) {
+	// Skip this test on Windows Containerd because NetworkConnect operations fail with an
+	// unsupported platform request error:
+	// https://github.com/moby/moby/issues/51589
+	skip.If(t, testEnv.RuntimeIsWindowsContainerd(),
+		"Skipping test: fails on Containerd due to unsupported platform request error during NetworkConnect operations")
+
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	netName := "lifecycle-test-nat"
+
+	netID := network.CreateNoError(ctx, t, c, netName,
+		network.WithDriver("nat"),
+	)
+
+	netInfo, err := c.NetworkInspect(ctx, netID, types.NetworkInspectOptions{})
+	assert.NilError(t, err)
+	assert.Check(t, is.Equal(netInfo.Name, netName))
+
+	// Create container on network
+	ctrName := "lifecycle-ctr"
+	id := container.Run(ctx, t, c,
+		container.WithName(ctrName),
+		container.WithNetworkMode(netName),
+	)
+
+	ctrInfo := container.Inspect(ctx, t, c, id)
+	assert.Check(t, ctrInfo.NetworkSettings.Networks[netName] != nil)
+
+	// Disconnect container from network
+	err = c.NetworkDisconnect(ctx, netID, id, false)
+	assert.NilError(t, err)
+
+	ctrInfo = container.Inspect(ctx, t, c, id)
+	assert.Check(t, ctrInfo.NetworkSettings.Networks[netName] == nil, "Container still connected after disconnect")
+
+	// Reconnect container to network
+	err = c.NetworkConnect(ctx, netID, id, nil)
+	assert.NilError(t, err)
+
+	ctrInfo = container.Inspect(ctx, t, c, id)
+	assert.Check(t, ctrInfo.NetworkSettings.Networks[netName] != nil, "Container not reconnected")
+
+	c.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+
+	network.RemoveNoError(ctx, t, c, netName)
+
+	_, err = c.NetworkInspect(ctx, netID, types.NetworkInspectOptions{})
+	assert.Check(t, err != nil, "Network still exists after deletion")
+}
+
+// TestWindowsNetworkIsolation validates network isolation between containers on different networks.
+// Ensures containers on different networks cannot communicate, validating Windows network driver isolation.
+func TestWindowsNetworkIsolation(t *testing.T) {
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	// Create two separate NAT networks
+	net1Name := "isolation-net1"
+	net2Name := "isolation-net2"
+
+	network.CreateNoError(ctx, t, c, net1Name, network.WithDriver("nat"))
+	defer network.RemoveNoError(ctx, t, c, net1Name)
+
+	network.CreateNoError(ctx, t, c, net2Name, network.WithDriver("nat"))
+	defer network.RemoveNoError(ctx, t, c, net2Name)
+
+	// Create container on first network
+	ctr1Name := "isolated-ctr1"
+	id1 := container.Run(ctx, t, c,
+		container.WithName(ctr1Name),
+		container.WithNetworkMode(net1Name),
+	)
+	defer c.ContainerRemove(ctx, id1, containertypes.RemoveOptions{Force: true})
+
+	ctr1Info := container.Inspect(ctx, t, c, id1)
+	ctr1IP := ctr1Info.NetworkSettings.Networks[net1Name].IPAddress
+	assert.Check(t, ctr1IP != "", "Container IP not assigned")
+
+	// Create container on second network and try to ping first container
+	pingCmd := []string{"ping", "-n", "1", "-w", "2000", ctr1IP}
+
+	attachCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+	defer cancel()
+	res := container.RunAttach(attachCtx, t, c,
+		container.WithCmd(pingCmd...),
+		container.WithNetworkMode(net2Name),
+	)
+	defer c.ContainerRemove(ctx, res.ContainerID, containertypes.RemoveOptions{Force: true})
+
+	// Ping should fail, demonstrating network isolation
+	assert.Check(t, res.ExitCode != 0, "Ping succeeded unexpectedly - networks are not isolated")
+	// Windows ping failure can have various error messages, but we should see some indication of failure
+	stdout := res.Stdout.String()
+	stderr := res.Stderr.String()
+
+	// Check for common Windows ping failure indicators
+	hasFailureIndicator := strings.Contains(stdout, "Destination host unreachable") ||
+		strings.Contains(stdout, "Request timed out") ||
+		strings.Contains(stdout, "100% loss") ||
+		strings.Contains(stdout, "Lost = 1") ||
+		strings.Contains(stderr, "unreachable") ||
+		strings.Contains(stderr, "timeout")
+
+	assert.Check(t, hasFailureIndicator,
+		"Expected ping failure indicators not found. Exit code: %d, stdout: %q, stderr: %q",
+		res.ExitCode, stdout, stderr)
+}
+
+// TestWindowsNetworkEndpointManagement validates endpoint creation and management on Windows networks.
+// Tests that multiple containers can be created and managed on the same network.
+func TestWindowsNetworkEndpointManagement(t *testing.T) {
+	ctx := setupTest(t)
+	c := testEnv.APIClient()
+
+	netName := "endpoint-test-nat"
+	network.CreateNoError(ctx, t, c, netName, network.WithDriver("nat"))
+	defer network.RemoveNoError(ctx, t, c, netName)
+
+	// Create multiple containers on the same network
+	const numContainers = 3
+	containerIDs := make([]string, numContainers)
+
+	for i := 0; i < numContainers; i++ {
+		ctrName := fmt.Sprintf("endpoint-ctr-%d", i)
+		id := container.Run(ctx, t, c,
+			container.WithName(ctrName),
+			container.WithNetworkMode(netName),
+		)
+		containerIDs[i] = id
+		defer c.ContainerRemove(ctx, id, containertypes.RemoveOptions{Force: true})
+	}
+
+	netInfo, err := c.NetworkInspect(ctx, netName, types.NetworkInspectOptions{})
+	assert.NilError(t, err)
+	assert.Check(t, is.Equal(len(netInfo.Containers), numContainers),
+		"Expected %d containers, got %d", numContainers, len(netInfo.Containers))
+
+	// Verify each container has network connectivity to others
+	for i := 0; i < numContainers-1; i++ {
+		targetName := fmt.Sprintf("endpoint-ctr-%d", i)
+		pingCmd := []string{"ping", "-n", "1", "-w", "3000", targetName}
+
+		sourceName := fmt.Sprintf("endpoint-ctr-%d", i+1)
+		attachCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+		defer cancel()
+		res := container.RunAttach(attachCtx, t, c,
+			container.WithName(fmt.Sprintf("%s-pinger", sourceName)),
+			container.WithCmd(pingCmd...),
+			container.WithNetworkMode(netName),
+		)
+		defer c.ContainerRemove(ctx, res.ContainerID, containertypes.RemoveOptions{Force: true})
+
+		assert.Check(t, is.Equal(res.ExitCode, 0),
+			"Container %s failed to ping %s", sourceName, targetName)
+	}
+}

vendor.mod

@@ -65,7 +65,7 @@ require (
 	github.com/moby/locker v1.0.1
 	github.com/moby/patternmatcher v0.6.0
 	github.com/moby/pubsub v1.0.0
-	github.com/moby/swarmkit/v2 v2.0.0
+	github.com/moby/swarmkit/v2 v2.1.1
 	github.com/moby/sys/mount v0.3.3
 	github.com/moby/sys/mountinfo v0.7.1
 	github.com/moby/sys/sequential v0.5.0

vendor.sum

@@ -918,8 +918,8 @@ github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkV
 github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
 github.com/moby/pubsub v1.0.0 h1:jkp/imWsmJz2f6LyFsk7EkVeN2HxR/HTTOY8kHrsxfA=
 github.com/moby/pubsub v1.0.0/go.mod h1:bXSO+3h5MNXXCaEG+6/NlAIk7MMZbySZlnB+cUQhKKc=
-github.com/moby/swarmkit/v2 v2.0.0 h1:jkWQKQaJ4ltA61/mC9UdPe1McLma55RUcacTO+pPweY=
-github.com/moby/swarmkit/v2 v2.0.0/go.mod h1:mTTGIAz/59OGZR5Qe+QByIe3Nxc+sSuJkrsStFhr6Lg=
+github.com/moby/swarmkit/v2 v2.1.1 h1:yvTJ8MMCc3f0qTA44J6R59EZ5yZawdYopkpuLk4+ICU=
+github.com/moby/swarmkit/v2 v2.1.1/go.mod h1:mTTGIAz/59OGZR5Qe+QByIe3Nxc+sSuJkrsStFhr6Lg=
 github.com/moby/sys/mount v0.1.0/go.mod h1:FVQFLDRWwyBjDTBNQXDlWnSFREqOo3OKX9aqhmeoo74=
 github.com/moby/sys/mount v0.1.1/go.mod h1:FVQFLDRWwyBjDTBNQXDlWnSFREqOo3OKX9aqhmeoo74=
 github.com/moby/sys/mount v0.3.3 h1:fX1SVkXFJ47XWDoeFW4Sq7PdQJnV2QIDZAqjNqgEjUs=

vendor/github.com/moby/swarmkit/v2/api/api.pb.txt

@@ -7215,6 +7215,14 @@ file {
       type: TYPE_BOOL
       json_name: "pendingDelete"
     }
+    field {
+      name: "extra"
+      number: 7
+      label: LABEL_OPTIONAL
+      type: TYPE_MESSAGE
+      type_name: ".google.protobuf.Any"
+      json_name: "extra"
+    }
     options {
       70001 {
         1 {
@@ -8296,6 +8304,14 @@ file {
       type: TYPE_STRING
       json_name: "networkId"
     }
+    field {
+      name: "appdata"
+      number: 3
+      label: LABEL_OPTIONAL
+      type: TYPE_MESSAGE
+      type_name: ".google.protobuf.Any"
+      json_name: "appdata"
+    }
   }
   message_type {
     name: "GetNetworkResponse"
@@ -8338,6 +8354,14 @@ file {
       type_name: ".docker.swarmkit.v1.ListNetworksRequest.Filters"
       json_name: "filters"
     }
+    field {
+      name: "appdata"
+      number: 2
+      label: LABEL_OPTIONAL
+      type: TYPE_MESSAGE
+      type_name: ".google.protobuf.Any"
+      json_name: "appdata"
+    }
     nested_type {
       name: "Filters"
       field {

vendor/github.com/moby/swarmkit/v2/api/control.pb.go

@@ -1285,6 +1285,8 @@ var xxx_messageInfo_CreateNetworkResponse proto.InternalMessageInfo
 type GetNetworkRequest struct {
 	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 	NetworkID string `protobuf:"bytes,2,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
+	// Application-specific message for the NetworkAllocator's OnGetNetwork callback.
+	Appdata *types.Any `protobuf:"bytes,3,opt,name=appdata,proto3" json:"appdata,omitempty"`
 }
 
 func (m *GetNetworkRequest) Reset()      { *m = GetNetworkRequest{} }
@@ -1429,6 +1431,8 @@ var xxx_messageInfo_RemoveNetworkResponse proto.InternalMessageInfo
 
 type ListNetworksRequest struct {
 	Filters *ListNetworksRequest_Filters `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"`
+	// Application-specific message for the NetworkAllocator's OnGetNetwork callback.
+	Appdata *types.Any `protobuf:"bytes,2,opt,name=appdata,proto3" json:"appdata,omitempty"`
 }
 
 func (m *ListNetworksRequest) Reset()      { *m = ListNetworksRequest{} }
@@ -3859,195 +3863,197 @@ func init() {
 }
 
 var fileDescriptor_b37401dd08bf8930 = []byte{
-	// 3006 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
-	0xf1, 0xe7, 0x3e, 0xc8, 0xdd, 0xad, 0xe5, 0x4b, 0x2d, 0x4a, 0x5e, 0xaf, 0xfd, 0x27, 0x85, 0x91,
-	0x25, 0xad, 0xf4, 0x57, 0x76, 0x6d, 0x3a, 0x8e, 0x15, 0x3f, 0x92, 0x88, 0xa2, 0x2c, 0xaf, 0x65,
-	0x4b, 0xc6, 0x50, 0x12, 0x92, 0x43, 0x40, 0x2c, 0x77, 0x5b, 0xf4, 0x98, 0xcb, 0x99, 0xcd, 0xcc,
-	0xac, 0x6c, 0x22, 0x48, 0x90, 0x87, 0x73, 0x0c, 0x90, 0x4b, 0x90, 0x20, 0x87, 0x00, 0x39, 0x05,
-	0x48, 0x80, 0x20, 0xc8, 0x21, 0xc8, 0x21, 0x1f, 0xc0, 0xc8, 0xc9, 0x47, 0x5f, 0xc2, 0xc4, 0x34,
-	0x02, 0xe4, 0x94, 0xaf, 0x90, 0x60, 0xba, 0xab, 0xe7, 0xb5, 0x3d, 0x3d, 0xb3, 0x0f, 0x80, 0x3e,
-	0x91, 0xdb, 0xf3, 0xab, 0xae, 0xea, 0xae, 0x9a, 0x5f, 0xf5, 0x74, 0x15, 0x5c, 0xdf, 0x37, 0xdc,
-	0xf7, 0x86, 0x7b, 0xcd, 0xae, 0x75, 0xd8, 0xea, 0x59, 0xdd, 0x03, 0x6a, 0xb7, 0x9c, 0x0f, 0x3a,
-	0xf6, 0xe1, 0x81, 0xe1, 0xb6, 0x3a, 0x03, 0xa3, 0xd5, 0xb5, 0x4c, 0xd7, 0xb6, 0xfa, 0xcd, 0x81,
-	0x6d, 0xb9, 0x16, 0x21, 0x1c, 0xd2, 0x14, 0x90, 0xe6, 0x93, 0x17, 0xea, 0xd7, 0x52, 0x66, 0x70,
-	0x06, 0xb4, 0xeb, 0x70, 0xf9, 0x7a, 0x9a, 0x36, 0x6b, 0xef, 0x7d, 0xda, 0x75, 0x05, 0x3a, 0x6d,
-	0x66, 0xf7, 0x68, 0x40, 0x05, 0x76, 0x6d, 0xdf, 0xda, 0xb7, 0xd8, 0xbf, 0x2d, 0xef, 0x3f, 0x1c,
-	0x7d, 0x7a, 0xdf, 0xb2, 0xf6, 0xfb, 0xb4, 0xc5, 0x7e, 0xed, 0x0d, 0x1f, 0xb7, 0x3a, 0xe6, 0x11,
-	0x3e, 0x7a, 0x59, 0x31, 0xb9, 0x0f, 0x1f, 0xf4, 0x87, 0xfb, 0x86, 0x89, 0x7f, 0xb8, 0xa0, 0xf6,
-	0x12, 0x2c, 0xdf, 0xa1, 0xee, 0x3d, 0xab, 0x47, 0x75, 0xfa, 0x9d, 0x21, 0x75, 0x5c, 0x72, 0x11,
-	0x4a, 0xa6, 0xd5, 0xa3, 0xbb, 0x46, 0xaf, 0x96, 0xbb, 0x90, 0x6b, 0x54, 0xb6, 0xe0, 0xe4, 0x78,
-	0x63, 0xc1, 0x43, 0xb4, 0xb7, 0xf5, 0x05, 0xef, 0x51, 0xbb, 0xa7, 0x7d, 0x1d, 0x56, 0x7c, 0x31,
-	0x67, 0x60, 0x99, 0x0e, 0x25, 0xd7, 0xa1, 0xe8, 0x3d, 0x64, 0x42, 0xd5, 0xcd, 0x5a, 0x73, 0x74,
-	0x73, 0x9b, 0x0c, 0xcf, 0x50, 0xda, 0x47, 0xf3, 0xb0, 0xfa, 0xb6, 0xe1, 0xb0, 0x29, 0x1c, 0xa1,
-	0xfa, 0x0d, 0x28, 0x3d, 0x36, 0xfa, 0x2e, 0xb5, 0x1d, 0x9c, 0xe5, 0xba, 0x6c, 0x96, 0xb8, 0x58,
-	0xf3, 0x0d, 0x2e, 0xa3, 0x0b, 0xe1, 0xfa, 0x6f, 0x8b, 0x50, 0xc2, 0x41, 0xb2, 0x06, 0xf3, 0x66,
-	0xe7, 0x90, 0x7a, 0x33, 0x16, 0x1a, 0x15, 0x9d, 0xff, 0x20, 0x2d, 0xa8, 0x1a, 0xbd, 0xdd, 0x81,
-	0x4d, 0x1f, 0x1b, 0x1f, 0x52, 0xa7, 0x96, 0xf7, 0x9e, 0x6d, 0x2d, 0x9f, 0x1c, 0x6f, 0x40, 0x7b,
-	0xfb, 0x5d, 0x1c, 0xd5, 0xc1, 0xe8, 0x89, 0xff, 0xc9, 0xbb, 0xb0, 0xd0, 0xef, 0xec, 0xd1, 0xbe,
-	0x53, 0x2b, 0x5c, 0x28, 0x34, 0xaa, 0x9b, 0x37, 0xc6, 0xb1, 0xac, 0xf9, 0x36, 0x13, 0xbd, 0x6d,
-	0xba, 0xf6, 0x91, 0x8e, 0xf3, 0x90, 0x6f, 0x43, 0x95, 0xed, 0x33, 0x4e, 0x5b, 0x62, 0xd3, 0xbe,
-	0x36, 0xd6, 0xb4, 0xde, 0x60, 0x78, 0x6a, 0x30, 0xfd, 0x01, 0xf2, 0x0e, 0x54, 0x0f, 0xe9, 0xe1,
-	0x1e, 0xb5, 0x9d, 0xf7, 0x8c, 0x81, 0x53, 0x2b, 0x5e, 0x28, 0x34, 0x96, 0x37, 0xaf, 0x24, 0x79,
-	0x65, 0x67, 0x40, 0xbb, 0xcd, 0x77, 0x7c, 0xfc, 0x56, 0x7e, 0x75, 0x4e, 0x0f, 0xcb, 0x93, 0xaf,
-	0xc0, 0xbc, 0x6d, 0xf5, 0xa9, 0x53, 0x9b, 0x67, 0x13, 0x3d, 0x9b, 0xe8, 0x5e, 0xab, 0x4f, 0x99,
-	0x34, 0x87, 0x93, 0x8b, 0xb0, 0xe4, 0xed, 0x78, 0xb0, 0xd5, 0x0b, 0xcc, 0x0d, 0x8b, 0xde, 0xa0,
-	0xd8, 0xdc, 0xfa, 0x57, 0xa1, 0x1a, 0x5a, 0x06, 0x59, 0x85, 0xc2, 0x01, 0x3d, 0xe2, 0xd1, 0xa7,
-	0x7b, 0xff, 0x7a, 0x4e, 0x7c, 0xd2, 0xe9, 0x0f, 0x69, 0x2d, 0xcf, 0xc6, 0xf8, 0x8f, 0x57, 0xf2,
-	0x37, 0x72, 0xf5, 0xd7, 0x61, 0x25, 0xb6, 0x0b, 0xe3, 0x88, 0x6b, 0xb7, 0xe0, 0x4c, 0x68, 0x77,
-	0x31, 0x92, 0x9b, 0x30, 0xef, 0x6d, 0x24, 0x0f, 0x19, 0x55, 0x28, 0x73, 0x98, 0xf6, 0xbb, 0x1c,
-	0x9c, 0x79, 0x38, 0xe8, 0x75, 0x5c, 0x3a, 0xee, 0x7b, 0x44, 0xbe, 0x06, 0x8b, 0x0c, 0xf4, 0x84,
-	0xda, 0x8e, 0x61, 0x99, 0xcc, 0xc0, 0xea, 0xe6, 0x33, 0x32, 0x8d, 0x8f, 0x38, 0x44, 0x67, 0x51,
-	0x83, 0x3f, 0xc8, 0xf3, 0x50, 0xf4, 0x18, 0xa9, 0x56, 0x60, 0x72, 0xcf, 0xaa, 0xdc, 0xab, 0x33,
-	0xa4, 0xb6, 0x05, 0x24, 0x6c, 0xeb, 0x44, 0x2f, 0xef, 0x3d, 0x38, 0xa3, 0xd3, 0x43, 0xeb, 0xc9,
-	0xf8, 0xeb, 0x5d, 0x83, 0xf9, 0xc7, 0x96, 0xdd, 0xe5, 0x9e, 0x28, 0xeb, 0xfc, 0x87, 0xb6, 0x06,
-	0x24, 0x3c, 0x1f, 0xb7, 0x09, 0xa9, 0xe9, 0x41, 0xc7, 0x39, 0x08, 0xa9, 0x70, 0x3b, 0xce, 0x41,
-	0x4c, 0x85, 0x87, 0xf0, 0x54, 0x78, 0x8f, 0x7c, 0x6a, 0xe2, 0x62, 0xc1, 0xea, 0xbc, 0x87, 0xaa,
-	0xd5, 0x31, 0x3c, 0x43, 0x69, 0x37, 0xc4, 0xea, 0xc6, 0x56, 0xed, 0xaf, 0x23, 0xac, 0x5d, 0xfb,
-	0x6b, 0x91, 0x53, 0x9d, 0x37, 0x38, 0x01, 0xd5, 0x85, 0xc5, 0x46, 0xa9, 0xee, 0x1f, 0x85, 0xd3,
-	0xa3, 0x3a, 0x99, 0x65, 0x52, 0xaa, 0x6b, 0x41, 0xd5, 0xa1, 0xf6, 0x13, 0xa3, 0xeb, 0x45, 0x07,
-	0xe7, 0x22, 0x34, 0x61, 0x87, 0x0f, 0xb7, 0xb7, 0x1d, 0x1d, 0x10, 0xd2, 0xee, 0x39, 0xe4, 0x32,
-	0x94, 0x31, 0x96, 0x38, 0xe1, 0x54, 0xb6, 0xaa, 0x27, 0xc7, 0x1b, 0x25, 0x1e, 0x4c, 0x8e, 0x5e,
-	0xe2, 0xd1, 0xe4, 0x90, 0x37, 0x61, 0xb9, 0x47, 0x1d, 0xc3, 0xa6, 0xbd, 0x5d, 0xc7, 0xed, 0xb8,
-	0x48, 0x2f, 0xcb, 0x9b, 0xff, 0x97, 0xe4, 0xe2, 0x1d, 0x0f, 0xc5, 0xf8, 0x69, 0x09, 0x05, 0xd9,
-	0x88, 0x84, 0xa7, 0x4a, 0xa3, 0x3c, 0x45, 0xea, 0x50, 0xb6, 0x87, 0xa6, 0x6b, 0x78, 0x7b, 0x5c,
-	0x61, 0xcf, 0xfd, 0xdf, 0xe4, 0x59, 0x80, 0xe1, 0x60, 0xd7, 0xb5, 0x76, 0xbd, 0x77, 0xab, 0x56,
-	0x66, 0xe1, 0x5d, 0x1e, 0x0e, 0x1e, 0x58, 0xdb, 0x1d, 0x97, 0x4e, 0xc1, 0x70, 0x82, 0xa2, 0x70,
-	0xb3, 0x03, 0x8a, 0xf2, 0x62, 0x4e, 0x49, 0x51, 0x2c, 0x08, 0x39, 0x4c, 0xbb, 0x0b, 0x6b, 0xb7,
-	0x6c, 0xda, 0x71, 0x29, 0x6e, 0xb8, 0x08, 0xc3, 0x17, 0x91, 0x3f, 0x78, 0x0c, 0x6e, 0xc8, 0xa6,
-	0x41, 0x89, 0x10, 0x85, 0xdc, 0x83, 0x73, 0xb1, 0xc9, 0xd0, 0xaa, 0x97, 0xa0, 0x84, 0x4e, 0xc4,
-	0x09, 0x9f, 0x51, 0x4c, 0xa8, 0x0b, 0xac, 0xf6, 0x3e, 0x9c, 0xb9, 0x43, 0xdd, 0x98, 0x65, 0xd7,
-	0x01, 0x82, 0x98, 0xc1, 0x77, 0x6e, 0xe9, 0xe4, 0x78, 0xa3, 0xe2, 0x87, 0x8c, 0x5e, 0xf1, 0x23,
-	0x86, 0x5c, 0x81, 0x15, 0xc3, 0x74, 0xa8, 0xed, 0xee, 0xf6, 0xe8, 0xe3, 0xce, 0xb0, 0xef, 0x3a,
-	0xc8, 0x30, 0xcb, 0x7c, 0x78, 0x1b, 0x47, 0xb5, 0xbb, 0x40, 0xc2, 0xba, 0xa6, 0x33, 0xfc, 0x4f,
-	0x79, 0x58, 0xe3, 0x64, 0x3a, 0x95, 0xf1, 0xdb, 0xb0, 0x22, 0xd0, 0x63, 0xe4, 0x81, 0x65, 0x94,
-	0x11, 0xa9, 0xe0, 0xc5, 0x48, 0x2a, 0xc8, 0xe6, 0x4a, 0xf2, 0x0e, 0x94, 0x6d, 0xab, 0xdf, 0xdf,
-	0xeb, 0x74, 0x0f, 0x6a, 0xc5, 0x0b, 0xb9, 0xc6, 0xf2, 0xe6, 0x0b, 0x32, 0x41, 0xd9, 0x22, 0x9b,
-	0x3a, 0x0a, 0xea, 0xfe, 0x14, 0x9a, 0x06, 0x65, 0x31, 0x4a, 0xca, 0x50, 0xbc, 0x77, 0xff, 0xde,
-	0xed, 0xd5, 0x39, 0xb2, 0x08, 0xe5, 0x77, 0xf5, 0xdb, 0x8f, 0xda, 0xf7, 0x1f, 0xee, 0xac, 0xe6,
-	0xbc, 0xe8, 0x89, 0x4d, 0x37, 0x9d, 0x13, 0xb6, 0x61, 0x8d, 0x93, 0xee, 0x34, 0x3e, 0xd0, 0x9e,
-	0x82, 0x73, 0xb1, 0x59, 0x90, 0xbd, 0x3f, 0x2a, 0xc0, 0x59, 0xef, 0xfd, 0xc3, 0x71, 0x9f, 0xc0,
-	0xdb, 0x71, 0x02, 0x6f, 0x25, 0xd1, 0x64, 0x4c, 0x72, 0x94, 0xc3, 0x7f, 0x93, 0x9f, 0x39, 0x87,
-	0xef, 0xc4, 0x38, 0xfc, 0xd5, 0x31, 0x8d, 0x93, 0xd2, 0xf8, 0x08, 0x47, 0x16, 0x53, 0x38, 0x72,
-	0x3e, 0xca, 0x91, 0xd3, 0xb0, 0xe0, 0x7d, 0x58, 0x8b, 0x9a, 0x8b, 0x41, 0xf3, 0x32, 0x94, 0xd1,
-	0x89, 0x82, 0x0b, 0x95, 0x51, 0xe3, 0x83, 0xb5, 0x1b, 0x50, 0x0f, 0x4d, 0xe8, 0x65, 0x81, 0xa1,
-	0x13, 0x78, 0xb7, 0x1e, 0x9b, 0xb6, 0x12, 0x92, 0xfc, 0x7d, 0x1e, 0x9e, 0x91, 0x8a, 0xa2, 0x49,
-	0xdf, 0x82, 0xb2, 0x83, 0x63, 0x68, 0xd2, 0xeb, 0x29, 0xbb, 0x1f, 0x9f, 0xa2, 0x19, 0x19, 0xd7,
-	0xfd, 0xe9, 0xea, 0x7f, 0xcc, 0xc1, 0x52, 0xe4, 0xd9, 0x98, 0x4c, 0x73, 0x11, 0x44, 0xda, 0xdb,
-	0xe5, 0xe9, 0xc3, 0xdb, 0xe7, 0xa2, 0xbe, 0x88, 0x83, 0x2c, 0xc7, 0x78, 0x20, 0x7b, 0x68, 0x9a,
-	0x86, 0xb9, 0x8f, 0xa0, 0x02, 0x07, 0xe1, 0x20, 0x07, 0x5d, 0x81, 0x95, 0xae, 0x75, 0x38, 0xe8,
-	0x53, 0xd7, 0x9f, 0xab, 0xc8, 0x60, 0xcb, 0xfe, 0xf0, 0x83, 0x68, 0xe6, 0xb9, 0x47, 0xdd, 0x0f,
-	0x2c, 0xfb, 0x60, 0x8c, 0xcc, 0x83, 0x12, 0xb2, 0xcc, 0xe3, 0x4f, 0x16, 0x70, 0x87, 0xc9, 0x87,
-	0x54, 0xdc, 0x21, 0xa4, 0x04, 0x56, 0x7b, 0xc8, 0x32, 0x4f, 0xcc, 0x32, 0x02, 0x45, 0x2f, 0xa2,
-	0x31, 0x2e, 0xd9, 0xff, 0xde, 0x36, 0xa3, 0x8c, 0xb7, 0xcd, 0xf9, 0x60, 0x9b, 0x51, 0xd6, 0xdb,
-	0x66, 0x04, 0xb4, 0x7b, 0x98, 0x64, 0x66, 0x64, 0xe3, 0x37, 0x05, 0xbf, 0xcd, 0xdc, 0x4c, 0x9f,
-	0xf3, 0x62, 0x96, 0x6a, 0xff, 0xce, 0x73, 0xce, 0xc3, 0xf1, 0x09, 0x38, 0x2f, 0x26, 0x39, 0xca,
-	0x79, 0x3f, 0x39, 0x45, 0xce, 0x4b, 0x30, 0x6e, 0x62, 0xce, 0x9b, 0x01, 0xaf, 0x05, 0x26, 0x05,
-	0xbc, 0x86, 0x8e, 0x52, 0xf2, 0x9a, 0xf0, 0x9c, 0x0f, 0xd6, 0x6e, 0xb2, 0x90, 0xbe, 0xd5, 0x1f,
-	0x3a, 0x2e, 0xb5, 0x43, 0xb9, 0xb0, 0xcb, 0x47, 0x62, 0x2c, 0x81, 0x38, 0x2f, 0x2e, 0x10, 0xe0,
-	0x87, 0xaf, 0x3f, 0x45, 0x10, 0xbe, 0x08, 0x51, 0x85, 0xaf, 0x90, 0x12, 0x58, 0x3f, 0x96, 0xf0,
-	0xc1, 0x04, 0xb1, 0x14, 0x93, 0xfc, 0x62, 0xc5, 0x52, 0x82, 0x71, 0xa7, 0x19, 0x4b, 0x81, 0x49,
-	0x41, 0x2c, 0xa1, 0x37, 0x94, 0xb1, 0x24, 0x5c, 0xe7, 0x83, 0xb5, 0x9f, 0xe7, 0xa0, 0x7a, 0x97,
-	0x1e, 0xe9, 0x96, 0xdb, 0x71, 0xbd, 0x23, 0xe6, 0x35, 0x38, 0xe3, 0x05, 0x19, 0xb5, 0x77, 0xdf,
-	0xb7, 0x0c, 0x73, 0xd7, 0xb5, 0x0e, 0xa8, 0xc9, 0x4c, 0x2b, 0xeb, 0x2b, 0xfc, 0xc1, 0x5b, 0x96,
-	0x61, 0x3e, 0xf0, 0x86, 0xc9, 0x75, 0x20, 0x87, 0x1d, 0xb3, 0xb3, 0x1f, 0x05, 0xf3, 0x43, 0xf9,
-	0x2a, 0x3e, 0x91, 0xa2, 0x87, 0x66, 0xdf, 0xea, 0x1e, 0xec, 0x7a, 0xab, 0x2e, 0x44, 0xd0, 0x0f,
-	0xd9, 0x83, 0xbb, 0xf4, 0x48, 0xfb, 0x91, 0x7f, 0xee, 0x9e, 0x26, 0xce, 0xbd, 0x73, 0xb7, 0x40,
-	0x8f, 0x73, 0xee, 0x46, 0x99, 0x31, 0xce, 0xdd, 0xa8, 0x3d, 0x74, 0xee, 0xbe, 0xe9, 0x9d, 0xbb,
-	0xf9, 0xae, 0xb2, 0xbc, 0x99, 0x20, 0x18, 0xda, 0xfc, 0xad, 0xe2, 0xc7, 0xc7, 0x1b, 0x73, 0xba,
-	0x2f, 0x16, 0x9c, 0xa3, 0x67, 0xf4, 0xa2, 0xbe, 0x0e, 0xab, 0xec, 0xcb, 0xa8, 0x6b, 0x53, 0x57,
-	0xec, 0xe7, 0x55, 0xa8, 0x38, 0x6c, 0x20, 0xd8, 0xce, 0xc5, 0x93, 0xe3, 0x8d, 0x32, 0x47, 0xb5,
-	0xb7, 0xbd, 0x53, 0x11, 0xfb, 0xaf, 0xa7, 0xdd, 0xc1, 0x8f, 0x38, 0x2e, 0x8e, 0xa6, 0x6c, 0xc2,
-	0x02, 0x07, 0xa0, 0x25, 0x75, 0xf9, 0xd9, 0x8c, 0xc9, 0x20, 0x52, 0xfb, 0x4b, 0x0e, 0xce, 0x8a,
-	0x0f, 0x84, 0xc9, 0x6c, 0x21, 0x5b, 0xb0, 0x8c, 0xd0, 0x31, 0xfc, 0xba, 0xc4, 0x45, 0x84, 0x5b,
-	0x37, 0x23, 0x6e, 0x5d, 0x4f, 0x36, 0x3c, 0x74, 0x3c, 0x79, 0x2b, 0xf8, 0x1c, 0x9c, 0x7a, 0x1b,
-	0xfe, 0x95, 0x07, 0xc2, 0x8f, 0x88, 0xde, 0x4f, 0x9f, 0x36, 0xdf, 0x8c, 0xd3, 0x66, 0x33, 0xf9,
-	0x6c, 0x19, 0x16, 0x1c, 0x65, 0xcd, 0x8f, 0x66, 0xcf, 0x9a, 0x7a, 0x8c, 0x35, 0x5f, 0x19, 0xcf,
-	0xb6, 0x53, 0x21, 0xcd, 0xbb, 0xe2, 0xf3, 0x0e, 0x2d, 0x42, 0x97, 0x7d, 0xd9, 0xfb, 0x18, 0x65,
-	0x43, 0x48, 0x99, 0x2a, 0x9f, 0x09, 0xa8, 0xd6, 0x86, 0xb3, 0xe2, 0x66, 0x24, 0x1c, 0xba, 0x9b,
-	0x91, 0xb3, 0x6e, 0xe6, 0x58, 0x8a, 0x4e, 0x35, 0x45, 0x2c, 0x7d, 0x03, 0xce, 0x8a, 0x8f, 0xdb,
-	0x09, 0xdf, 0xee, 0xf3, 0xc1, 0x47, 0x76, 0xd8, 0x1a, 0x24, 0x8d, 0x5b, 0x96, 0xf9, 0xd8, 0xd8,
-	0x0f, 0x4d, 0xdb, 0x65, 0x03, 0xb1, 0x69, 0x39, 0xca, 0x9b, 0x96, 0x3f, 0xf6, 0x49, 0x43, 0x88,
-	0x07, 0x2b, 0xe4, 0x00, 0xd5, 0x0a, 0x51, 0x06, 0x91, 0x21, 0xd2, 0x98, 0xd4, 0x16, 0x8f, 0x34,
-	0x10, 0x3a, 0x0e, 0x69, 0x70, 0x91, 0x31, 0x48, 0x83, 0x6b, 0x96, 0x91, 0xc6, 0x0c, 0xb6, 0x41,
-	0x90, 0x06, 0x1f, 0x9e, 0x80, 0x34, 0xa2, 0x82, 0x5f, 0x2c, 0xd2, 0x90, 0xdb, 0x76, 0x9a, 0xa4,
-	0xe1, 0x5b, 0x14, 0x90, 0x06, 0x77, 0x84, 0x92, 0x34, 0xd0, 0x67, 0x02, 0x1a, 0x90, 0x46, 0x34,
-	0x74, 0x33, 0x90, 0x86, 0x2c, 0x96, 0xa2, 0x53, 0x4d, 0x11, 0x4b, 0x3e, 0x69, 0x4c, 0xfc, 0x76,
-	0xfb, 0xa4, 0x11, 0xb5, 0x46, 0xfb, 0x1e, 0x9c, 0xe7, 0x56, 0xde, 0xfe, 0xd0, 0xa5, 0x26, 0x7b,
-	0x8f, 0x70, 0xf2, 0x9b, 0x50, 0xed, 0x98, 0x26, 0x9e, 0x70, 0x1c, 0xd5, 0xdd, 0xc0, 0xcd, 0x00,
-	0xa6, 0x87, 0x65, 0xc8, 0x05, 0xa8, 0xf6, 0xa8, 0xd3, 0xb5, 0x8d, 0x81, 0x2b, 0xde, 0xe1, 0x8a,
-	0x1e, 0x1e, 0xd2, 0x1e, 0xc1, 0x53, 0x23, 0xea, 0x71, 0x9f, 0x5e, 0x85, 0x0a, 0x15, 0x83, 0xa8,
-	0x5d, 0x5a, 0x4a, 0x08, 0x24, 0x03, 0xbc, 0xf6, 0x36, 0x9c, 0xe7, 0xcb, 0x1d, 0x59, 0xd6, 0x26,
-	0x2c, 0xfa, 0xb0, 0x60, 0xdb, 0x56, 0x4e, 0x8e, 0x37, 0xaa, 0x3e, 0xb6, 0xbd, 0xad, 0x57, 0x7d,
-	0x50, 0xbb, 0xa7, 0x3d, 0x0d, 0x4f, 0x8d, 0xcc, 0x86, 0xfb, 0xd7, 0x86, 0xb3, 0x77, 0xa8, 0x3b,
-	0x13, 0x2d, 0x3b, 0xb0, 0x16, 0x9d, 0x6a, 0x16, 0x1b, 0xf1, 0xeb, 0x9c, 0xb8, 0xa6, 0xd1, 0xa9,
-	0x63, 0x0d, 0xed, 0xe0, 0x4e, 0x76, 0x06, 0xfe, 0x25, 0x50, 0x3c, 0x30, 0x4c, 0xbc, 0xdc, 0xd0,
-	0xd9, 0xff, 0xa4, 0x09, 0xa5, 0x41, 0xe7, 0xa8, 0x6f, 0x75, 0x7a, 0xc8, 0xbc, 0x6b, 0x4d, 0xde,
-	0x2a, 0xd1, 0x14, 0xbd, 0x0f, 0xcd, 0x9b, 0xe6, 0x91, 0x2e, 0x40, 0x9a, 0x2e, 0x02, 0x30, 0xb0,
-	0x0f, 0xd7, 0x7d, 0x03, 0xca, 0x36, 0x8e, 0xa1, 0x75, 0xd2, 0x9a, 0xaa, 0x2f, 0xe7, 0xa3, 0xb5,
-	0x37, 0xc5, 0x65, 0x4a, 0x7c, 0xcd, 0x2d, 0xa8, 0x0a, 0x50, 0xe0, 0x15, 0x46, 0x88, 0x02, 0xd9,
-	0xde, 0xd6, 0x41, 0x40, 0xda, 0x3d, 0xad, 0x26, 0xe2, 0x28, 0x6e, 0x9d, 0xf6, 0xe3, 0xbc, 0x38,
-	0xf3, 0x4f, 0xab, 0x84, 0xbc, 0x01, 0xab, 0xbe, 0xc0, 0x18, 0xf9, 0x6e, 0x45, 0x08, 0x89, 0x8c,
-	0x17, 0xf3, 0x68, 0x61, 0x02, 0x8f, 0x86, 0xbc, 0x57, 0xcc, 0xe8, 0xbd, 0xf8, 0x26, 0x4c, 0xed,
-	0xbd, 0xdb, 0xec, 0xca, 0x63, 0x6a, 0xd7, 0xdd, 0x67, 0x6f, 0xe6, 0x0c, 0xed, 0xfa, 0x6f, 0x9e,
-	0x7f, 0xd3, 0x8b, 0x47, 0x7e, 0x4a, 0x7f, 0x2b, 0x9e, 0xd2, 0x9f, 0x4f, 0x4a, 0x9b, 0x71, 0xd1,
-	0xd1, 0xa4, 0xfe, 0xab, 0xd9, 0x27, 0xf5, 0x07, 0xb1, 0xa4, 0xfe, 0xda, 0xb8, 0xd6, 0x4d, 0x5e,
-	0x80, 0x10, 0x04, 0x31, 0x1f, 0x10, 0xc4, 0x34, 0xa9, 0x7e, 0x07, 0xce, 0xc5, 0xec, 0x44, 0xa7,
-	0xbe, 0x02, 0x15, 0xe1, 0x26, 0x91, 0xee, 0xd5, 0x5e, 0x0d, 0xe0, 0x41, 0xca, 0x7f, 0x64, 0xf5,
-	0x87, 0x87, 0x74, 0x8c, 0x94, 0xcf, 0x05, 0x64, 0x29, 0x5f, 0x4c, 0x15, 0xa4, 0xfc, 0x27, 0x6c,
-	0x44, 0x95, 0xf2, 0x51, 0x06, 0x91, 0x78, 0x9a, 0x8f, 0xda, 0x74, 0x15, 0x2a, 0xfc, 0x69, 0x2c,
-	0xdf, 0x73, 0x94, 0x97, 0xef, 0xf9, 0x63, 0xff, 0x34, 0x3f, 0x03, 0x3b, 0x82, 0xd3, 0xfc, 0xa4,
-	0xb6, 0x78, 0xa7, 0x79, 0x84, 0x8e, 0x73, 0x9a, 0xe7, 0x22, 0x63, 0x9c, 0xe6, 0x65, 0xee, 0x88,
-	0x5a, 0x3e, 0xc5, 0x36, 0xfc, 0xa2, 0xc0, 0x4f, 0xf3, 0x7c, 0x78, 0x82, 0xd3, 0x7c, 0x54, 0x70,
-	0xf4, 0xc5, 0xff, 0xf3, 0x29, 0x9e, 0xe6, 0xe5, 0xb6, 0x4d, 0xfe, 0xda, 0x9f, 0x87, 0x85, 0x7d,
-	0xdb, 0x1a, 0x0e, 0x44, 0xd5, 0x11, 0x7f, 0x91, 0x1a, 0x94, 0x7a, 0xb6, 0xe1, 0x05, 0x01, 0xb6,
-	0x9e, 0x89, 0x9f, 0x33, 0x38, 0xff, 0xfb, 0x6b, 0x08, 0xce, 0xff, 0xdc, 0x75, 0xca, 0xf3, 0x3f,
-	0x7a, 0x59, 0x40, 0xb5, 0x47, 0xe2, 0xa0, 0x3d, 0x71, 0xb0, 0xcb, 0xbb, 0xaa, 0xfc, 0xe3, 0x77,
-	0x34, 0x14, 0x37, 0xff, 0xde, 0x80, 0xd2, 0x2d, 0xde, 0x08, 0x4b, 0x0c, 0x28, 0x61, 0x1f, 0x27,
-	0xd1, 0x64, 0xb6, 0x46, 0x7b, 0x43, 0xeb, 0x17, 0x95, 0x18, 0x3c, 0xa5, 0x9c, 0xfb, 0xdb, 0x1f,
-	0xfe, 0xf3, 0xcb, 0xfc, 0x0a, 0x2c, 0x31, 0xd0, 0x97, 0xf0, 0xf6, 0x96, 0x58, 0x50, 0xf1, 0x5b,
-	0xed, 0xc8, 0x73, 0x59, 0xfa, 0x1c, 0xeb, 0x97, 0x52, 0x50, 0x6a, 0x85, 0x36, 0x40, 0xd0, 0xe9,
-	0x46, 0x2e, 0x25, 0xf7, 0x35, 0x84, 0x57, 0x78, 0x39, 0x0d, 0x96, 0xaa, 0x33, 0xe8, 0x64, 0x93,
-	0xeb, 0x1c, 0xe9, 0x9c, 0x93, 0xeb, 0x94, 0x34, 0xc4, 0x25, 0xe8, 0xe4, 0x3e, 0x7c, 0xd0, 0x71,
-	0x0e, 0x12, 0x7d, 0x18, 0xea, 0x64, 0x4b, 0xf4, 0x61, 0xa4, 0x67, 0x4d, 0xed, 0x43, 0x5e, 0x02,
-	0x7e, 0x2e, 0x4b, 0x5f, 0x58, 0xb2, 0x0f, 0x23, 0x0d, 0x4d, 0xa9, 0xfb, 0xc9, 0x96, 0xa7, 0xd8,
-	0xcf, 0xf0, 0x0a, 0x2f, 0xa7, 0xc1, 0x52, 0x75, 0x06, 0x2d, 0x42, 0x72, 0x9d, 0x23, 0xed, 0x4a,
-	0x72, 0x9d, 0xa3, 0x9d, 0x46, 0x49, 0x3a, 0x3f, 0x84, 0xc5, 0x70, 0x7b, 0x03, 0xb9, 0x92, 0xb1,
-	0x5f, 0xa3, 0xde, 0x48, 0x07, 0xaa, 0x35, 0x7f, 0x17, 0x96, 0x22, 0xcd, 0x5c, 0x44, 0x3a, 0xa3,
-	0xac, 0x79, 0xac, 0x7e, 0x35, 0x03, 0x32, 0x55, 0x79, 0xa4, 0x17, 0x48, 0xae, 0x5c, 0xd6, 0x7d,
-	0x24, 0x57, 0x2e, 0x6d, 0x2c, 0x52, 0x28, 0x8f, 0xb4, 0xfc, 0xc8, 0x95, 0xcb, 0x7a, 0x8b, 0xe4,
-	0xca, 0xe5, 0xfd, 0x43, 0x09, 0xca, 0x7f, 0x9a, 0x8b, 0xb4, 0x15, 0x89, 0x0e, 0x10, 0xd2, 0xcc,
-	0xdc, 0x2a, 0xc2, 0x2d, 0x69, 0x8d, 0xd9, 0x5a, 0xa2, 0x0e, 0x7a, 0x2c, 0x27, 0x27, 0x06, 0x7d,
-	0xb4, 0x05, 0x21, 0x31, 0xe8, 0xe3, 0xfd, 0x04, 0xea, 0xa0, 0x17, 0xb5, 0xef, 0xe4, 0xa0, 0x8f,
-	0x15, 0xec, 0x93, 0x83, 0x3e, 0x5e, 0x46, 0x4f, 0x0d, 0x7a, 0xb1, 0x60, 0x45, 0xd0, 0xc7, 0xd6,
-	0x7c, 0x35, 0x03, 0x32, 0x63, 0xdc, 0x29, 0x95, 0xcb, 0x7a, 0x3e, 0x54, 0x71, 0x97, 0x51, 0x39,
-	0xf7, 0x33, 0x16, 0xff, 0x12, 0xfd, 0x1c, 0x2d, 0xab, 0x26, 0xfa, 0x39, 0x56, 0x79, 0x4c, 0xf1,
-	0xb3, 0xa8, 0x4b, 0x27, 0xfb, 0x39, 0x56, 0x4c, 0x4f, 0xf6, 0x73, 0xbc, 0xc4, 0x9d, 0xca, 0x2f,
-	0x62, 0xc1, 0x0a, 0x7e, 0x89, 0xad, 0xf9, 0x6a, 0x06, 0x64, 0x6a, 0xb2, 0xf4, 0x2b, 0xa2, 0xf2,
-	0x64, 0x19, 0xaf, 0xb7, 0xd6, 0x2f, 0xa5, 0xa0, 0x52, 0xf7, 0x39, 0x5c, 0x7e, 0x94, 0xef, 0xb3,
-	0xa4, 0xb4, 0x5a, 0x6f, 0xa4, 0x03, 0xd5, 0x9a, 0x87, 0x50, 0x0d, 0x15, 0xd1, 0xc8, 0xe5, 0x6c,
-	0x75, 0xbf, 0xfa, 0x95, 0x54, 0x5c, 0xea, 0x82, 0xc3, 0x35, 0x32, 0xf9, 0x82, 0x25, 0x05, 0xb9,
-	0x7a, 0x23, 0x1d, 0x98, 0xaa, 0x39, 0x5c, 0x0f, 0x93, 0x6b, 0x96, 0xd4, 0xdc, 0xea, 0x8d, 0x74,
-	0x60, 0x96, 0xa8, 0xe2, 0x37, 0xea, 0x89, 0x51, 0x15, 0xb9, 0xb2, 0x4f, 0x8c, 0xaa, 0xd8, 0xb5,
-	0x7c, 0x5a, 0x54, 0xa1, 0x4e, 0x45, 0x54, 0x45, 0xd5, 0x36, 0xd2, 0x81, 0x99, 0xa2, 0x0a, 0xab,
-	0x2c, 0xc9, 0x51, 0x15, 0x2d, 0x0c, 0x25, 0x47, 0x55, 0xac, 0x5c, 0x93, 0x1a, 0x55, 0xaa, 0x05,
-	0x4b, 0x2a, 0x36, 0xaa, 0xa8, 0xca, 0xbc, 0xd5, 0xe1, 0x82, 0x89, 0x2a, 0xaa, 0x32, 0x68, 0x96,
-	0xd6, 0x5e, 0x92, 0x35, 0x87, 0xeb, 0x00, 0x72, 0xcd, 0x92, 0xa2, 0x83, 0x5c, 0xb3, 0xac, 0xa4,
-	0x90, 0xa4, 0xf9, 0x87, 0x39, 0x58, 0x89, 0x95, 0x63, 0xc8, 0xb5, 0xe4, 0x8d, 0x1c, 0x31, 0xe0,
-	0xff, 0x33, 0x61, 0xd3, 0x6d, 0x88, 0x15, 0x5b, 0xe4, 0x36, 0xc8, 0xeb, 0x3b, 0x72, 0x1b, 0x92,
-	0xaa, 0x37, 0xc9, 0xc1, 0x1e, 0xba, 0x3a, 0x26, 0x49, 0x29, 0x37, 0x76, 0x45, 0x5d, 0xbf, 0x92,
-	0x8a, 0x53, 0xab, 0xfd, 0x3e, 0x2c, 0x47, 0x2f, 0xd3, 0x89, 0x22, 0xf1, 0xc5, 0x95, 0x5f, 0xcb,
-	0x02, 0x4d, 0xcd, 0xd0, 0x91, 0xeb, 0x55, 0xd2, 0xc8, 0x7a, 0x53, 0x2c, 0xcf, 0xd0, 0xd2, 0xbb,
-	0x5a, 0xc5, 0xe2, 0xa3, 0x75, 0x20, 0xa2, 0x38, 0xdd, 0x65, 0x5a, 0xbc, 0xbc, 0xac, 0xa4, 0xd0,
-	0x1f, 0xad, 0xf4, 0x10, 0xc5, 0x01, 0x2f, 0x93, 0xfe, 0x84, 0xc2, 0x51, 0x1a, 0xd3, 0xf1, 0x1b,
-	0x22, 0x15, 0xd3, 0x45, 0xee, 0xa6, 0x54, 0x4c, 0x17, 0xbd, 0x6c, 0x52, 0x67, 0x31, 0x54, 0x9b,
-	0x94, 0xc5, 0xa2, 0x3a, 0x2f, 0xa5, 0xa0, 0x32, 0x66, 0x31, 0xd5, 0x52, 0x25, 0x77, 0xce, 0xaa,
-	0x2c, 0x96, 0x4d, 0x33, 0x66, 0x31, 0xbc, 0x2b, 0x4c, 0xce, 0x62, 0xd1, 0x0b, 0xd1, 0xe4, 0x2c,
-	0x16, 0xbb, 0x74, 0x4c, 0xcd, 0x25, 0xaa, 0x05, 0x4b, 0xee, 0x1d, 0x55, 0xb9, 0x24, 0xd3, 0x82,
-	0xb7, 0x9e, 0xfb, 0xf8, 0xb3, 0xf5, 0xb9, 0x4f, 0x3f, 0x5b, 0x9f, 0xfb, 0xc1, 0xc9, 0x7a, 0xee,
-	0xe3, 0x93, 0xf5, 0xdc, 0x27, 0x27, 0xeb, 0xb9, 0x7f, 0x9e, 0xac, 0xe7, 0x7e, 0xf6, 0xf9, 0xfa,
-	0xdc, 0x27, 0x9f, 0xaf, 0xcf, 0x7d, 0xfa, 0xf9, 0xfa, 0xdc, 0xde, 0x02, 0x2b, 0xee, 0xbd, 0xf8,
-	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0xde, 0x67, 0x4f, 0xb3, 0x3f, 0x00, 0x00,
+	// 3029 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x6f, 0x24, 0x47,
+	0x15, 0xf7, 0x8c, 0xc7, 0x9e, 0x99, 0x37, 0xfe, 0xda, 0x5a, 0xef, 0xc6, 0x99, 0x04, 0x7b, 0xd5,
+	0x9b, 0xdd, 0xf5, 0x2e, 0xcb, 0x38, 0x71, 0x08, 0x59, 0xf2, 0x01, 0xac, 0xd7, 0x9b, 0xcd, 0x64,
+	0x93, 0xdd, 0xa8, 0xbd, 0x59, 0xc1, 0x01, 0x59, 0xe3, 0x99, 0x5a, 0xa7, 0xe3, 0x71, 0xf7, 0xd0,
+	0xdd, 0xb3, 0x89, 0x85, 0x40, 0x7c, 0x24, 0x47, 0x24, 0x2e, 0x88, 0x88, 0x03, 0x12, 0x27, 0x24,
+	0x90, 0x10, 0xe2, 0x80, 0x38, 0xf0, 0x07, 0x44, 0x9c, 0x72, 0xcc, 0x05, 0x43, 0x1c, 0x21, 0x71,
+	0xe2, 0x5f, 0x00, 0x55, 0xd5, 0xab, 0xfe, 0x9a, 0xea, 0xea, 0x9e, 0x0f, 0xc9, 0x9c, 0xec, 0xa9,
+	0xfe, 0xbd, 0x8f, 0xaa, 0xf7, 0xfa, 0xf7, 0xaa, 0xeb, 0x15, 0x5c, 0xdf, 0xb7, 0xfc, 0x77, 0xfb,
+	0x7b, 0x8d, 0xb6, 0x73, 0xb8, 0xd1, 0x71, 0xda, 0x07, 0xd4, 0xdd, 0xf0, 0xde, 0x6f, 0xb9, 0x87,
+	0x07, 0x96, 0xbf, 0xd1, 0xea, 0x59, 0x1b, 0x6d, 0xc7, 0xf6, 0x5d, 0xa7, 0xdb, 0xe8, 0xb9, 0x8e,
+	0xef, 0x10, 0x22, 0x20, 0x0d, 0x09, 0x69, 0x3c, 0x7e, 0xae, 0x7e, 0x2d, 0x43, 0x83, 0xd7, 0xa3,
+	0x6d, 0x4f, 0xc8, 0xd7, 0xb3, 0xac, 0x39, 0x7b, 0xef, 0xd1, 0xb6, 0x2f, 0xd1, 0x59, 0x9a, 0xfd,
+	0xa3, 0x1e, 0x95, 0xd8, 0xe5, 0x7d, 0x67, 0xdf, 0xe1, 0xff, 0x6e, 0xb0, 0xff, 0x70, 0xf4, 0xc9,
+	0x7d, 0xc7, 0xd9, 0xef, 0xd2, 0x0d, 0xfe, 0x6b, 0xaf, 0xff, 0x68, 0xa3, 0x65, 0x1f, 0xe1, 0xa3,
+	0x17, 0x35, 0xca, 0x03, 0x78, 0xaf, 0xdb, 0xdf, 0xb7, 0x6c, 0xfc, 0x23, 0x04, 0x8d, 0x17, 0x60,
+	0xe1, 0x0e, 0xf5, 0xef, 0x39, 0x1d, 0x6a, 0xd2, 0xef, 0xf5, 0xa9, 0xe7, 0x93, 0x8b, 0x50, 0xb6,
+	0x9d, 0x0e, 0xdd, 0xb5, 0x3a, 0x2b, 0x85, 0x0b, 0x85, 0xf5, 0xea, 0x16, 0x9c, 0x1c, 0xaf, 0xcd,
+	0x32, 0x44, 0x73, 0xdb, 0x9c, 0x65, 0x8f, 0x9a, 0x1d, 0xe3, 0x9b, 0xb0, 0x18, 0x88, 0x79, 0x3d,
+	0xc7, 0xf6, 0x28, 0xb9, 0x0e, 0x25, 0xf6, 0x90, 0x0b, 0xd5, 0x36, 0x57, 0x1a, 0x83, 0x8b, 0xdb,
+	0xe0, 0x78, 0x8e, 0x32, 0x3e, 0x9c, 0x81, 0xa5, 0x37, 0x2d, 0x8f, 0xab, 0xf0, 0xa4, 0xe9, 0xd7,
+	0xa0, 0xfc, 0xc8, 0xea, 0xfa, 0xd4, 0xf5, 0x50, 0xcb, 0x75, 0x95, 0x96, 0xa4, 0x58, 0xe3, 0x35,
+	0x21, 0x63, 0x4a, 0xe1, 0xfa, 0x6f, 0x4b, 0x50, 0xc6, 0x41, 0xb2, 0x0c, 0x33, 0x76, 0xeb, 0x90,
+	0x32, 0x8d, 0xd3, 0xeb, 0x55, 0x53, 0xfc, 0x20, 0x1b, 0x50, 0xb3, 0x3a, 0xbb, 0x3d, 0x97, 0x3e,
+	0xb2, 0x3e, 0xa0, 0xde, 0x4a, 0x91, 0x3d, 0xdb, 0x5a, 0x38, 0x39, 0x5e, 0x83, 0xe6, 0xf6, 0xdb,
+	0x38, 0x6a, 0x82, 0xd5, 0x91, 0xff, 0x93, 0xb7, 0x61, 0xb6, 0xdb, 0xda, 0xa3, 0x5d, 0x6f, 0x65,
+	0xfa, 0xc2, 0xf4, 0x7a, 0x6d, 0xf3, 0xc6, 0x30, 0x9e, 0x35, 0xde, 0xe4, 0xa2, 0xb7, 0x6d, 0xdf,
+	0x3d, 0x32, 0x51, 0x0f, 0xf9, 0x2e, 0xd4, 0xf8, 0x3a, 0xa3, 0xda, 0x32, 0x57, 0xfb, 0xca, 0x50,
+	0x6a, 0xd9, 0x60, 0x54, 0x35, 0xd8, 0xc1, 0x00, 0x79, 0x0b, 0x6a, 0x87, 0xf4, 0x70, 0x8f, 0xba,
+	0xde, 0xbb, 0x56, 0xcf, 0x5b, 0x29, 0x5d, 0x98, 0x5e, 0x5f, 0xd8, 0xbc, 0x92, 0x16, 0x95, 0x9d,
+	0x1e, 0x6d, 0x37, 0xde, 0x0a, 0xf0, 0x5b, 0xc5, 0xa5, 0x29, 0x33, 0x2a, 0x4f, 0xbe, 0x06, 0x33,
+	0xae, 0xd3, 0xa5, 0xde, 0xca, 0x0c, 0x57, 0xf4, 0x74, 0x6a, 0x78, 0x9d, 0x2e, 0xe5, 0xd2, 0x02,
+	0x4e, 0x2e, 0xc2, 0x3c, 0x5b, 0xf1, 0x70, 0xa9, 0x67, 0x79, 0x18, 0xe6, 0xd8, 0xa0, 0x5c, 0xdc,
+	0xfa, 0xd7, 0xa1, 0x16, 0x99, 0x06, 0x59, 0x82, 0xe9, 0x03, 0x7a, 0x24, 0xb2, 0xcf, 0x64, 0xff,
+	0xb2, 0x20, 0x3e, 0x6e, 0x75, 0xfb, 0x74, 0xa5, 0xc8, 0xc7, 0xc4, 0x8f, 0x97, 0x8a, 0x37, 0x0a,
+	0xf5, 0x57, 0x61, 0x31, 0xb1, 0x0a, 0xc3, 0x88, 0x1b, 0xb7, 0xe0, 0x4c, 0x64, 0x75, 0x31, 0x93,
+	0x1b, 0x30, 0xc3, 0x16, 0x52, 0xa4, 0x8c, 0x2e, 0x95, 0x05, 0xcc, 0xf8, 0x5d, 0x01, 0xce, 0xbc,
+	0xd3, 0xeb, 0xb4, 0x7c, 0x3a, 0xec, 0x7b, 0x44, 0xbe, 0x01, 0x73, 0x1c, 0xf4, 0x98, 0xba, 0x9e,
+	0xe5, 0xd8, 0xdc, 0xc1, 0xda, 0xe6, 0x53, 0x2a, 0x8b, 0x0f, 0x05, 0xc4, 0xe4, 0x59, 0x83, 0x3f,
+	0xc8, 0xb3, 0x50, 0x62, 0x8c, 0xb4, 0x32, 0xcd, 0xe5, 0x9e, 0xd6, 0x85, 0xd7, 0xe4, 0x48, 0x63,
+	0x0b, 0x48, 0xd4, 0xd7, 0x91, 0x5e, 0xde, 0x7b, 0x70, 0xc6, 0xa4, 0x87, 0xce, 0xe3, 0xe1, 0xe7,
+	0xbb, 0x0c, 0x33, 0x8f, 0x1c, 0xb7, 0x2d, 0x22, 0x51, 0x31, 0xc5, 0x0f, 0x63, 0x19, 0x48, 0x54,
+	0x9f, 0xf0, 0x09, 0xa9, 0xe9, 0x41, 0xcb, 0x3b, 0x88, 0x98, 0xf0, 0x5b, 0xde, 0x41, 0xc2, 0x04,
+	0x43, 0x30, 0x13, 0xec, 0x51, 0x40, 0x4d, 0x42, 0x2c, 0x9c, 0x1d, 0x7b, 0xa8, 0x9b, 0x1d, 0xc7,
+	0x73, 0x94, 0x71, 0x43, 0xce, 0x6e, 0x68, 0xd3, 0xc1, 0x3c, 0xa2, 0xd6, 0x8d, 0xbf, 0x96, 0x04,
+	0xd5, 0xb1, 0xc1, 0x11, 0xa8, 0x2e, 0x2a, 0x36, 0x48, 0x75, 0xff, 0x98, 0x3e, 0x3d, 0xaa, 0x53,
+	0x79, 0xa6, 0xa4, 0xba, 0x0d, 0xa8, 0x79, 0xd4, 0x7d, 0x6c, 0xb5, 0x59, 0x76, 0x08, 0x2e, 0x42,
+	0x17, 0x76, 0xc4, 0x70, 0x73, 0xdb, 0x33, 0x01, 0x21, 0xcd, 0x8e, 0x47, 0x2e, 0x43, 0x05, 0x73,
+	0x49, 0x10, 0x4e, 0x75, 0xab, 0x76, 0x72, 0xbc, 0x56, 0x16, 0xc9, 0xe4, 0x99, 0x65, 0x91, 0x4d,
+	0x1e, 0x79, 0x1d, 0x16, 0x3a, 0xd4, 0xb3, 0x5c, 0xda, 0xd9, 0xf5, 0xfc, 0x96, 0x8f, 0xf4, 0xb2,
+	0xb0, 0xf9, 0xa5, 0xb4, 0x10, 0xef, 0x30, 0x14, 0xe7, 0xa7, 0x79, 0x14, 0xe4, 0x23, 0x0a, 0x9e,
+	0x2a, 0x0f, 0xf2, 0x14, 0xa9, 0x43, 0xc5, 0xed, 0xdb, 0xbe, 0xc5, 0xd6, 0xb8, 0xca, 0x9f, 0x07,
+	0xbf, 0xc9, 0xd3, 0x00, 0xfd, 0xde, 0xae, 0xef, 0xec, 0xb2, 0x77, 0x6b, 0xa5, 0xc2, 0xd3, 0xbb,
+	0xd2, 0xef, 0x3d, 0x70, 0xb6, 0x5b, 0x3e, 0x1d, 0x83, 0xe1, 0x24, 0x45, 0xe1, 0x62, 0x87, 0x14,
+	0xc5, 0x72, 0x4e, 0x4b, 0x51, 0x3c, 0x09, 0x05, 0xcc, 0xb8, 0x0b, 0xcb, 0xb7, 0x5c, 0xda, 0xf2,
+	0x29, 0x2e, 0xb8, 0x4c, 0xc3, 0xe7, 0x91, 0x3f, 0x44, 0x0e, 0xae, 0xa9, 0xd4, 0xa0, 0x44, 0x84,
+	0x42, 0xee, 0xc1, 0xb9, 0x84, 0x32, 0xf4, 0xea, 0x05, 0x28, 0x63, 0x10, 0x51, 0xe1, 0x53, 0x1a,
+	0x85, 0xa6, 0xc4, 0x1a, 0xef, 0xc1, 0x99, 0x3b, 0xd4, 0x4f, 0x78, 0x76, 0x1d, 0x20, 0xcc, 0x19,
+	0x7c, 0xe7, 0xe6, 0x4f, 0x8e, 0xd7, 0xaa, 0x41, 0xca, 0x98, 0xd5, 0x20, 0x63, 0xc8, 0x15, 0x58,
+	0xb4, 0x6c, 0x8f, 0xba, 0xfe, 0x6e, 0x87, 0x3e, 0x6a, 0xf5, 0xbb, 0xbe, 0x87, 0x0c, 0xb3, 0x20,
+	0x86, 0xb7, 0x71, 0xd4, 0xb8, 0x0b, 0x24, 0x6a, 0x6b, 0x3c, 0xc7, 0xff, 0x54, 0x84, 0x65, 0x41,
+	0xa6, 0x63, 0x39, 0xbf, 0x0d, 0x8b, 0x12, 0x3d, 0x44, 0x1d, 0x58, 0x40, 0x19, 0x59, 0x0a, 0x9e,
+	0x8f, 0x95, 0x82, 0x7c, 0xa1, 0x24, 0x6f, 0x41, 0xc5, 0x75, 0xba, 0xdd, 0xbd, 0x56, 0xfb, 0x60,
+	0xa5, 0x74, 0xa1, 0xb0, 0xbe, 0xb0, 0xf9, 0x9c, 0x4a, 0x50, 0x35, 0xc9, 0x86, 0x89, 0x82, 0x66,
+	0xa0, 0xc2, 0x30, 0xa0, 0x22, 0x47, 0x49, 0x05, 0x4a, 0xf7, 0xee, 0xdf, 0xbb, 0xbd, 0x34, 0x45,
+	0xe6, 0xa0, 0xf2, 0xb6, 0x79, 0xfb, 0x61, 0xf3, 0xfe, 0x3b, 0x3b, 0x4b, 0x05, 0x96, 0x3d, 0x09,
+	0x75, 0xe3, 0x05, 0x61, 0x1b, 0x96, 0x05, 0xe9, 0x8e, 0x13, 0x03, 0xe3, 0x09, 0x38, 0x97, 0xd0,
+	0x82, 0xec, 0xfd, 0xe1, 0x34, 0x9c, 0x65, 0xef, 0x1f, 0x8e, 0x07, 0x04, 0xde, 0x4c, 0x12, 0xf8,
+	0x46, 0x1a, 0x4d, 0x26, 0x24, 0x07, 0x39, 0xfc, 0x37, 0xc5, 0x89, 0x73, 0xf8, 0x4e, 0x82, 0xc3,
+	0x5f, 0x1e, 0xd2, 0x39, 0x25, 0x8d, 0x0f, 0x70, 0x64, 0x29, 0x83, 0x23, 0x67, 0xe2, 0x1c, 0x39,
+	0x0e, 0x0b, 0xde, 0x87, 0xe5, 0xb8, 0xbb, 0x98, 0x34, 0x2f, 0x42, 0x05, 0x83, 0x28, 0xb9, 0x50,
+	0x9b, 0x35, 0x01, 0xd8, 0xb8, 0x01, 0xf5, 0x88, 0x42, 0x56, 0x05, 0xfa, 0x5e, 0x18, 0xdd, 0x7a,
+	0x42, 0x6d, 0x35, 0x22, 0xf9, 0xfb, 0x22, 0x3c, 0xa5, 0x14, 0x45, 0x97, 0xbe, 0x03, 0x15, 0x0f,
+	0xc7, 0xd0, 0xa5, 0x57, 0x33, 0x56, 0x3f, 0xa9, 0xa2, 0x11, 0x1b, 0x37, 0x03, 0x75, 0xf5, 0x3f,
+	0x16, 0x60, 0x3e, 0xf6, 0x6c, 0x48, 0xa6, 0xb9, 0x08, 0xb2, 0xec, 0xed, 0x8a, 0xf2, 0xc1, 0xd6,
+	0xb9, 0x64, 0xce, 0xe1, 0x20, 0xaf, 0x31, 0x0c, 0xe4, 0xf6, 0x6d, 0xdb, 0xb2, 0xf7, 0x11, 0x34,
+	0x2d, 0x40, 0x38, 0x28, 0x40, 0x57, 0x60, 0xb1, 0xed, 0x1c, 0xf6, 0xba, 0xd4, 0x0f, 0x74, 0x95,
+	0x38, 0x6c, 0x21, 0x18, 0x7e, 0x10, 0xaf, 0x3c, 0xf7, 0xa8, 0xff, 0xbe, 0xe3, 0x1e, 0x0c, 0x51,
+	0x79, 0x50, 0x42, 0x55, 0x79, 0x02, 0x65, 0x21, 0x77, 0xd8, 0x62, 0x48, 0xc7, 0x1d, 0x52, 0x4a,
+	0x62, 0x8d, 0x8f, 0x0a, 0xbc, 0xf4, 0x24, 0x5c, 0x23, 0x50, 0x62, 0x29, 0x8d, 0x89, 0xc9, 0xff,
+	0x67, 0xeb, 0x8c, 0x42, 0x6c, 0x9d, 0x8b, 0xe1, 0x3a, 0xa3, 0x2c, 0x5b, 0x67, 0x04, 0x34, 0x3b,
+	0xa4, 0x01, 0xe5, 0x56, 0x8f, 0x91, 0x5c, 0x0b, 0xe9, 0x78, 0xb9, 0x21, 0xbe, 0xdd, 0x1b, 0xf2,
+	0x63, 0xbc, 0x71, 0xd3, 0x3e, 0x32, 0x25, 0x08, 0xab, 0xd2, 0x84, 0x26, 0xf5, 0x6d, 0x49, 0x88,
+	0x93, 0x9e, 0x56, 0x48, 0x92, 0x09, 0x4f, 0x8d, 0x8f, 0x91, 0x24, 0x71, 0x7c, 0x04, 0x92, 0x4c,
+	0x48, 0x0e, 0x90, 0x64, 0x74, 0x49, 0x8b, 0x39, 0x96, 0xb4, 0xfe, 0xd1, 0x29, 0x92, 0x6a, 0xca,
+	0x64, 0x46, 0x26, 0xd5, 0x09, 0x10, 0x67, 0xe8, 0x52, 0x48, 0x9c, 0x18, 0x58, 0x2d, 0x71, 0xca,
+	0x48, 0x07, 0x60, 0xe3, 0x26, 0x7f, 0x65, 0x6e, 0x75, 0xfb, 0x9e, 0x4f, 0xdd, 0x48, 0xb1, 0x6d,
+	0x8b, 0x91, 0x04, 0x0d, 0x21, 0x8e, 0xe5, 0x11, 0x02, 0x9a, 0x1d, 0x4c, 0xf7, 0x40, 0x45, 0x98,
+	0xee, 0x08, 0xd1, 0xa5, 0xbb, 0x94, 0x92, 0x58, 0xe3, 0xdf, 0x45, 0x91, 0x7b, 0xf8, 0x60, 0x84,
+	0xdc, 0x4b, 0x48, 0x0e, 0x16, 0xe8, 0xd3, 0xcc, 0xa5, 0x14, 0xe7, 0x4e, 0x33, 0x97, 0x42, 0x97,
+	0xc2, 0x5c, 0xc2, 0x68, 0x68, 0x73, 0x49, 0x86, 0x2e, 0x00, 0x1b, 0xbf, 0x28, 0x40, 0xed, 0x2e,
+	0x3d, 0x32, 0x1d, 0xbf, 0xe5, 0xb3, 0x3d, 0xec, 0x35, 0x38, 0xc3, 0x92, 0x8c, 0xba, 0xbb, 0xef,
+	0x39, 0x96, 0xbd, 0xeb, 0x3b, 0x07, 0xd4, 0xe6, 0xae, 0x55, 0xcc, 0x45, 0xf1, 0xe0, 0x0d, 0xc7,
+	0xb2, 0x1f, 0xb0, 0x61, 0x72, 0x1d, 0xc8, 0x61, 0xcb, 0x6e, 0xed, 0xc7, 0xc1, 0x62, 0xd7, 0xbf,
+	0x84, 0x4f, 0x94, 0xe8, 0xbe, 0xdd, 0x75, 0xda, 0x07, 0xbb, 0x6c, 0xd6, 0xd3, 0x31, 0xf4, 0x3b,
+	0xfc, 0xc1, 0x5d, 0x7a, 0x64, 0xfc, 0x24, 0xd8, 0xd8, 0x8f, 0x93, 0xe7, 0x6c, 0x63, 0x2f, 0xd1,
+	0xc3, 0x6c, 0xec, 0x51, 0x66, 0x88, 0x8d, 0x3d, 0x5a, 0x8f, 0x6c, 0xec, 0x6f, 0xb2, 0x8d, 0xbd,
+	0x58, 0x55, 0x5e, 0x98, 0x53, 0x04, 0x23, 0x8b, 0xbf, 0x55, 0xfa, 0xe4, 0x78, 0x6d, 0xca, 0x0c,
+	0xc4, 0xc2, 0x8d, 0xfa, 0x84, 0x5e, 0xd4, 0x57, 0x61, 0x89, 0x7f, 0x7a, 0xb5, 0x5d, 0xea, 0xcb,
+	0xf5, 0xbc, 0x0a, 0x55, 0x8f, 0x0f, 0x84, 0xcb, 0x39, 0x77, 0x72, 0xbc, 0x56, 0x11, 0xa8, 0xe6,
+	0x36, 0xdb, 0x76, 0xf1, 0xff, 0x3a, 0xc6, 0x1d, 0xfc, 0x4a, 0x14, 0xe2, 0xe8, 0xca, 0x26, 0xcc,
+	0x0a, 0x00, 0x7a, 0x52, 0x57, 0x6f, 0xfe, 0xb8, 0x0c, 0x22, 0x8d, 0xbf, 0x14, 0xe0, 0xac, 0xfc,
+	0x02, 0x19, 0xcd, 0x17, 0xb2, 0x05, 0x0b, 0x08, 0x1d, 0x22, 0xae, 0xf3, 0x42, 0x44, 0x86, 0x75,
+	0x33, 0x16, 0xd6, 0xd5, 0x74, 0xc7, 0x23, 0xfb, 0x9f, 0x37, 0xc2, 0xef, 0xcd, 0xb1, 0x97, 0xe1,
+	0x5f, 0x45, 0x20, 0x62, 0x0f, 0xca, 0x7e, 0x06, 0xb4, 0xf9, 0x7a, 0x92, 0x36, 0x1b, 0xe9, 0x9b,
+	0xd7, 0xa8, 0xe0, 0x20, 0x6b, 0x7e, 0x38, 0x79, 0xd6, 0x34, 0x13, 0xac, 0xf9, 0xd2, 0x70, 0xbe,
+	0x9d, 0x0a, 0x69, 0xde, 0x95, 0xdf, 0x8f, 0xe8, 0x11, 0x86, 0xec, 0xab, 0xec, 0x6b, 0x97, 0x0f,
+	0x21, 0x65, 0xea, 0x62, 0x26, 0xa1, 0x46, 0x13, 0xce, 0xca, 0xa3, 0x97, 0x68, 0xea, 0x6e, 0xc6,
+	0x36, 0xd3, 0xb9, 0x73, 0x29, 0xae, 0x6a, 0x8c, 0x5c, 0xfa, 0x16, 0x9c, 0x95, 0x5f, 0xcf, 0x23,
+	0xbe, 0xdd, 0xe7, 0xc3, 0xaf, 0xf8, 0xa8, 0x37, 0x48, 0x1a, 0xb7, 0x1c, 0xfb, 0x91, 0xb5, 0x1f,
+	0x51, 0xdb, 0xe6, 0x03, 0x09, 0xb5, 0x02, 0xc5, 0xd4, 0x8a, 0xc7, 0x01, 0x69, 0x48, 0xf1, 0x70,
+	0x86, 0x02, 0xa0, 0x9b, 0x21, 0xca, 0x20, 0x32, 0x42, 0x1a, 0xa3, 0xfa, 0xc2, 0x48, 0x03, 0xa1,
+	0xc3, 0x90, 0x86, 0x10, 0x19, 0x82, 0x34, 0x84, 0x65, 0x15, 0x69, 0x4c, 0x60, 0x19, 0x24, 0x69,
+	0x88, 0xe1, 0x11, 0x48, 0x23, 0x2e, 0xf8, 0xff, 0x45, 0x1a, 0x6a, 0xdf, 0x4e, 0x93, 0x34, 0x02,
+	0x8f, 0x42, 0xd2, 0x10, 0x81, 0xd0, 0x92, 0x06, 0xc6, 0x4c, 0x42, 0x43, 0xd2, 0x88, 0xa7, 0x6e,
+	0x0e, 0xd2, 0x50, 0xe5, 0x52, 0x5c, 0xd5, 0x18, 0xb9, 0x14, 0x90, 0xc6, 0xc8, 0x6f, 0x77, 0x40,
+	0x1a, 0x71, 0x6f, 0x8c, 0x1f, 0xc0, 0x79, 0xe1, 0xe5, 0xed, 0x0f, 0x7c, 0x6a, 0xf3, 0xf7, 0x08,
+	0x95, 0xdf, 0x84, 0x5a, 0xcb, 0xb6, 0x71, 0x87, 0xe3, 0xe9, 0x0e, 0x1f, 0x6e, 0x86, 0x30, 0x33,
+	0x2a, 0x43, 0x2e, 0x40, 0xad, 0x43, 0xbd, 0xb6, 0x6b, 0xf5, 0x7c, 0xf9, 0x0e, 0x57, 0xcd, 0xe8,
+	0x90, 0xf1, 0x10, 0x9e, 0x18, 0x30, 0x8f, 0xeb, 0xf4, 0x32, 0x54, 0xa9, 0x1c, 0x44, 0xeb, 0xca,
+	0x5e, 0x45, 0x28, 0x19, 0xe2, 0x8d, 0x37, 0xe1, 0xbc, 0x98, 0xee, 0xc0, 0xb4, 0x36, 0x61, 0x2e,
+	0x80, 0x85, 0xcb, 0xb6, 0x78, 0x72, 0xbc, 0x56, 0x0b, 0xb0, 0xcd, 0x6d, 0xb3, 0x16, 0x80, 0x9a,
+	0x1d, 0xe3, 0x49, 0x78, 0x62, 0x40, 0x1b, 0xae, 0x5f, 0x13, 0xce, 0xde, 0xa1, 0xfe, 0x44, 0xac,
+	0xec, 0xc0, 0x72, 0x5c, 0xd5, 0x24, 0x16, 0xe2, 0xd7, 0x05, 0x79, 0x0e, 0x64, 0x52, 0xcf, 0xe9,
+	0xbb, 0xe1, 0xa1, 0xef, 0x04, 0xe2, 0x4b, 0xa0, 0x74, 0x60, 0xd9, 0x78, 0x18, 0x62, 0xf2, 0xff,
+	0x49, 0x03, 0xca, 0xbd, 0xd6, 0x51, 0xd7, 0x69, 0x75, 0xf4, 0xe7, 0x39, 0x08, 0x32, 0x4c, 0x99,
+	0x80, 0xa1, 0x7f, 0x38, 0xef, 0x1b, 0x50, 0x71, 0x71, 0x0c, 0xbd, 0x53, 0x36, 0x6d, 0x03, 0xb9,
+	0x00, 0x6d, 0xbc, 0x2e, 0x0f, 0x5f, 0x92, 0x73, 0xde, 0x80, 0x9a, 0x04, 0x85, 0x51, 0xe1, 0x84,
+	0x28, 0x91, 0xcd, 0x6d, 0x13, 0x24, 0xa4, 0xd9, 0x31, 0x56, 0x64, 0x1e, 0x25, 0xbd, 0x33, 0x7e,
+	0x5a, 0x94, 0x7b, 0xfe, 0x71, 0x8d, 0x90, 0xd7, 0x60, 0x29, 0x10, 0x18, 0xa2, 0xde, 0x2d, 0x4a,
+	0x21, 0x59, 0xf1, 0x12, 0x11, 0x9d, 0x1e, 0x21, 0xa2, 0x91, 0xe8, 0x95, 0x72, 0x46, 0x2f, 0xb9,
+	0x08, 0x63, 0x47, 0xef, 0x36, 0x3f, 0xf2, 0x18, 0x3b, 0x74, 0xf7, 0xf9, 0x9b, 0x39, 0x41, 0xbf,
+	0xfe, 0x5b, 0x14, 0xdf, 0xf4, 0xf2, 0x51, 0x50, 0xd2, 0xdf, 0x48, 0x96, 0xf4, 0x67, 0xd3, 0xca,
+	0x66, 0x52, 0x74, 0xb0, 0xa8, 0xff, 0x6a, 0xf2, 0x45, 0xfd, 0x41, 0xa2, 0xa8, 0xbf, 0x32, 0xac,
+	0x77, 0xa3, 0x77, 0x38, 0x24, 0x41, 0xcc, 0x84, 0x04, 0x31, 0x4e, 0xa9, 0xdf, 0x81, 0x73, 0x09,
+	0x3f, 0x31, 0xa8, 0x2f, 0x41, 0x55, 0x86, 0x49, 0x96, 0x7b, 0x7d, 0x54, 0x43, 0x78, 0x58, 0xf2,
+	0x1f, 0x3a, 0xdd, 0xfe, 0x21, 0x1d, 0xa2, 0xe4, 0x0b, 0x01, 0x55, 0xc9, 0x97, 0xaa, 0xc2, 0x92,
+	0xff, 0x98, 0x8f, 0xe8, 0x4a, 0x3e, 0xca, 0x20, 0x12, 0x77, 0xf3, 0x71, 0x9f, 0xae, 0x42, 0x55,
+	0x3c, 0x4d, 0xd4, 0x7b, 0x81, 0x62, 0xf5, 0x5e, 0x3c, 0x0e, 0x76, 0xf3, 0x13, 0xf0, 0x23, 0xdc,
+	0xcd, 0x8f, 0xea, 0x0b, 0xdb, 0xcd, 0x23, 0x74, 0x98, 0xdd, 0xbc, 0x10, 0x19, 0x62, 0x37, 0xaf,
+	0x0a, 0x47, 0xdc, 0xf3, 0x31, 0x96, 0xe1, 0x97, 0xd3, 0x62, 0x37, 0x2f, 0x86, 0x47, 0xd8, 0xcd,
+	0xc7, 0x05, 0x07, 0x5f, 0xfc, 0x3f, 0x9f, 0xe2, 0x6e, 0x5e, 0xed, 0xdb, 0xe8, 0xaf, 0xfd, 0x79,
+	0x98, 0xdd, 0x77, 0x9d, 0x7e, 0x4f, 0xb6, 0x35, 0xf1, 0x17, 0x59, 0x81, 0x72, 0xc7, 0xb5, 0x58,
+	0x12, 0xe0, 0xdd, 0x36, 0xf9, 0x73, 0x02, 0xfb, 0xff, 0x60, 0x0e, 0xe1, 0xfe, 0x5f, 0x84, 0x4e,
+	0xbb, 0xff, 0xc7, 0x28, 0x4b, 0xa8, 0xf1, 0x50, 0x6e, 0xb4, 0x47, 0x4e, 0x76, 0xf5, 0xb5, 0xad,
+	0x60, 0xfb, 0x1d, 0x4f, 0xc5, 0xcd, 0xbf, 0xaf, 0x43, 0xf9, 0x96, 0xb8, 0x69, 0x4b, 0x2c, 0x28,
+	0xe3, 0x45, 0x51, 0x62, 0xa8, 0x7c, 0x8d, 0x5f, 0x3e, 0xad, 0x5f, 0xd4, 0x62, 0x70, 0x97, 0x72,
+	0xee, 0x6f, 0x7f, 0xf8, 0xcf, 0xc7, 0xc5, 0x45, 0x98, 0xe7, 0xa0, 0xaf, 0xe0, 0xe9, 0x2d, 0x71,
+	0xa0, 0x1a, 0xdc, 0xe5, 0x23, 0xcf, 0xe4, 0xb9, 0x48, 0x59, 0xbf, 0x94, 0x81, 0xd2, 0x1b, 0x74,
+	0x01, 0xc2, 0xab, 0x74, 0xe4, 0x52, 0xfa, 0xc5, 0x89, 0xe8, 0x0c, 0x2f, 0x67, 0xc1, 0x32, 0x6d,
+	0x86, 0x57, 0xe5, 0xd4, 0x36, 0x07, 0xae, 0xe6, 0xa9, 0x6d, 0x2a, 0x6e, 0xdc, 0xa5, 0xd8, 0x14,
+	0x31, 0x7c, 0xd0, 0xf2, 0x0e, 0x52, 0x63, 0x18, 0xb9, 0x2a, 0x97, 0x1a, 0xc3, 0xd8, 0xa5, 0x38,
+	0x7d, 0x0c, 0x45, 0x8f, 0xf9, 0x99, 0x3c, 0x17, 0xcf, 0xd2, 0x63, 0x18, 0xbb, 0x31, 0x95, 0xb9,
+	0x9e, 0x7c, 0x7a, 0x9a, 0xf5, 0x8c, 0xce, 0xf0, 0x72, 0x16, 0x2c, 0xd3, 0x66, 0x78, 0x07, 0x49,
+	0x6d, 0x73, 0xe0, 0x3e, 0x94, 0xda, 0xe6, 0xe0, 0x55, 0xa6, 0x34, 0x9b, 0x1f, 0xc0, 0x5c, 0xf4,
+	0xfe, 0x04, 0xb9, 0x92, 0xf3, 0x42, 0x48, 0x7d, 0x3d, 0x1b, 0xa8, 0xb7, 0xfc, 0x7d, 0x98, 0x8f,
+	0xdd, 0x16, 0x23, 0x4a, 0x8d, 0xaa, 0xdb, 0x69, 0xf5, 0xab, 0x39, 0x90, 0x99, 0xc6, 0x63, 0x97,
+	0x8d, 0xd4, 0xc6, 0x55, 0xd7, 0x9b, 0xd4, 0xc6, 0x95, 0x37, 0x97, 0x34, 0xc6, 0x63, 0x77, 0x8a,
+	0xd4, 0xc6, 0x55, 0x97, 0x97, 0xd4, 0xc6, 0xd5, 0x17, 0x94, 0x52, 0x8c, 0xff, 0xac, 0x10, 0xbb,
+	0xb7, 0x24, 0xaf, 0x98, 0x90, 0x46, 0xee, 0xbb, 0x28, 0xc2, 0x93, 0x8d, 0x21, 0xef, 0xae, 0xe8,
+	0x93, 0x1e, 0xdb, 0xc9, 0xa9, 0x49, 0x1f, 0xbf, 0xb2, 0x90, 0x9a, 0xf4, 0xc9, 0xfb, 0x07, 0xfa,
+	0xa4, 0x97, 0xbd, 0xef, 0xf4, 0xa4, 0x4f, 0x34, 0xec, 0xd3, 0x93, 0x3e, 0xd9, 0x46, 0xcf, 0x4c,
+	0x7a, 0x39, 0x61, 0x4d, 0xd2, 0x27, 0xe6, 0x7c, 0x35, 0x07, 0x32, 0x67, 0xde, 0x69, 0x8d, 0xab,
+	0xee, 0x88, 0xe8, 0xf2, 0x2e, 0xa7, 0x71, 0x11, 0x67, 0x6c, 0xfe, 0xa5, 0xc6, 0x39, 0xde, 0x56,
+	0x4d, 0x8d, 0x73, 0xa2, 0xf3, 0x98, 0x11, 0x67, 0xd9, 0x97, 0x4e, 0x8f, 0x73, 0xa2, 0x99, 0x9e,
+	0x1e, 0xe7, 0x64, 0x8b, 0x3b, 0x93, 0x5f, 0xe4, 0x84, 0x35, 0xfc, 0x92, 0x98, 0xf3, 0xd5, 0x1c,
+	0xc8, 0xcc, 0x62, 0x19, 0x74, 0x44, 0xd5, 0xc5, 0x32, 0xd9, 0x6f, 0xad, 0x5f, 0xca, 0x40, 0x65,
+	0xae, 0x73, 0xb4, 0xfd, 0xa8, 0x5e, 0x67, 0x45, 0x6b, 0xb5, 0xbe, 0x9e, 0x0d, 0xd4, 0x5b, 0xee,
+	0x43, 0x2d, 0xd2, 0x44, 0x23, 0x97, 0xf3, 0xf5, 0xfd, 0xea, 0x57, 0x32, 0x71, 0x99, 0x13, 0x8e,
+	0xf6, 0xc8, 0xd4, 0x13, 0x56, 0x34, 0xe4, 0xea, 0xeb, 0xd9, 0xc0, 0x4c, 0xcb, 0xd1, 0x7e, 0x98,
+	0xda, 0xb2, 0xa2, 0xe7, 0x56, 0x5f, 0xcf, 0x06, 0xe6, 0xc9, 0x2a, 0x71, 0xa2, 0x9e, 0x9a, 0x55,
+	0xb1, 0x23, 0xfb, 0xd4, 0xac, 0x4a, 0x1c, 0xcb, 0x67, 0x65, 0x15, 0xda, 0xd4, 0x64, 0x55, 0xdc,
+	0xec, 0x7a, 0x36, 0x30, 0x57, 0x56, 0x61, 0x97, 0x25, 0x3d, 0xab, 0xe2, 0x8d, 0xa1, 0xf4, 0xac,
+	0x4a, 0xb4, 0x6b, 0x32, 0xb3, 0x4a, 0x37, 0x61, 0x45, 0xc7, 0x46, 0x97, 0x55, 0xb9, 0x97, 0x3a,
+	0xda, 0x30, 0xd1, 0x65, 0x55, 0x0e, 0xcb, 0xca, 0xde, 0x4b, 0xba, 0xe5, 0x68, 0x1f, 0x40, 0x6d,
+	0x59, 0xd1, 0x74, 0x50, 0x5b, 0x56, 0xb5, 0x14, 0xd2, 0x2c, 0xff, 0xb8, 0x00, 0x8b, 0x89, 0x76,
+	0x0c, 0xb9, 0x96, 0xbe, 0x90, 0x03, 0x0e, 0x7c, 0x39, 0x17, 0x36, 0xdb, 0x87, 0x44, 0xb3, 0x45,
+	0xed, 0x83, 0xba, 0xbf, 0xa3, 0xf6, 0x21, 0xad, 0x7b, 0x93, 0x9e, 0xec, 0x91, 0xa3, 0x63, 0x92,
+	0x56, 0x72, 0x13, 0x47, 0xd4, 0xf5, 0x2b, 0x99, 0x38, 0xbd, 0xd9, 0x1f, 0xc2, 0x42, 0xfc, 0x30,
+	0x9d, 0x68, 0x0a, 0x5f, 0xd2, 0xf8, 0xb5, 0x3c, 0xd0, 0xcc, 0x0a, 0x1d, 0x3b, 0x5e, 0x25, 0xeb,
+	0x79, 0x4f, 0x8a, 0xd5, 0x15, 0x5a, 0x79, 0x56, 0xab, 0x99, 0x7c, 0xbc, 0x0f, 0x44, 0x34, 0xbb,
+	0xbb, 0x5c, 0x93, 0x57, 0xb7, 0x95, 0x34, 0xf6, 0xe3, 0x9d, 0x1e, 0xa2, 0xd9, 0xe0, 0xe5, 0xb2,
+	0x9f, 0xd2, 0x38, 0xca, 0x62, 0x3a, 0x71, 0x42, 0xa4, 0x63, 0xba, 0xd8, 0xd9, 0x94, 0x8e, 0xe9,
+	0xe2, 0x87, 0x4d, 0xfa, 0x2a, 0x86, 0x66, 0xd3, 0xaa, 0x58, 0xdc, 0xe6, 0xa5, 0x0c, 0x54, 0xce,
+	0x2a, 0xa6, 0x9b, 0xaa, 0xe2, 0xcc, 0x59, 0x57, 0xc5, 0xf2, 0x59, 0xc6, 0x2a, 0x86, 0x67, 0x85,
+	0xe9, 0x55, 0x2c, 0x7e, 0x20, 0x9a, 0x5e, 0xc5, 0x12, 0x87, 0x8e, 0x99, 0xb5, 0x44, 0x37, 0x61,
+	0xc5, 0xb9, 0xa3, 0xae, 0x96, 0xe4, 0x9a, 0xf0, 0xd6, 0x33, 0x9f, 0x7c, 0xbe, 0x3a, 0xf5, 0xd9,
+	0xe7, 0xab, 0x53, 0x3f, 0x3a, 0x59, 0x2d, 0x7c, 0x72, 0xb2, 0x5a, 0xf8, 0xf4, 0x64, 0xb5, 0xf0,
+	0xcf, 0x93, 0xd5, 0xc2, 0xcf, 0xbf, 0x58, 0x9d, 0xfa, 0xf4, 0x8b, 0xd5, 0xa9, 0xcf, 0xbe, 0x58,
+	0x9d, 0xda, 0x9b, 0xe5, 0xcd, 0xbd, 0xe7, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0x79, 0x77, 0x4d,
+	0x1d, 0x14, 0x40, 0x00, 0x00,
 }
 
 type authenticatedWrapperControlServer struct {
@@ -5093,6 +5099,10 @@ func (m *GetNetworkRequest) CopyFrom(src interface{}) {
 
 	o := src.(*GetNetworkRequest)
 	*m = *o
+	if o.Appdata != nil {
+		m.Appdata = &types.Any{}
+		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Appdata, o.Appdata)
+	}
 }
 
 func (m *GetNetworkResponse) Copy() *GetNetworkResponse {
@@ -5156,6 +5166,10 @@ func (m *ListNetworksRequest) CopyFrom(src interface{}) {
 		m.Filters = &ListNetworksRequest_Filters{}
 		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Filters, o.Filters)
 	}
+	if o.Appdata != nil {
+		m.Appdata = &types.Any{}
+		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Appdata, o.Appdata)
+	}
 }
 
 func (m *ListNetworksRequest_Filters) Copy() *ListNetworksRequest_Filters {
@@ -9505,6 +9519,18 @@ func (m *GetNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Appdata != nil {
+		{
+			size, err := m.Appdata.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintControl(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
 	if len(m.NetworkID) > 0 {
 		i -= len(m.NetworkID)
 		copy(dAtA[i:], m.NetworkID)
@@ -9637,6 +9663,18 @@ func (m *ListNetworksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Appdata != nil {
+		{
+			size, err := m.Appdata.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintControl(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
 	if m.Filters != nil {
 		{
 			size, err := m.Filters.MarshalToSizedBuffer(dAtA[:i])
@@ -14216,6 +14254,10 @@ func (m *GetNetworkRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovControl(uint64(l))
 	}
+	if m.Appdata != nil {
+		l = m.Appdata.Size()
+		n += 1 + l + sovControl(uint64(l))
+	}
 	return n
 }
 
@@ -14268,6 +14310,10 @@ func (m *ListNetworksRequest) Size() (n int) {
 		l = m.Filters.Size()
 		n += 1 + l + sovControl(uint64(l))
 	}
+	if m.Appdata != nil {
+		l = m.Appdata.Size()
+		n += 1 + l + sovControl(uint64(l))
+	}
 	return n
 }
 
@@ -15675,6 +15721,7 @@ func (this *GetNetworkRequest) String() string {
 	s := strings.Join([]string{`&GetNetworkRequest{`,
 		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 		`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
+		`Appdata:` + strings.Replace(fmt.Sprintf("%v", this.Appdata), "Any", "types.Any", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -15715,6 +15762,7 @@ func (this *ListNetworksRequest) String() string {
 	}
 	s := strings.Join([]string{`&ListNetworksRequest{`,
 		`Filters:` + strings.Replace(fmt.Sprintf("%v", this.Filters), "ListNetworksRequest_Filters", "ListNetworksRequest_Filters", 1) + `,`,
+		`Appdata:` + strings.Replace(fmt.Sprintf("%v", this.Appdata), "Any", "types.Any", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -20443,6 +20491,42 @@ func (m *GetNetworkRequest) Unmarshal(dAtA []byte) error {
 			}
 			m.NetworkID = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Appdata", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowControl
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthControl
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthControl
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Appdata == nil {
+				m.Appdata = &types.Any{}
+			}
+			if err := m.Appdata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipControl(dAtA[iNdEx:])
@@ -20779,6 +20863,42 @@ func (m *ListNetworksRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Appdata", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowControl
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthControl
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthControl
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Appdata == nil {
+				m.Appdata = &types.Any{}
+			}
+			if err := m.Appdata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipControl(dAtA[iNdEx:])

vendor/github.com/moby/swarmkit/v2/api/control.proto

@@ -484,6 +484,8 @@ message CreateNetworkResponse {
 message GetNetworkRequest {
 	string name = 1;
 	string network_id = 2;
+	// Application-specific message for the NetworkAllocator's OnGetNetwork callback.
+	google.protobuf.Any appdata = 3;
 }
 
 message GetNetworkResponse {
@@ -507,6 +509,8 @@ message ListNetworksRequest {
 	}
 
 	Filters filters = 1;
+	// Application-specific message for the NetworkAllocator's OnGetNetwork callback.
+	google.protobuf.Any appdata = 2;
 }
 
 message ListNetworksResponse {

vendor/github.com/moby/swarmkit/v2/api/objects.pb.go

@@ -473,6 +473,10 @@ type Network struct {
 	// the services that still use this service, and proceed to delete
 	// this network when all of these services are gone
 	PendingDelete bool `protobuf:"varint,6,opt,name=pending_delete,json=pendingDelete,proto3" json:"pending_delete,omitempty"`
+	// Extra encodes application-specific information about the live state
+	// of the network. The syntax and semantics of the value are dictated by
+	// the network allocator implementation.
+	Extra *types.Any `protobuf:"bytes,7,opt,name=extra,proto3" json:"extra,omitempty"`
 }
 
 func (m *Network) Reset()      { *m = Network{} }
@@ -835,119 +839,120 @@ func init() {
 }
 
 var fileDescriptor_6218a23329ef342d = []byte{
-	// 1786 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcb, 0x73, 0x1c, 0x47,
-	0x19, 0xd7, 0xac, 0xc6, 0xfb, 0xf8, 0xf6, 0x81, 0xd3, 0x11, 0x62, 0x2c, 0xc4, 0x4a, 0x6c, 0x12,
-	0x70, 0xa5, 0x5c, 0xab, 0x60, 0x02, 0xc8, 0x22, 0x89, 0xbd, 0x2b, 0x09, 0x67, 0x49, 0x6c, 0xab,
-	0x5a, 0x89, 0x93, 0xdb, 0x30, 0x3b, 0xd3, 0x5a, 0x8f, 0x77, 0x76, 0x7a, 0x6a, 0xba, 0x67, 0xc3,
-	0x72, 0xe2, 0xec, 0x2a, 0xaa, 0xb8, 0xf9, 0xc6, 0x81, 0xe2, 0x9f, 0xe0, 0xc2, 0x81, 0x03, 0x65,
-	0x6e, 0x39, 0x51, 0x29, 0x0e, 0x2a, 0xbc, 0xfe, 0x2b, 0xb8, 0x51, 0xfd, 0x98, 0xdd, 0x91, 0x77,
-	0xf4, 0x30, 0xb8, 0x54, 0x9c, 0xb6, 0x1f, 0xbf, 0xdf, 0xd7, 0xdf, 0xf7, 0x75, 0x7f, 0x8f, 0x59,
-	0xb8, 0x31, 0xf0, 0xf9, 0xa3, 0xa4, 0xdf, 0x76, 0xe9, 0x68, 0xcb, 0xa3, 0xee, 0x90, 0xc4, 0x5b,
-	0xec, 0x2b, 0x27, 0x1e, 0x0d, 0x7d, 0xbe, 0xe5, 0x44, 0xfe, 0x16, 0xed, 0x3f, 0x26, 0x2e, 0x67,
-	0xed, 0x28, 0xa6, 0x9c, 0x22, 0xa4, 0x20, 0xed, 0x14, 0xd2, 0x1e, 0xff, 0x68, 0xed, 0xdd, 0x73,
-	0x24, 0xf0, 0x49, 0x44, 0x34, 0xff, 0x5c, 0x2c, 0x8b, 0x88, 0x9b, 0x62, 0x37, 0x06, 0x94, 0x0e,
-	0x02, 0xb2, 0x25, 0x67, 0xfd, 0xe4, 0x68, 0x8b, 0xfb, 0x23, 0xc2, 0xb8, 0x33, 0x8a, 0x34, 0x60,
-	0x65, 0x40, 0x07, 0x54, 0x0e, 0xb7, 0xc4, 0x48, 0xaf, 0x5e, 0x7b, 0x99, 0xe6, 0x84, 0x13, 0xbd,
-	0xf5, 0xb3, 0x33, 0x4e, 0x9f, 0xc1, 0xa3, 0x20, 0x19, 0xf8, 0xa1, 0xfe, 0x51, 0xc4, 0xd6, 0x9f,
-	0x0d, 0x30, 0xef, 0x11, 0xee, 0xa0, 0x9f, 0x43, 0x69, 0x4c, 0x62, 0xe6, 0xd3, 0xd0, 0x32, 0x36,
-	0x8d, 0xeb, 0xd5, 0x9b, 0xdf, 0x6d, 0x2f, 0x7a, 0xa4, 0xfd, 0x50, 0x41, 0xba, 0xe6, 0xb3, 0xe3,
-	0x8d, 0x25, 0x9c, 0x32, 0xd0, 0x2d, 0x00, 0x37, 0x26, 0x0e, 0x27, 0x9e, 0xed, 0x70, 0xab, 0x20,
-	0xf9, 0x6b, 0x6d, 0xa5, 0x6e, 0x3b, 0x3d, 0xbf, 0xfd, 0x59, 0x6a, 0x25, 0xae, 0x68, 0x74, 0x87,
-	0x0b, 0x6a, 0x12, 0x79, 0x29, 0x75, 0xf9, 0x7c, 0xaa, 0x46, 0x77, 0x78, 0xeb, 0x4f, 0x57, 0xc0,
-	0xbc, 0x4f, 0x3d, 0x82, 0x56, 0xa1, 0xe0, 0x7b, 0x52, 0xed, 0x4a, 0xb7, 0x38, 0x3d, 0xde, 0x28,
-	0xf4, 0xf6, 0x70, 0xc1, 0xf7, 0xd0, 0x4d, 0x30, 0x47, 0x84, 0x3b, 0x5a, 0x21, 0x2b, 0xcf, 0x20,
-	0x61, 0xbb, 0xb6, 0x46, 0x62, 0xd1, 0x4f, 0xc1, 0x14, 0x57, 0xa5, 0x35, 0x59, 0xcf, 0xe3, 0x88,
-	0x33, 0x0f, 0x23, 0xe2, 0xa6, 0x3c, 0x81, 0x47, 0xfb, 0x50, 0xf5, 0x08, 0x73, 0x63, 0x3f, 0xe2,
-	0xc2, 0x87, 0xa6, 0xa4, 0xbf, 0x75, 0x1a, 0x7d, 0x6f, 0x0e, 0xc5, 0x59, 0x1e, 0xfa, 0x00, 0x8a,
-	0x8c, 0x3b, 0x3c, 0x61, 0xd6, 0x15, 0x29, 0xa1, 0x79, 0xaa, 0x02, 0x12, 0xa5, 0x55, 0xd0, 0x1c,
-	0xf4, 0x31, 0x34, 0x46, 0x4e, 0xe8, 0x0c, 0x48, 0x6c, 0x6b, 0x29, 0x45, 0x29, 0xe5, 0xfb, 0xb9,
-	0xa6, 0x2b, 0xa4, 0x12, 0x84, 0xeb, 0xa3, 0xec, 0x14, 0xf5, 0x00, 0x1c, 0xce, 0x1d, 0xf7, 0xd1,
-	0x88, 0x84, 0xdc, 0x2a, 0x49, 0x29, 0xef, 0xe4, 0xea, 0x42, 0xf8, 0x57, 0x34, 0x1e, 0x76, 0x66,
-	0xe0, 0x6e, 0xc1, 0x32, 0x70, 0x86, 0x8c, 0xee, 0x42, 0xd5, 0x25, 0x31, 0xf7, 0x8f, 0x7c, 0xd7,
-	0xe1, 0xc4, 0x2a, 0x4b, 0x59, 0x1b, 0x79, 0xb2, 0x76, 0xe7, 0x30, 0x6d, 0x58, 0x96, 0x89, 0xde,
-	0x03, 0x33, 0xa6, 0x01, 0xb1, 0x2a, 0x9b, 0xc6, 0xf5, 0xc6, 0xe9, 0x57, 0x83, 0x69, 0x40, 0xb0,
-	0x44, 0x8a, 0xa3, 0xe7, 0x8a, 0x30, 0x0b, 0x36, 0x97, 0x2f, 0x6c, 0x06, 0xce, 0x32, 0x51, 0x0b,
-	0x6a, 0x0f, 0xbf, 0xfc, 0xb4, 0x73, 0xff, 0xf3, 0xbd, 0x83, 0x03, 0x1a, 0x73, 0xab, 0xba, 0x69,
-	0x5c, 0xaf, 0xe3, 0x13, 0x6b, 0x3b, 0xab, 0x4f, 0x9e, 0xb6, 0x10, 0x5c, 0x2d, 0x1b, 0x57, 0x0d,
-	0xf9, 0x16, 0x8d, 0xf7, 0x8c, 0x2f, 0x8d, 0x5f, 0x19, 0xad, 0xe7, 0x26, 0x94, 0x0e, 0x49, 0x3c,
-	0xf6, 0xdd, 0xd7, 0xfb, 0x52, 0x6f, 0x9d, 0x78, 0xa9, 0xb9, 0x0e, 0xd5, 0xc7, 0x2e, 0x3c, 0xd6,
-	0x8f, 0xa0, 0x26, 0x7e, 0xed, 0x34, 0xe2, 0xe1, 0xdc, 0x88, 0xc7, 0x55, 0x41, 0xd0, 0x13, 0xb4,
-	0x07, 0xf5, 0x28, 0x26, 0x63, 0x9f, 0x26, 0xcc, 0x96, 0x3a, 0x14, 0x2f, 0xa4, 0x03, 0xae, 0xa5,
-	0x2c, 0x31, 0x43, 0x0f, 0xe0, 0xdb, 0x27, 0xa4, 0xcc, 0xd4, 0xa9, 0x9e, 0xaf, 0xce, 0x9b, 0x59,
-	0x49, 0xa9, 0x5a, 0xdb, 0x50, 0x26, 0xa1, 0x17, 0x51, 0x3f, 0xe4, 0x3a, 0x00, 0x73, 0x1f, 0xc9,
-	0xbe, 0xc6, 0xe0, 0x19, 0x1a, 0xed, 0x43, 0x5d, 0xe5, 0x15, 0xfb, 0x44, 0xf4, 0x6d, 0xe6, 0xd1,
-	0x3f, 0x97, 0x40, 0x1d, 0x36, 0xb5, 0x24, 0x33, 0x43, 0x1f, 0x00, 0x3c, 0xa6, 0xfd, 0x54, 0x46,
-	0x4d, 0xca, 0xf8, 0x5e, 0x9e, 0x8c, 0x5f, 0xd2, 0xbe, 0x16, 0x50, 0x79, 0x9c, 0x0e, 0xd1, 0x3b,
-	0xd0, 0x88, 0x48, 0xe8, 0xf9, 0xe1, 0xc0, 0xf6, 0x48, 0x40, 0x38, 0x91, 0x71, 0x57, 0xc6, 0x75,
-	0xbd, 0xba, 0x27, 0x17, 0x77, 0xd0, 0x93, 0xa7, 0xad, 0x06, 0xd4, 0xb2, 0xef, 0xac, 0xf5, 0x87,
-	0x02, 0x94, 0x53, 0xb3, 0xd0, 0xfb, 0xfa, 0x61, 0x18, 0xa7, 0xdb, 0x90, 0x62, 0xe5, 0xad, 0xa8,
-	0x37, 0xf1, 0x3e, 0x5c, 0x89, 0x68, 0xcc, 0x99, 0x55, 0x90, 0x51, 0x92, 0x9b, 0x78, 0xc4, 0x3b,
-	0xdf, 0xa5, 0xe1, 0x91, 0x3f, 0xc0, 0x0a, 0x8c, 0xbe, 0x80, 0xea, 0xd8, 0x8f, 0x79, 0xe2, 0x04,
-	0xb6, 0x1f, 0x31, 0x6b, 0x59, 0x72, 0x7f, 0x70, 0xd6, 0x91, 0xed, 0x87, 0x0a, 0xdf, 0x3b, 0xe8,
-	0x36, 0xa6, 0xc7, 0x1b, 0x30, 0x9b, 0x32, 0x0c, 0x5a, 0x54, 0x2f, 0x62, 0x6b, 0xf7, 0xa0, 0x32,
-	0xdb, 0x41, 0x37, 0x00, 0x42, 0x15, 0xa0, 0xf6, 0x2c, 0x7c, 0xea, 0xd3, 0xe3, 0x8d, 0x8a, 0x0e,
-	0xdb, 0xde, 0x1e, 0xae, 0x68, 0x40, 0xcf, 0x43, 0x08, 0x4c, 0xc7, 0xf3, 0x62, 0x19, 0x4c, 0x15,
-	0x2c, 0xc7, 0xad, 0xdf, 0x95, 0xc1, 0xfc, 0xcc, 0x61, 0xc3, 0xcb, 0xae, 0x15, 0xe2, 0xcc, 0x73,
-	0xc3, 0xaf, 0xf1, 0x8a, 0xe1, 0x77, 0x03, 0x80, 0xa9, 0xa8, 0x12, 0xee, 0x30, 0xe7, 0xee, 0xd0,
-	0xb1, 0x26, 0xdc, 0xa1, 0x01, 0xca, 0x1d, 0x2c, 0xa0, 0x5c, 0x3e, 0x69, 0x13, 0xcb, 0x31, 0x7a,
-	0x0b, 0x4a, 0x21, 0xf5, 0x24, 0xbd, 0x28, 0xe9, 0x30, 0x3d, 0xde, 0x28, 0x8a, 0xec, 0xd9, 0xdb,
-	0xc3, 0x45, 0xb1, 0xd5, 0xf3, 0x64, 0xf6, 0x0c, 0x43, 0xca, 0x1d, 0x51, 0x99, 0x98, 0x2e, 0x02,
-	0xb9, 0x31, 0xde, 0x99, 0xc3, 0xd2, 0xc4, 0x9d, 0x61, 0xa2, 0x87, 0xf0, 0x66, 0xaa, 0x6f, 0x56,
-	0x60, 0xf9, 0x55, 0x04, 0x22, 0x2d, 0x21, 0xb3, 0x93, 0x29, 0x96, 0x95, 0xd3, 0x8b, 0xa5, 0xbc,
-	0x81, 0xbc, 0x62, 0xd9, 0x85, 0xba, 0x47, 0x98, 0x1f, 0x13, 0x4f, 0x06, 0x2c, 0x91, 0x59, 0xb0,
-	0x91, 0x1f, 0xaf, 0xa9, 0x10, 0x82, 0x6b, 0x9a, 0x23, 0x67, 0xa8, 0x03, 0x65, 0xfd, 0xee, 0x98,
-	0x55, 0x7d, 0x95, 0xea, 0x32, 0xa3, 0x9d, 0x48, 0x5a, 0xb5, 0x57, 0x4a, 0x5a, 0xb7, 0x00, 0x02,
-	0x3a, 0xb0, 0xbd, 0xd8, 0x1f, 0x93, 0xd8, 0xaa, 0xeb, 0xd6, 0x29, 0x87, 0xbb, 0x27, 0x11, 0xb8,
-	0x12, 0xd0, 0x81, 0x1a, 0x22, 0x07, 0xd6, 0x1c, 0xc6, 0xfc, 0x41, 0x48, 0x3c, 0x7b, 0x40, 0x42,
-	0x12, 0xfb, 0xae, 0x1d, 0x13, 0x46, 0x93, 0xd8, 0x25, 0xcc, 0xfa, 0x96, 0xb4, 0x24, 0xb7, 0x79,
-	0xb9, 0xab, 0xc0, 0x58, 0x63, 0xb1, 0x95, 0x8a, 0x79, 0x69, 0x83, 0xa1, 0x3b, 0x50, 0x17, 0xb9,
-	0xd0, 0xe7, 0x24, 0x96, 0xd7, 0x65, 0x5d, 0x3d, 0xff, 0x95, 0xd7, 0x1e, 0xd3, 0x7e, 0x2f, 0x25,
-	0xa0, 0x8f, 0xa0, 0x34, 0xa6, 0x41, 0x32, 0x22, 0xcc, 0x7a, 0x43, 0x6a, 0xf4, 0x76, 0x2e, 0x57,
-	0x42, 0x32, 0xae, 0x4d, 0x49, 0x3b, 0x6b, 0x4f, 0x9e, 0xb6, 0x56, 0x61, 0x25, 0x9b, 0x28, 0xb7,
-	0x8d, 0x3b, 0xc6, 0xc7, 0xc6, 0x81, 0xd1, 0xfa, 0x6b, 0x01, 0xde, 0x58, 0xb8, 0x15, 0xf4, 0x13,
-	0x28, 0xe9, 0x7b, 0x39, 0xab, 0x09, 0xd6, 0x3c, 0x9c, 0x62, 0xd1, 0x3a, 0x54, 0x44, 0x92, 0x21,
-	0x8c, 0x11, 0x95, 0x3e, 0x2b, 0x78, 0xbe, 0x80, 0x2c, 0x28, 0x39, 0x81, 0xef, 0x88, 0xbd, 0x65,
-	0xb9, 0x97, 0x4e, 0x51, 0x02, 0xab, 0xea, 0xf2, 0xec, 0x79, 0xaf, 0x61, 0xd3, 0x88, 0x33, 0xcb,
-	0x94, 0xf6, 0xde, 0xbe, 0xd0, 0x5b, 0xd2, 0xd7, 0x3b, 0x5f, 0x78, 0x10, 0x71, 0xb6, 0x1f, 0xf2,
-	0x78, 0x82, 0x57, 0xbc, 0x9c, 0xad, 0xb5, 0xbb, 0x70, 0xed, 0x54, 0x0a, 0xba, 0x0a, 0xcb, 0x43,
-	0x32, 0x51, 0x09, 0x12, 0x8b, 0x21, 0x5a, 0x81, 0x2b, 0x63, 0x27, 0x48, 0x88, 0xce, 0xa7, 0x6a,
-	0xb2, 0x53, 0xd8, 0x36, 0x5a, 0x7f, 0x2f, 0x40, 0x49, 0xab, 0x73, 0xd9, 0x9d, 0x8d, 0x3e, 0x76,
-	0x21, 0xb5, 0x7e, 0x08, 0x35, 0xed, 0x52, 0x15, 0xd3, 0xe6, 0xb9, 0x51, 0x51, 0x55, 0x78, 0x15,
-	0xcf, 0x1f, 0x82, 0xe9, 0x47, 0xce, 0x48, 0x97, 0xff, 0xdc, 0x93, 0x7b, 0x07, 0x9d, 0x7b, 0x0f,
-	0x22, 0x95, 0x9a, 0xca, 0xd3, 0xe3, 0x0d, 0x53, 0x2c, 0x60, 0x49, 0xcb, 0xa9, 0xe0, 0xc5, 0x8b,
-	0x56, 0xf0, 0xbf, 0x15, 0xa1, 0xb4, 0x1b, 0x24, 0x8c, 0x93, 0xf8, 0xb2, 0x7d, 0xa9, 0x8f, 0x5d,
-	0xf0, 0xe5, 0x2e, 0x94, 0x62, 0x4a, 0xb9, 0xed, 0x3a, 0x67, 0xb9, 0x11, 0x53, 0xca, 0x77, 0x3b,
-	0xdd, 0x86, 0x20, 0x8a, 0x22, 0xa2, 0xe6, 0xb8, 0x28, 0xa8, 0xbb, 0x0e, 0xfa, 0x02, 0x56, 0xd3,
-	0xd2, 0xdd, 0xa7, 0x94, 0x33, 0x1e, 0x3b, 0x91, 0x3d, 0x24, 0x13, 0xd1, 0x62, 0x2d, 0x9f, 0xf6,
-	0x69, 0xb2, 0x1f, 0xba, 0xf1, 0x44, 0xfa, 0xf8, 0x13, 0x32, 0xc1, 0x2b, 0x5a, 0x40, 0x37, 0xe5,
-	0x7f, 0x42, 0x26, 0x0c, 0xdd, 0x86, 0x75, 0x32, 0x83, 0x09, 0x89, 0x76, 0xe0, 0x8c, 0x44, 0x53,
-	0x62, 0xbb, 0x01, 0x75, 0x87, 0xd2, 0xf3, 0x26, 0xbe, 0x46, 0xb2, 0xa2, 0x3e, 0x55, 0x88, 0x5d,
-	0x01, 0x40, 0x0c, 0xac, 0x7e, 0xe0, 0xb8, 0xc3, 0xc0, 0x67, 0xe2, 0xeb, 0x33, 0xf3, 0xa5, 0x21,
-	0x4a, 0x93, 0xd0, 0x6d, 0xfb, 0x0c, 0x6f, 0xb5, 0xbb, 0x73, 0x6e, 0xe6, 0xbb, 0x45, 0x07, 0xde,
-	0x77, 0xfa, 0xf9, 0xbb, 0xa8, 0x0b, 0xd5, 0x24, 0x14, 0xc7, 0x2b, 0x1f, 0x54, 0x2e, 0xea, 0x03,
-	0x50, 0x2c, 0x69, 0xf9, 0x3a, 0x98, 0x47, 0xa2, 0xd9, 0x12, 0xf5, 0xaa, 0xac, 0xde, 0xe0, 0x2f,
-	0x7a, 0x07, 0x87, 0x58, 0xae, 0xa2, 0x36, 0x20, 0x8f, 0x1c, 0x39, 0x49, 0xc0, 0x3b, 0x2a, 0x05,
-	0x1d, 0x50, 0x1a, 0xc8, 0xe2, 0x54, 0xc1, 0x39, 0x3b, 0xa8, 0x09, 0xc0, 0x92, 0x7e, 0x48, 0xf8,
-	0xa1, 0xff, 0x1b, 0x22, 0x2b, 0x50, 0x1d, 0x67, 0x56, 0x16, 0x3e, 0x7d, 0xea, 0x8b, 0x9f, 0x3e,
-	0x6b, 0x63, 0x58, 0x3f, 0xcb, 0x1d, 0x39, 0x49, 0xe5, 0x4e, 0x36, 0xa9, 0x54, 0x6f, 0xbe, 0x9b,
-	0xe7, 0x81, 0x7c, 0x91, 0x99, 0x04, 0x94, 0x1b, 0x48, 0x7f, 0x31, 0xa0, 0x78, 0x48, 0xdc, 0x98,
-	0xf0, 0xd7, 0x1a, 0x47, 0xdb, 0x27, 0xe2, 0xa8, 0x99, 0xff, 0xa5, 0x23, 0x4e, 0x5d, 0x08, 0xa3,
-	0x35, 0x28, 0xfb, 0x21, 0x27, 0x71, 0xe8, 0x04, 0x32, 0x8e, 0xca, 0x78, 0x36, 0xcf, 0x35, 0xe0,
-	0x8f, 0x06, 0x14, 0x55, 0x93, 0x7d, 0xd9, 0x06, 0xa8, 0x53, 0x5f, 0x36, 0x20, 0x57, 0xc9, 0x7f,
-	0x1b, 0x50, 0x4e, 0x6b, 0xfd, 0x6b, 0x55, 0xf3, 0xa5, 0xa6, 0x73, 0xf9, 0xbf, 0x6e, 0x3a, 0x11,
-	0x98, 0x43, 0x3f, 0xd4, 0xed, 0x31, 0x96, 0x63, 0xd4, 0x86, 0x52, 0xe4, 0x4c, 0x02, 0xea, 0x78,
-	0x3a, 0xc3, 0xaf, 0x2c, 0xfc, 0xd3, 0xd4, 0x09, 0x27, 0x38, 0x05, 0xed, 0xac, 0x3c, 0x79, 0xda,
-	0xba, 0x0a, 0x8d, 0xac, 0xe5, 0x8f, 0x8c, 0xd6, 0x3f, 0x0c, 0xa8, 0xec, 0xff, 0x9a, 0x93, 0x50,
-	0x36, 0xe3, 0xff, 0x97, 0xc6, 0x6f, 0x2e, 0xfe, 0x1b, 0x55, 0x39, 0xf1, 0x47, 0x53, 0xee, 0xa5,
-	0xfe, 0xb3, 0x00, 0x45, 0xd5, 0x4e, 0x5d, 0xf6, 0xcb, 0x53, 0xa7, 0x2e, 0x84, 0xce, 0x7d, 0x68,
-	0x44, 0x49, 0x3f, 0xf0, 0xd9, 0xa3, 0xf4, 0x9b, 0x5a, 0x35, 0x46, 0x3f, 0x3c, 0x5d, 0xc6, 0x81,
-	0xc2, 0xa7, 0xff, 0x6a, 0x45, 0xd9, 0x29, 0xba, 0x0d, 0x55, 0xd5, 0x1c, 0xda, 0x7e, 0x78, 0x44,
-	0xcf, 0xfa, 0x8b, 0x4d, 0x09, 0xeb, 0x85, 0x47, 0x14, 0xc3, 0x78, 0x36, 0xfe, 0x1f, 0x0a, 0x7c,
-	0xf7, 0xed, 0x67, 0xcf, 0x9b, 0x4b, 0xdf, 0x3c, 0x6f, 0x2e, 0xfd, 0x76, 0xda, 0x34, 0x9e, 0x4d,
-	0x9b, 0xc6, 0xd7, 0xd3, 0xa6, 0xf1, 0xaf, 0x69, 0xd3, 0xf8, 0xfd, 0x8b, 0xe6, 0xd2, 0xd7, 0x2f,
-	0x9a, 0x4b, 0xdf, 0xbc, 0x68, 0x2e, 0xf5, 0x8b, 0xf2, 0x21, 0xfe, 0xf8, 0x3f, 0x01, 0x00, 0x00,
-	0xff, 0xff, 0xb2, 0x67, 0x0d, 0x00, 0xbd, 0x16, 0x00, 0x00,
+	// 1805 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x6f, 0x1b, 0xc7,
+	0x15, 0xd7, 0x52, 0x2b, 0x7e, 0x3c, 0x7e, 0x54, 0x99, 0xa8, 0xea, 0x5a, 0x55, 0x29, 0x95, 0x49,
+	0x5a, 0xc3, 0x30, 0xa8, 0xd4, 0x4d, 0x5b, 0x59, 0x4d, 0x62, 0x93, 0x92, 0xea, 0xb0, 0x89, 0x6d,
+	0x61, 0x94, 0x38, 0xb9, 0x6d, 0x97, 0xbb, 0x23, 0x7a, 0xcd, 0xe5, 0xce, 0x62, 0x67, 0xc8, 0x84,
+	0x3d, 0xf5, 0x6c, 0xa0, 0x40, 0x6f, 0xbe, 0xf5, 0x50, 0xf4, 0x9f, 0xe8, 0xa5, 0x87, 0x1e, 0x0a,
+	0x1f, 0x73, 0x2a, 0x8c, 0x1e, 0x84, 0x9a, 0xfe, 0x1b, 0x7a, 0xe8, 0xad, 0x98, 0x8f, 0x25, 0x57,
+	0xe6, 0xea, 0xab, 0x30, 0x84, 0x9e, 0xb8, 0x33, 0xf3, 0xfb, 0xbd, 0x79, 0xef, 0xcd, 0xbc, 0x8f,
+	0x21, 0xdc, 0xec, 0xf9, 0xfc, 0xf1, 0xb0, 0xdb, 0x74, 0xe9, 0x60, 0xcb, 0xa3, 0x6e, 0x9f, 0xc4,
+	0x5b, 0xec, 0x6b, 0x27, 0x1e, 0xf4, 0x7d, 0xbe, 0xe5, 0x44, 0xfe, 0x16, 0xed, 0x3e, 0x21, 0x2e,
+	0x67, 0xcd, 0x28, 0xa6, 0x9c, 0x22, 0xa4, 0x20, 0xcd, 0x04, 0xd2, 0x1c, 0xfd, 0x64, 0xed, 0xc6,
+	0x39, 0x12, 0xf8, 0x38, 0x22, 0x9a, 0x7f, 0x2e, 0x96, 0x45, 0xc4, 0x4d, 0xb0, 0x1b, 0x3d, 0x4a,
+	0x7b, 0x01, 0xd9, 0x92, 0xa3, 0xee, 0xf0, 0x68, 0x8b, 0xfb, 0x03, 0xc2, 0xb8, 0x33, 0x88, 0x34,
+	0x60, 0xa5, 0x47, 0x7b, 0x54, 0x7e, 0x6e, 0x89, 0x2f, 0x3d, 0x7b, 0xed, 0x75, 0x9a, 0x13, 0x8e,
+	0xf5, 0xd2, 0x2f, 0xce, 0xd8, 0x7d, 0x0a, 0x8f, 0x82, 0x61, 0xcf, 0x0f, 0xf5, 0x8f, 0x22, 0x36,
+	0xfe, 0x62, 0x80, 0x79, 0x9f, 0x70, 0x07, 0xfd, 0x12, 0x0a, 0x23, 0x12, 0x33, 0x9f, 0x86, 0x96,
+	0xb1, 0x69, 0x5c, 0x2f, 0xdf, 0xfa, 0x7e, 0x73, 0xde, 0x23, 0xcd, 0x47, 0x0a, 0xd2, 0x36, 0x9f,
+	0x1f, 0x6f, 0x2c, 0xe0, 0x84, 0x81, 0x6e, 0x03, 0xb8, 0x31, 0x71, 0x38, 0xf1, 0x6c, 0x87, 0x5b,
+	0x39, 0xc9, 0x5f, 0x6b, 0x2a, 0x75, 0x9b, 0xc9, 0xfe, 0xcd, 0xcf, 0x13, 0x2b, 0x71, 0x49, 0xa3,
+	0x5b, 0x5c, 0x50, 0x87, 0x91, 0x97, 0x50, 0x17, 0xcf, 0xa7, 0x6a, 0x74, 0x8b, 0x37, 0xfe, 0xbc,
+	0x04, 0xe6, 0x03, 0xea, 0x11, 0xb4, 0x0a, 0x39, 0xdf, 0x93, 0x6a, 0x97, 0xda, 0xf9, 0xc9, 0xf1,
+	0x46, 0xae, 0xb3, 0x87, 0x73, 0xbe, 0x87, 0x6e, 0x81, 0x39, 0x20, 0xdc, 0xd1, 0x0a, 0x59, 0x59,
+	0x06, 0x09, 0xdb, 0xb5, 0x35, 0x12, 0x8b, 0x7e, 0x0e, 0xa6, 0x38, 0x2a, 0xad, 0xc9, 0x7a, 0x16,
+	0x47, 0xec, 0x79, 0x18, 0x11, 0x37, 0xe1, 0x09, 0x3c, 0xda, 0x87, 0xb2, 0x47, 0x98, 0x1b, 0xfb,
+	0x11, 0x17, 0x3e, 0x34, 0x25, 0xfd, 0x9d, 0xd3, 0xe8, 0x7b, 0x33, 0x28, 0x4e, 0xf3, 0xd0, 0x87,
+	0x90, 0x67, 0xdc, 0xe1, 0x43, 0x66, 0x2d, 0x49, 0x09, 0xf5, 0x53, 0x15, 0x90, 0x28, 0xad, 0x82,
+	0xe6, 0xa0, 0x4f, 0xa0, 0x36, 0x70, 0x42, 0xa7, 0x47, 0x62, 0x5b, 0x4b, 0xc9, 0x4b, 0x29, 0x3f,
+	0xcc, 0x34, 0x5d, 0x21, 0x95, 0x20, 0x5c, 0x1d, 0xa4, 0x87, 0xa8, 0x03, 0xe0, 0x70, 0xee, 0xb8,
+	0x8f, 0x07, 0x24, 0xe4, 0x56, 0x41, 0x4a, 0x79, 0x2f, 0x53, 0x17, 0xc2, 0xbf, 0xa6, 0x71, 0xbf,
+	0x35, 0x05, 0xb7, 0x73, 0x96, 0x81, 0x53, 0x64, 0x74, 0x0f, 0xca, 0x2e, 0x89, 0xb9, 0x7f, 0xe4,
+	0xbb, 0x0e, 0x27, 0x56, 0x51, 0xca, 0xda, 0xc8, 0x92, 0xb5, 0x3b, 0x83, 0x69, 0xc3, 0xd2, 0x4c,
+	0xf4, 0x3e, 0x98, 0x31, 0x0d, 0x88, 0x55, 0xda, 0x34, 0xae, 0xd7, 0x4e, 0x3f, 0x1a, 0x4c, 0x03,
+	0x82, 0x25, 0x52, 0x6c, 0x3d, 0x53, 0x84, 0x59, 0xb0, 0xb9, 0x78, 0x61, 0x33, 0x70, 0x9a, 0x89,
+	0x1a, 0x50, 0x79, 0xf4, 0xd5, 0x67, 0xad, 0x07, 0x5f, 0xec, 0x1d, 0x1c, 0xd0, 0x98, 0x5b, 0xe5,
+	0x4d, 0xe3, 0x7a, 0x15, 0x9f, 0x98, 0xdb, 0x59, 0x7d, 0xfa, 0xac, 0x81, 0x60, 0xb9, 0x68, 0x2c,
+	0x1b, 0xf2, 0x2e, 0x1a, 0xef, 0x1b, 0x5f, 0x19, 0xbf, 0x31, 0x1a, 0x2f, 0x4d, 0x28, 0x1c, 0x92,
+	0x78, 0xe4, 0xbb, 0x6f, 0xf6, 0xa6, 0xde, 0x3e, 0x71, 0x53, 0x33, 0x1d, 0xaa, 0xb7, 0x9d, 0xbb,
+	0xac, 0x1f, 0x43, 0x45, 0xfc, 0xda, 0x49, 0xc4, 0xc3, 0xb9, 0x11, 0x8f, 0xcb, 0x82, 0xa0, 0x07,
+	0x68, 0x0f, 0xaa, 0x51, 0x4c, 0x46, 0x3e, 0x1d, 0x32, 0x5b, 0xea, 0x90, 0xbf, 0x90, 0x0e, 0xb8,
+	0x92, 0xb0, 0xc4, 0x08, 0x3d, 0x84, 0xef, 0x9e, 0x90, 0x32, 0x55, 0xa7, 0x7c, 0xbe, 0x3a, 0x6f,
+	0xa7, 0x25, 0x25, 0x6a, 0x6d, 0x43, 0x91, 0x84, 0x5e, 0x44, 0xfd, 0x90, 0xeb, 0x00, 0xcc, 0xbc,
+	0x24, 0xfb, 0x1a, 0x83, 0xa7, 0x68, 0xb4, 0x0f, 0x55, 0x95, 0x57, 0xec, 0x13, 0xd1, 0xb7, 0x99,
+	0x45, 0xff, 0x42, 0x02, 0x75, 0xd8, 0x54, 0x86, 0xa9, 0x11, 0xfa, 0x10, 0xe0, 0x09, 0xed, 0x26,
+	0x32, 0x2a, 0x52, 0xc6, 0x0f, 0xb2, 0x64, 0xfc, 0x9a, 0x76, 0xb5, 0x80, 0xd2, 0x93, 0xe4, 0x13,
+	0xbd, 0x07, 0xb5, 0x88, 0x84, 0x9e, 0x1f, 0xf6, 0x6c, 0x8f, 0x04, 0x84, 0x13, 0x19, 0x77, 0x45,
+	0x5c, 0xd5, 0xb3, 0x7b, 0x72, 0x72, 0x07, 0x3d, 0x7d, 0xd6, 0xa8, 0x41, 0x25, 0x7d, 0xcf, 0x1a,
+	0x7f, 0xcc, 0x41, 0x31, 0x31, 0x0b, 0x7d, 0xa0, 0x2f, 0x86, 0x71, 0xba, 0x0d, 0x09, 0x56, 0x9e,
+	0x8a, 0xba, 0x13, 0x1f, 0xc0, 0x52, 0x44, 0x63, 0xce, 0xac, 0x9c, 0x8c, 0x92, 0xcc, 0xc4, 0x23,
+	0xee, 0xf9, 0x2e, 0x0d, 0x8f, 0xfc, 0x1e, 0x56, 0x60, 0xf4, 0x25, 0x94, 0x47, 0x7e, 0xcc, 0x87,
+	0x4e, 0x60, 0xfb, 0x11, 0xb3, 0x16, 0x25, 0xf7, 0x47, 0x67, 0x6d, 0xd9, 0x7c, 0xa4, 0xf0, 0x9d,
+	0x83, 0x76, 0x6d, 0x72, 0xbc, 0x01, 0xd3, 0x21, 0xc3, 0xa0, 0x45, 0x75, 0x22, 0xb6, 0x76, 0x1f,
+	0x4a, 0xd3, 0x15, 0x74, 0x13, 0x20, 0x54, 0x01, 0x6a, 0x4f, 0xc3, 0xa7, 0x3a, 0x39, 0xde, 0x28,
+	0xe9, 0xb0, 0xed, 0xec, 0xe1, 0x92, 0x06, 0x74, 0x3c, 0x84, 0xc0, 0x74, 0x3c, 0x2f, 0x96, 0xc1,
+	0x54, 0xc2, 0xf2, 0xbb, 0xf1, 0xfb, 0x22, 0x98, 0x9f, 0x3b, 0xac, 0x7f, 0xd5, 0xb5, 0x42, 0xec,
+	0x79, 0x6e, 0xf8, 0xd5, 0x2e, 0x19, 0x7e, 0x37, 0x01, 0x98, 0x8a, 0x2a, 0xe1, 0x0e, 0x73, 0xe6,
+	0x0e, 0x1d, 0x6b, 0xc2, 0x1d, 0x1a, 0xa0, 0xdc, 0xc1, 0x02, 0xca, 0xe5, 0x95, 0x36, 0xb1, 0xfc,
+	0x46, 0xef, 0x40, 0x21, 0xa4, 0x9e, 0xa4, 0xe7, 0x25, 0x1d, 0x26, 0xc7, 0x1b, 0x79, 0x91, 0x3d,
+	0x3b, 0x7b, 0x38, 0x2f, 0x96, 0x3a, 0x9e, 0xcc, 0x9e, 0x61, 0x48, 0xb9, 0x23, 0x2a, 0x13, 0xd3,
+	0x45, 0x20, 0x33, 0xc6, 0x5b, 0x33, 0x58, 0x92, 0xb8, 0x53, 0x4c, 0xf4, 0x08, 0xde, 0x4e, 0xf4,
+	0x4d, 0x0b, 0x2c, 0x5e, 0x46, 0x20, 0xd2, 0x12, 0x52, 0x2b, 0xa9, 0x62, 0x59, 0x3a, 0xbd, 0x58,
+	0xca, 0x13, 0xc8, 0x2a, 0x96, 0x6d, 0xa8, 0x7a, 0x84, 0xf9, 0x31, 0xf1, 0x64, 0xc0, 0x12, 0x99,
+	0x05, 0x6b, 0xd9, 0xf1, 0x9a, 0x08, 0x21, 0xb8, 0xa2, 0x39, 0x72, 0x84, 0x5a, 0x50, 0xd4, 0xf7,
+	0x8e, 0x59, 0xe5, 0xcb, 0x54, 0x97, 0x29, 0xed, 0x44, 0xd2, 0xaa, 0x5c, 0x2a, 0x69, 0xdd, 0x06,
+	0x08, 0x68, 0xcf, 0xf6, 0x62, 0x7f, 0x44, 0x62, 0xab, 0xaa, 0x5b, 0xa7, 0x0c, 0xee, 0x9e, 0x44,
+	0xe0, 0x52, 0x40, 0x7b, 0xea, 0x13, 0x39, 0xb0, 0xe6, 0x30, 0xe6, 0xf7, 0x42, 0xe2, 0xd9, 0x3d,
+	0x12, 0x92, 0xd8, 0x77, 0xed, 0x98, 0x30, 0x3a, 0x8c, 0x5d, 0xc2, 0xac, 0xef, 0x48, 0x4b, 0x32,
+	0x9b, 0x97, 0x7b, 0x0a, 0x8c, 0x35, 0x16, 0x5b, 0x89, 0x98, 0xd7, 0x16, 0x18, 0xba, 0x0b, 0x55,
+	0x91, 0x0b, 0x7d, 0x4e, 0x62, 0x79, 0x5c, 0xd6, 0xf2, 0xf9, 0xb7, 0xbc, 0xf2, 0x84, 0x76, 0x3b,
+	0x09, 0x01, 0x7d, 0x0c, 0x85, 0x11, 0x0d, 0x86, 0x03, 0xc2, 0xac, 0xb7, 0xa4, 0x46, 0xef, 0x66,
+	0x72, 0x25, 0x24, 0xe5, 0xda, 0x84, 0xb4, 0xb3, 0xf6, 0xf4, 0x59, 0x63, 0x15, 0x56, 0xd2, 0x89,
+	0x72, 0xdb, 0xb8, 0x6b, 0x7c, 0x62, 0x1c, 0x18, 0x8d, 0xbf, 0xe5, 0xe0, 0xad, 0xb9, 0x53, 0x41,
+	0x3f, 0x83, 0x82, 0x3e, 0x97, 0xb3, 0x9a, 0x60, 0xcd, 0xc3, 0x09, 0x16, 0xad, 0x43, 0x49, 0x24,
+	0x19, 0xc2, 0x18, 0x51, 0xe9, 0xb3, 0x84, 0x67, 0x13, 0xc8, 0x82, 0x82, 0x13, 0xf8, 0x8e, 0x58,
+	0x5b, 0x94, 0x6b, 0xc9, 0x10, 0x0d, 0x61, 0x55, 0x1d, 0x9e, 0x3d, 0xeb, 0x35, 0x6c, 0x1a, 0x71,
+	0x66, 0x99, 0xd2, 0xde, 0x3b, 0x17, 0xba, 0x4b, 0xfa, 0x78, 0x67, 0x13, 0x0f, 0x23, 0xce, 0xf6,
+	0x43, 0x1e, 0x8f, 0xf1, 0x8a, 0x97, 0xb1, 0xb4, 0x76, 0x0f, 0xae, 0x9d, 0x4a, 0x41, 0xcb, 0xb0,
+	0xd8, 0x27, 0x63, 0x95, 0x20, 0xb1, 0xf8, 0x44, 0x2b, 0xb0, 0x34, 0x72, 0x82, 0x21, 0xd1, 0xf9,
+	0x54, 0x0d, 0x76, 0x72, 0xdb, 0x46, 0xe3, 0xdf, 0x39, 0x28, 0x68, 0x75, 0xae, 0xba, 0xb3, 0xd1,
+	0xdb, 0xce, 0xa5, 0xd6, 0x8f, 0xa0, 0xa2, 0x5d, 0xaa, 0x62, 0xda, 0x3c, 0x37, 0x2a, 0xca, 0x0a,
+	0xaf, 0xe2, 0xf9, 0x23, 0x30, 0xfd, 0xc8, 0x19, 0xe8, 0xf2, 0x9f, 0xb9, 0x73, 0xe7, 0xa0, 0x75,
+	0xff, 0x61, 0xa4, 0x52, 0x53, 0x71, 0x72, 0xbc, 0x61, 0x8a, 0x09, 0x2c, 0x69, 0x19, 0x15, 0x3c,
+	0x9f, 0x51, 0xc1, 0xd1, 0x0d, 0x58, 0x22, 0xdf, 0xf0, 0xd8, 0xd1, 0x29, 0x75, 0x65, 0xee, 0xb9,
+	0xd3, 0x0a, 0xc7, 0x58, 0x41, 0x32, 0xab, 0xfd, 0xdf, 0xf3, 0x50, 0xd8, 0x0d, 0x86, 0x8c, 0x93,
+	0xf8, 0xaa, 0xfd, 0xae, 0xb7, 0x9d, 0xf3, 0xfb, 0x2e, 0x14, 0x62, 0x4a, 0xb9, 0xed, 0x3a, 0x67,
+	0xb9, 0x1c, 0x53, 0xca, 0x77, 0x5b, 0xed, 0x9a, 0x20, 0x8a, 0x82, 0xa3, 0xc6, 0x38, 0x2f, 0xa8,
+	0xbb, 0x0e, 0xfa, 0x12, 0x56, 0x93, 0x32, 0xdf, 0xa5, 0x94, 0x33, 0x1e, 0x3b, 0x91, 0xdd, 0x27,
+	0x63, 0xd1, 0x8e, 0x2d, 0x9e, 0xf6, 0x8c, 0xd9, 0x0f, 0xdd, 0x78, 0x2c, 0xcf, 0xe3, 0x53, 0x32,
+	0xc6, 0x2b, 0x5a, 0x40, 0x3b, 0xe1, 0x7f, 0x4a, 0xc6, 0x0c, 0xdd, 0x81, 0x75, 0x32, 0x85, 0x09,
+	0x89, 0x76, 0xe0, 0x0c, 0x44, 0x03, 0x63, 0xbb, 0x01, 0x75, 0xfb, 0xf2, 0x94, 0x4c, 0x7c, 0x8d,
+	0xa4, 0x45, 0x7d, 0xa6, 0x10, 0xbb, 0x02, 0x80, 0x18, 0x58, 0xdd, 0xc0, 0x71, 0xfb, 0x81, 0xcf,
+	0xc4, 0x4b, 0x35, 0xf5, 0x2a, 0x11, 0x65, 0x4c, 0xe8, 0xb6, 0x7d, 0x86, 0xb7, 0x9a, 0xed, 0x19,
+	0x37, 0xf5, 0xc6, 0xd1, 0x41, 0xfa, 0xbd, 0x6e, 0xf6, 0x2a, 0x6a, 0x43, 0x79, 0x18, 0x8a, 0xed,
+	0x95, 0x0f, 0x4a, 0x17, 0xf5, 0x01, 0x28, 0x96, 0xb4, 0x7c, 0x1d, 0xcc, 0x23, 0xd1, 0x98, 0x89,
+	0xda, 0x56, 0x54, 0xf7, 0xf5, 0x57, 0x9d, 0x83, 0x43, 0x2c, 0x67, 0x51, 0x13, 0x90, 0x47, 0x8e,
+	0x9c, 0x61, 0xc0, 0x5b, 0x2a, 0x5d, 0x1d, 0x50, 0x1a, 0xc8, 0x42, 0x56, 0xc2, 0x19, 0x2b, 0xa8,
+	0x0e, 0xc0, 0x86, 0xdd, 0x90, 0xf0, 0x43, 0xff, 0xb7, 0x44, 0x56, 0xab, 0x2a, 0x4e, 0xcd, 0xcc,
+	0x3d, 0x93, 0xaa, 0xf3, 0xcf, 0xa4, 0xb5, 0x11, 0xac, 0x9f, 0xe5, 0x8e, 0x8c, 0x04, 0x74, 0x37,
+	0x9d, 0x80, 0xca, 0xb7, 0x6e, 0x64, 0x79, 0x20, 0x5b, 0x64, 0x2a, 0x59, 0x65, 0x06, 0xd2, 0x5f,
+	0x0d, 0xc8, 0x1f, 0x12, 0x37, 0x26, 0xfc, 0x8d, 0xc6, 0xd1, 0xf6, 0x89, 0x38, 0xaa, 0x67, 0xbf,
+	0x8a, 0xc4, 0xae, 0x73, 0x61, 0xb4, 0x06, 0x45, 0x3f, 0xe4, 0x24, 0x0e, 0x9d, 0x40, 0xc6, 0x51,
+	0x11, 0x4f, 0xc7, 0x99, 0x06, 0xfc, 0xc9, 0x80, 0xbc, 0x6a, 0xc8, 0xaf, 0xda, 0x00, 0xb5, 0xeb,
+	0xeb, 0x06, 0x64, 0x2a, 0xf9, 0x1f, 0x03, 0x8a, 0x49, 0x5f, 0xf0, 0x46, 0xd5, 0x7c, 0xad, 0x41,
+	0x5d, 0xfc, 0x9f, 0x1b, 0x54, 0x04, 0x66, 0xdf, 0x0f, 0x75, 0x2b, 0x8d, 0xe5, 0x37, 0x6a, 0x42,
+	0x21, 0x72, 0xc6, 0x01, 0x75, 0x3c, 0x5d, 0x0d, 0xb2, 0xd3, 0x74, 0x02, 0xda, 0x59, 0x79, 0xfa,
+	0xac, 0xb1, 0x0c, 0xb5, 0xb4, 0xe5, 0x8f, 0x8d, 0xc6, 0x3f, 0x0c, 0x28, 0xed, 0x7f, 0xc3, 0x49,
+	0x28, 0x1b, 0xf7, 0xff, 0x4b, 0xe3, 0x37, 0xe7, 0xff, 0xb9, 0x2a, 0x9d, 0xf8, 0x53, 0x2a, 0xf3,
+	0x50, 0xff, 0x99, 0x83, 0xbc, 0x6a, 0xbd, 0xae, 0xfa, 0xe6, 0xa9, 0x5d, 0xe7, 0x42, 0xe7, 0x01,
+	0xd4, 0xa2, 0x61, 0x37, 0xf0, 0xd9, 0xe3, 0xe4, 0xfd, 0xad, 0x9a, 0xa8, 0x1f, 0x9f, 0x2e, 0xe3,
+	0x40, 0xe1, 0x93, 0x7f, 0xc0, 0xa2, 0xf4, 0x10, 0xdd, 0x81, 0xb2, 0x6a, 0x24, 0x6d, 0x3f, 0x3c,
+	0xa2, 0x67, 0xfd, 0x1d, 0xa7, 0x84, 0x75, 0xc2, 0x23, 0x8a, 0x61, 0x34, 0xfd, 0xbe, 0x60, 0x33,
+	0x90, 0xe5, 0xdc, 0xf6, 0xbb, 0xcf, 0x5f, 0xd6, 0x17, 0x5e, 0xbc, 0xac, 0x2f, 0xfc, 0x6e, 0x52,
+	0x37, 0x9e, 0x4f, 0xea, 0xc6, 0xb7, 0x93, 0xba, 0xf1, 0xaf, 0x49, 0xdd, 0xf8, 0xc3, 0xab, 0xfa,
+	0xc2, 0xb7, 0xaf, 0xea, 0x0b, 0x2f, 0x5e, 0xd5, 0x17, 0xba, 0x79, 0x79, 0x11, 0x7f, 0xfa, 0xdf,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0xc8, 0xcf, 0x42, 0x61, 0xe9, 0x16, 0x00, 0x00,
 }
 
 func (m *Meta) Copy() *Meta {
@@ -1223,6 +1228,10 @@ func (m *Network) CopyFrom(src interface{}) {
 		m.IPAM = &IPAMOptions{}
 		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.IPAM, o.IPAM)
 	}
+	if o.Extra != nil {
+		m.Extra = &types.Any{}
+		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Extra, o.Extra)
+	}
 }
 
 func (m *Cluster) Copy() *Cluster {
@@ -2082,6 +2091,18 @@ func (m *Network) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Extra != nil {
+		{
+			size, err := m.Extra.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintObjects(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x3a
+	}
 	if m.PendingDelete {
 		i--
 		if m.PendingDelete {
@@ -2906,6 +2927,10 @@ func (m *Network) Size() (n int) {
 	if m.PendingDelete {
 		n += 2
 	}
+	if m.Extra != nil {
+		l = m.Extra.Size()
+		n += 1 + l + sovObjects(uint64(l))
+	}
 	return n
 }
 
@@ -6171,6 +6196,7 @@ func (this *Network) String() string {
 		`DriverState:` + strings.Replace(fmt.Sprintf("%v", this.DriverState), "Driver", "Driver", 1) + `,`,
 		`IPAM:` + strings.Replace(fmt.Sprintf("%v", this.IPAM), "IPAMOptions", "IPAMOptions", 1) + `,`,
 		`PendingDelete:` + fmt.Sprintf("%v", this.PendingDelete) + `,`,
+		`Extra:` + strings.Replace(fmt.Sprintf("%v", this.Extra), "Any", "types.Any", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -8588,6 +8614,42 @@ func (m *Network) Unmarshal(dAtA []byte) error {
 				}
 			}
 			m.PendingDelete = bool(v != 0)
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowObjects
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthObjects
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthObjects
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Extra == nil {
+				m.Extra = &types.Any{}
+			}
+			if err := m.Extra.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipObjects(dAtA[iNdEx:])

vendor/github.com/moby/swarmkit/v2/api/objects.proto

@@ -332,6 +332,11 @@ message Network {
 	// the services that still use this service, and proceed to delete
 	// this network when all of these services are gone
 	bool pending_delete = 6;
+
+	// Extra encodes application-specific information about the live state
+	// of the network. The syntax and semantics of the value are dictated by
+	// the network allocator implementation.
+	google.protobuf.Any extra = 7;
 }
 
 // Cluster provides global cluster settings.

vendor/github.com/moby/swarmkit/v2/ca/config.go

@@ -9,6 +9,7 @@ import (
 	"math/big"
 	"math/rand"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -60,6 +61,17 @@ var (
 	errInvalidJoinToken = errors.New("invalid join token")
 )
 
+// strongTLSCiphers defines a secure, modern set of TLS cipher suites
+// with known weak algorithms removed.
+var strongTLSCiphers = []uint16{
+	tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+	tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+	tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+	tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+}
+
 // SecurityConfig is used to represent a node's security configuration. It includes information about
 // the RootCA and ServerTLSCreds/ClientTLSCreds transport authenticators to be used for MTLS
 type SecurityConfig struct {
@@ -649,6 +661,7 @@ func NewServerTLSConfig(certs []tls.Certificate, rootCAPool *x509.CertPool) (*tl
 		RootCAs:                  rootCAPool,
 		ClientCAs:                rootCAPool,
 		PreferServerCipherSuites: true,
+		CipherSuites:             slices.Clone(strongTLSCiphers),
 		MinVersion:               tls.VersionTLS12,
 		NextProtos:               alpnProtoStr,
 	}, nil
@@ -665,6 +678,7 @@ func NewClientTLSConfig(certs []tls.Certificate, rootCAPool *x509.CertPool, serv
 		ServerName:   serverName,
 		Certificates: certs,
 		RootCAs:      rootCAPool,
+		CipherSuites: slices.Clone(strongTLSCiphers),
 		MinVersion:   tls.VersionTLS12,
 	}, nil
 }

vendor/github.com/moby/swarmkit/v2/manager/allocator/network.go

@@ -1524,6 +1524,10 @@ func (a *Allocator) procTasksNetwork(ctx context.Context, onRetry bool) {
 	}
 }
 
+func (a *Allocator) NetworkAllocator() networkallocator.NetworkAllocator {
+	return a.nwkAllocator
+}
+
 // updateTaskStatus sets TaskStatus and updates timestamp.
 func updateTaskStatus(t *api.Task, newStatus api.TaskState, message string) {
 	t.Status = api.TaskStatus{

vendor/github.com/moby/swarmkit/v2/manager/allocator/networkallocator/networkallocator.go

@@ -1,6 +1,8 @@
 package networkallocator
 
 import (
+	"context"
+
 	"github.com/moby/swarmkit/v2/api"
 )
 
@@ -87,6 +89,27 @@ type NetworkAllocator interface {
 	IsAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool
 }
 
+// OnGetNetworker is an optional interface that [NetworkAllocator] may implement
+// to customize the Control API response for GetNetwork and ListNetworks requests.
+type OnGetNetworker interface {
+	// OnGetNetwork is called with a copy of the network object that will be
+	// returned in a GetNetwork or ListNetworks Control API response. Any
+	// modifications to the network object will be reflected in the
+	// response. The modified network object will not be persisted to the
+	// store. Errors returned will be bubbled up to the Control API client.
+	//
+	// The appdataTypeURL and appdata parameters are set to the TypeUrl and
+	// value, respectively, of the appdata field in the ListNetworks or
+	// GetNetwork Control API request.
+	//
+	// The network may not have been allocated at the time of the call.
+	// Calling OnGetNetwork with an unallocated network should not be an
+	// error.
+	//
+	// This method may be called concurrently from multiple goroutines.
+	OnGetNetwork(ctx context.Context, network *api.Network, appdataTypeURL string, appdata []byte) error
+}
+
 // Config is used to store network related cluster config in the Manager.
 type Config struct {
 	// DefaultAddrPool specifies default subnet pool for global scope networks

vendor/github.com/moby/swarmkit/v2/manager/apihooks.go

@@ -0,0 +1,35 @@
+package manager
+
+import (
+	"context"
+
+	"github.com/moby/swarmkit/v2/api"
+	"github.com/moby/swarmkit/v2/manager/allocator/networkallocator"
+)
+
+func (m *Manager) networkAllocator() networkallocator.NetworkAllocator {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.allocator == nil {
+		return nil
+	}
+	return m.allocator.NetworkAllocator()
+}
+
+func (m *Manager) OnGetNetwork(ctx context.Context, n *api.Network, appdataTypeURL string, appdata []byte) error {
+	if nwh, ok := m.networkAllocator().(networkallocator.OnGetNetworker); ok {
+		return nwh.OnGetNetwork(ctx, n, appdataTypeURL, appdata)
+	}
+	return nil
+}
+
+func (m *Manager) OnListNetworks(ctx context.Context, networks []*api.Network, appdataTypeURL string, appdata []byte) error {
+	if nwh, ok := m.networkAllocator().(networkallocator.OnGetNetworker); ok {
+		for _, n := range networks {
+			if err := nwh.OnGetNetwork(ctx, n, appdataTypeURL, appdata); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

vendor/github.com/moby/swarmkit/v2/manager/controlapi/apihooks.go

@@ -0,0 +1,32 @@
+package controlapi
+
+import (
+	"context"
+
+	"github.com/moby/swarmkit/v2/api"
+)
+
+// NetworkViewResponseMutator provides callbacks which may modify the response
+// objects for GetNetwork and ListNetworks Control API requests before they are
+// sent to the client.
+type NetworkViewResponseMutator interface {
+	OnGetNetwork(context.Context, *api.Network, string, []byte) error
+	OnListNetworks(context.Context, []*api.Network, string, []byte) error
+}
+
+type NoopViewResponseMutator struct{}
+
+func (NoopViewResponseMutator) OnGetNetwork(ctx context.Context, n *api.Network, appdataTypeURL string, appdata []byte) error {
+	return nil
+}
+
+func (NoopViewResponseMutator) OnListNetworks(ctx context.Context, networks []*api.Network, appdataTypeURL string, appdata []byte) error {
+	return nil
+}
+
+func (s *Server) networkhooks() NetworkViewResponseMutator {
+	if s.NetworkHooks != nil {
+		return s.NetworkHooks
+	}
+	return NoopViewResponseMutator{}
+}

vendor/github.com/moby/swarmkit/v2/manager/controlapi/network.go

@@ -148,6 +148,9 @@ func (s *Server) GetNetwork(ctx context.Context, request *api.GetNetworkRequest)
 	if n == nil {
 		return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
 	}
+	if err := s.networkhooks().OnGetNetwork(ctx, n, request.Appdata.GetTypeUrl(), request.Appdata.GetValue()); err != nil {
+		return nil, err
+	}
 	return &api.GetNetworkResponse{
 		Network: n,
 	}, nil
@@ -292,6 +295,10 @@ func (s *Server) ListNetworks(ctx context.Context, request *api.ListNetworksRequ
 		)
 	}
 
+	if err := s.networkhooks().OnListNetworks(ctx, networks, request.Appdata.GetTypeUrl(), request.Appdata.GetValue()); err != nil {
+		return nil, err
+	}
+
 	return &api.ListNetworksResponse{
 		Networks: networks,
 	}, nil

vendor/github.com/moby/swarmkit/v2/manager/controlapi/server.go

@@ -21,6 +21,10 @@ type Server struct {
 	securityConfig *ca.SecurityConfig
 	netvalidator   networkallocator.DriverValidator
 	dr             *drivers.DriverProvider
+
+	// NetworkHooks intercept and mutate API server responses for GetNetwork
+	// and ListNetworks API requests when set.
+	NetworkHooks NetworkViewResponseMutator
 }
 
 // NewServer creates a Cluster API server.

vendor/github.com/moby/swarmkit/v2/manager/manager.go

@@ -473,6 +473,7 @@ func (m *Manager) Run(parent context.Context) error {
 	}
 
 	baseControlAPI := controlapi.NewServer(m.raftNode.MemoryStore(), m.raftNode, m.config.SecurityConfig, m.config.networkProvider(), drivers.New(m.config.PluginGetter))
+	baseControlAPI.NetworkHooks = m
 	baseResourceAPI := resourceapi.New(m.raftNode.MemoryStore())
 	healthServer := health.NewHealthServer()
 	localHealthServer := health.NewHealthServer()

vendor/modules.txt

@@ -869,7 +869,7 @@ github.com/moby/patternmatcher/ignorefile
 # github.com/moby/pubsub v1.0.0
 ## explicit; go 1.19
 github.com/moby/pubsub
-# github.com/moby/swarmkit/v2 v2.0.0
+# github.com/moby/swarmkit/v2 v2.1.1
 ## explicit; go 1.18
 github.com/moby/swarmkit/v2/agent
 github.com/moby/swarmkit/v2/agent/configs