diff --git a/go.mod b/go.mod
index 8064d18a..e85a5e17 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/Masterminds/semver/v3 v3.2.1
 	github.com/Microsoft/go-winio v0.6.2
 	github.com/aws/aws-sdk-go-v2/config v1.26.6
-	github.com/compose-spec/compose-go/v2 v2.1.2
+	github.com/compose-spec/compose-go/v2 v2.1.3
 	github.com/containerd/console v1.0.4
 	github.com/containerd/containerd v1.7.18
 	github.com/containerd/continuity v0.4.3
@@ -117,10 +117,8 @@ require (
 	github.com/mattn/go-shellwords v1.0.12 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect
-	github.com/mitchellh/copystructure v1.2.0 // indirect
 	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
 	github.com/moby/locker v1.0.1 // indirect
 	github.com/moby/patternmatcher v0.6.0 // indirect
diff --git a/go.sum b/go.sum
index cd3a67b9..20856b50 100644
--- a/go.sum
+++ b/go.sum
@@ -84,8 +84,8 @@ github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4 h1:/inchEIKaYC1Akx+H+g
 github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb h1:EDmT6Q9Zs+SbUoc7Ik9EfrFqcylYqgPZ9ANSbTAntnE=
 github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb/go.mod h1:ZjrT6AXHbDs86ZSdt/osfBi5qfexBrKUdONk989Wnk4=
-github.com/compose-spec/compose-go/v2 v2.1.2 h1:N2XmNYg5jHNBaU+4/zSAe2UrZLq7Kkp1eSsOHfAHbxQ=
-github.com/compose-spec/compose-go/v2 v2.1.2/go.mod h1:NJGRGazJfh0tD7d13h66KDVvyOHK49Wil2CIhoffiD0=
+github.com/compose-spec/compose-go/v2 v2.1.3 h1:bD67uqLuL/XgkAK6ir3xZvNLFPxPScEi1KW7R5esrLE=
+github.com/compose-spec/compose-go/v2 v2.1.3/go.mod h1:lFN0DrMxIncJGYAXTfWuajfwj5haBJqrBkarHcnjJKc=
 github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
 github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
 github.com/containerd/console v1.0.4 h1:F2g4+oChYvBTsASRTz8NP6iIAi97J3TtSAsLbIFn4ro=
@@ -292,16 +292,12 @@ github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfr
 github.com/miekg/pkcs11 v1.0.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
 github.com/miekg/pkcs11 v1.1.1 h1:Ugu9pdy6vAYku5DEpVWVFPYnzV+bxB+iRdbuFSu7TvU=
 github.com/miekg/pkcs11 v1.1.1/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
-github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
-github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/mitchellh/mapstructure v0.0.0-20150613213606-2caf8efc9366/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
-github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/moby/buildkit v0.14.1 h1:2epLCZTkn4CikdImtsLtIa++7DzCimrrZCT1sway+oI=
 github.com/moby/buildkit v0.14.1/go.mod h1:1XssG7cAqv5Bz1xcGMxJL123iCv5TYN4Z/qf647gfuk=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
diff --git a/vendor/github.com/compose-spec/compose-go/v2/types/config.go b/vendor/github.com/compose-spec/compose-go/v2/types/config.go
index 5777dcd5..a2382fb3 100644
--- a/vendor/github.com/compose-spec/compose-go/v2/types/config.go
+++ b/vendor/github.com/compose-spec/compose-go/v2/types/config.go
@@ -100,7 +100,13 @@ type Secrets map[string]SecretConfig
 type Configs map[string]ConfigObjConfig
 
 // Extensions is a map of custom extension
-type Extensions map[string]interface{}
+type Extensions map[string]any
+
+func (e Extensions) DeepCopy(t Extensions) {
+	for k, v := range e {
+		t[k] = v
+	}
+}
 
 // MarshalJSON makes Config implement json.Marshaler
 func (c Config) MarshalJSON() ([]byte, error) {
diff --git a/vendor/github.com/compose-spec/compose-go/v2/types/derived.gen.go b/vendor/github.com/compose-spec/compose-go/v2/types/derived.gen.go
new file mode 100644
index 00000000..6c50028a
--- /dev/null
+++ b/vendor/github.com/compose-spec/compose-go/v2/types/derived.gen.go
@@ -0,0 +1,2067 @@
+// Code generated by goderive DO NOT EDIT.
+
+package types
+
+// deriveDeepCopyProject recursively copies the contents of src into dst.
+func deriveDeepCopyProject(dst, src *Project) {
+	dst.Name = src.Name
+	dst.WorkingDir = src.WorkingDir
+	if src.Services != nil {
+		dst.Services = make(map[string]ServiceConfig, len(src.Services))
+		deriveDeepCopy(dst.Services, src.Services)
+	} else {
+		dst.Services = nil
+	}
+	if src.Networks != nil {
+		dst.Networks = make(map[string]NetworkConfig, len(src.Networks))
+		deriveDeepCopy_(dst.Networks, src.Networks)
+	} else {
+		dst.Networks = nil
+	}
+	if src.Volumes != nil {
+		dst.Volumes = make(map[string]VolumeConfig, len(src.Volumes))
+		deriveDeepCopy_1(dst.Volumes, src.Volumes)
+	} else {
+		dst.Volumes = nil
+	}
+	if src.Secrets != nil {
+		dst.Secrets = make(map[string]SecretConfig, len(src.Secrets))
+		deriveDeepCopy_2(dst.Secrets, src.Secrets)
+	} else {
+		dst.Secrets = nil
+	}
+	if src.Configs != nil {
+		dst.Configs = make(map[string]ConfigObjConfig, len(src.Configs))
+		deriveDeepCopy_3(dst.Configs, src.Configs)
+	} else {
+		dst.Configs = nil
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+	if src.ComposeFiles == nil {
+		dst.ComposeFiles = nil
+	} else {
+		if dst.ComposeFiles != nil {
+			if len(src.ComposeFiles) > len(dst.ComposeFiles) {
+				if cap(dst.ComposeFiles) >= len(src.ComposeFiles) {
+					dst.ComposeFiles = (dst.ComposeFiles)[:len(src.ComposeFiles)]
+				} else {
+					dst.ComposeFiles = make([]string, len(src.ComposeFiles))
+				}
+			} else if len(src.ComposeFiles) < len(dst.ComposeFiles) {
+				dst.ComposeFiles = (dst.ComposeFiles)[:len(src.ComposeFiles)]
+			}
+		} else {
+			dst.ComposeFiles = make([]string, len(src.ComposeFiles))
+		}
+		copy(dst.ComposeFiles, src.ComposeFiles)
+	}
+	if src.Environment != nil {
+		dst.Environment = make(map[string]string, len(src.Environment))
+		deriveDeepCopy_4(dst.Environment, src.Environment)
+	} else {
+		dst.Environment = nil
+	}
+	if src.DisabledServices != nil {
+		dst.DisabledServices = make(map[string]ServiceConfig, len(src.DisabledServices))
+		deriveDeepCopy(dst.DisabledServices, src.DisabledServices)
+	} else {
+		dst.DisabledServices = nil
+	}
+	if src.Profiles == nil {
+		dst.Profiles = nil
+	} else {
+		if dst.Profiles != nil {
+			if len(src.Profiles) > len(dst.Profiles) {
+				if cap(dst.Profiles) >= len(src.Profiles) {
+					dst.Profiles = (dst.Profiles)[:len(src.Profiles)]
+				} else {
+					dst.Profiles = make([]string, len(src.Profiles))
+				}
+			} else if len(src.Profiles) < len(dst.Profiles) {
+				dst.Profiles = (dst.Profiles)[:len(src.Profiles)]
+			}
+		} else {
+			dst.Profiles = make([]string, len(src.Profiles))
+		}
+		copy(dst.Profiles, src.Profiles)
+	}
+}
+
+// deriveDeepCopyService recursively copies the contents of src into dst.
+func deriveDeepCopyService(dst, src *ServiceConfig) {
+	dst.Name = src.Name
+	if src.Profiles == nil {
+		dst.Profiles = nil
+	} else {
+		if dst.Profiles != nil {
+			if len(src.Profiles) > len(dst.Profiles) {
+				if cap(dst.Profiles) >= len(src.Profiles) {
+					dst.Profiles = (dst.Profiles)[:len(src.Profiles)]
+				} else {
+					dst.Profiles = make([]string, len(src.Profiles))
+				}
+			} else if len(src.Profiles) < len(dst.Profiles) {
+				dst.Profiles = (dst.Profiles)[:len(src.Profiles)]
+			}
+		} else {
+			dst.Profiles = make([]string, len(src.Profiles))
+		}
+		copy(dst.Profiles, src.Profiles)
+	}
+	if src.Annotations != nil {
+		dst.Annotations = make(map[string]string, len(src.Annotations))
+		deriveDeepCopy_4(dst.Annotations, src.Annotations)
+	} else {
+		dst.Annotations = nil
+	}
+	if src.Attach == nil {
+		dst.Attach = nil
+	} else {
+		dst.Attach = new(bool)
+		*dst.Attach = *src.Attach
+	}
+	if src.Build == nil {
+		dst.Build = nil
+	} else {
+		dst.Build = new(BuildConfig)
+		deriveDeepCopy_5(dst.Build, src.Build)
+	}
+	if src.Develop == nil {
+		dst.Develop = nil
+	} else {
+		dst.Develop = new(DevelopConfig)
+		deriveDeepCopy_6(dst.Develop, src.Develop)
+	}
+	if src.BlkioConfig == nil {
+		dst.BlkioConfig = nil
+	} else {
+		dst.BlkioConfig = new(BlkioConfig)
+		deriveDeepCopy_7(dst.BlkioConfig, src.BlkioConfig)
+	}
+	if src.CapAdd == nil {
+		dst.CapAdd = nil
+	} else {
+		if dst.CapAdd != nil {
+			if len(src.CapAdd) > len(dst.CapAdd) {
+				if cap(dst.CapAdd) >= len(src.CapAdd) {
+					dst.CapAdd = (dst.CapAdd)[:len(src.CapAdd)]
+				} else {
+					dst.CapAdd = make([]string, len(src.CapAdd))
+				}
+			} else if len(src.CapAdd) < len(dst.CapAdd) {
+				dst.CapAdd = (dst.CapAdd)[:len(src.CapAdd)]
+			}
+		} else {
+			dst.CapAdd = make([]string, len(src.CapAdd))
+		}
+		copy(dst.CapAdd, src.CapAdd)
+	}
+	if src.CapDrop == nil {
+		dst.CapDrop = nil
+	} else {
+		if dst.CapDrop != nil {
+			if len(src.CapDrop) > len(dst.CapDrop) {
+				if cap(dst.CapDrop) >= len(src.CapDrop) {
+					dst.CapDrop = (dst.CapDrop)[:len(src.CapDrop)]
+				} else {
+					dst.CapDrop = make([]string, len(src.CapDrop))
+				}
+			} else if len(src.CapDrop) < len(dst.CapDrop) {
+				dst.CapDrop = (dst.CapDrop)[:len(src.CapDrop)]
+			}
+		} else {
+			dst.CapDrop = make([]string, len(src.CapDrop))
+		}
+		copy(dst.CapDrop, src.CapDrop)
+	}
+	dst.CgroupParent = src.CgroupParent
+	dst.Cgroup = src.Cgroup
+	dst.CPUCount = src.CPUCount
+	dst.CPUPercent = src.CPUPercent
+	dst.CPUPeriod = src.CPUPeriod
+	dst.CPUQuota = src.CPUQuota
+	dst.CPURTPeriod = src.CPURTPeriod
+	dst.CPURTRuntime = src.CPURTRuntime
+	dst.CPUS = src.CPUS
+	dst.CPUSet = src.CPUSet
+	dst.CPUShares = src.CPUShares
+	if src.Command == nil {
+		dst.Command = nil
+	} else {
+		if dst.Command != nil {
+			if len(src.Command) > len(dst.Command) {
+				if cap(dst.Command) >= len(src.Command) {
+					dst.Command = (dst.Command)[:len(src.Command)]
+				} else {
+					dst.Command = make([]string, len(src.Command))
+				}
+			} else if len(src.Command) < len(dst.Command) {
+				dst.Command = (dst.Command)[:len(src.Command)]
+			}
+		} else {
+			dst.Command = make([]string, len(src.Command))
+		}
+		copy(dst.Command, src.Command)
+	}
+	if src.Configs == nil {
+		dst.Configs = nil
+	} else {
+		if dst.Configs != nil {
+			if len(src.Configs) > len(dst.Configs) {
+				if cap(dst.Configs) >= len(src.Configs) {
+					dst.Configs = (dst.Configs)[:len(src.Configs)]
+				} else {
+					dst.Configs = make([]ServiceConfigObjConfig, len(src.Configs))
+				}
+			} else if len(src.Configs) < len(dst.Configs) {
+				dst.Configs = (dst.Configs)[:len(src.Configs)]
+			}
+		} else {
+			dst.Configs = make([]ServiceConfigObjConfig, len(src.Configs))
+		}
+		deriveDeepCopy_8(dst.Configs, src.Configs)
+	}
+	dst.ContainerName = src.ContainerName
+	if src.CredentialSpec == nil {
+		dst.CredentialSpec = nil
+	} else {
+		dst.CredentialSpec = new(CredentialSpecConfig)
+		deriveDeepCopy_9(dst.CredentialSpec, src.CredentialSpec)
+	}
+	if src.DependsOn != nil {
+		dst.DependsOn = make(map[string]ServiceDependency, len(src.DependsOn))
+		deriveDeepCopy_10(dst.DependsOn, src.DependsOn)
+	} else {
+		dst.DependsOn = nil
+	}
+	if src.Deploy == nil {
+		dst.Deploy = nil
+	} else {
+		dst.Deploy = new(DeployConfig)
+		deriveDeepCopy_11(dst.Deploy, src.Deploy)
+	}
+	if src.DeviceCgroupRules == nil {
+		dst.DeviceCgroupRules = nil
+	} else {
+		if dst.DeviceCgroupRules != nil {
+			if len(src.DeviceCgroupRules) > len(dst.DeviceCgroupRules) {
+				if cap(dst.DeviceCgroupRules) >= len(src.DeviceCgroupRules) {
+					dst.DeviceCgroupRules = (dst.DeviceCgroupRules)[:len(src.DeviceCgroupRules)]
+				} else {
+					dst.DeviceCgroupRules = make([]string, len(src.DeviceCgroupRules))
+				}
+			} else if len(src.DeviceCgroupRules) < len(dst.DeviceCgroupRules) {
+				dst.DeviceCgroupRules = (dst.DeviceCgroupRules)[:len(src.DeviceCgroupRules)]
+			}
+		} else {
+			dst.DeviceCgroupRules = make([]string, len(src.DeviceCgroupRules))
+		}
+		copy(dst.DeviceCgroupRules, src.DeviceCgroupRules)
+	}
+	if src.Devices == nil {
+		dst.Devices = nil
+	} else {
+		if dst.Devices != nil {
+			if len(src.Devices) > len(dst.Devices) {
+				if cap(dst.Devices) >= len(src.Devices) {
+					dst.Devices = (dst.Devices)[:len(src.Devices)]
+				} else {
+					dst.Devices = make([]string, len(src.Devices))
+				}
+			} else if len(src.Devices) < len(dst.Devices) {
+				dst.Devices = (dst.Devices)[:len(src.Devices)]
+			}
+		} else {
+			dst.Devices = make([]string, len(src.Devices))
+		}
+		copy(dst.Devices, src.Devices)
+	}
+	if src.DNS == nil {
+		dst.DNS = nil
+	} else {
+		if dst.DNS != nil {
+			if len(src.DNS) > len(dst.DNS) {
+				if cap(dst.DNS) >= len(src.DNS) {
+					dst.DNS = (dst.DNS)[:len(src.DNS)]
+				} else {
+					dst.DNS = make([]string, len(src.DNS))
+				}
+			} else if len(src.DNS) < len(dst.DNS) {
+				dst.DNS = (dst.DNS)[:len(src.DNS)]
+			}
+		} else {
+			dst.DNS = make([]string, len(src.DNS))
+		}
+		copy(dst.DNS, src.DNS)
+	}
+	if src.DNSOpts == nil {
+		dst.DNSOpts = nil
+	} else {
+		if dst.DNSOpts != nil {
+			if len(src.DNSOpts) > len(dst.DNSOpts) {
+				if cap(dst.DNSOpts) >= len(src.DNSOpts) {
+					dst.DNSOpts = (dst.DNSOpts)[:len(src.DNSOpts)]
+				} else {
+					dst.DNSOpts = make([]string, len(src.DNSOpts))
+				}
+			} else if len(src.DNSOpts) < len(dst.DNSOpts) {
+				dst.DNSOpts = (dst.DNSOpts)[:len(src.DNSOpts)]
+			}
+		} else {
+			dst.DNSOpts = make([]string, len(src.DNSOpts))
+		}
+		copy(dst.DNSOpts, src.DNSOpts)
+	}
+	if src.DNSSearch == nil {
+		dst.DNSSearch = nil
+	} else {
+		if dst.DNSSearch != nil {
+			if len(src.DNSSearch) > len(dst.DNSSearch) {
+				if cap(dst.DNSSearch) >= len(src.DNSSearch) {
+					dst.DNSSearch = (dst.DNSSearch)[:len(src.DNSSearch)]
+				} else {
+					dst.DNSSearch = make([]string, len(src.DNSSearch))
+				}
+			} else if len(src.DNSSearch) < len(dst.DNSSearch) {
+				dst.DNSSearch = (dst.DNSSearch)[:len(src.DNSSearch)]
+			}
+		} else {
+			dst.DNSSearch = make([]string, len(src.DNSSearch))
+		}
+		copy(dst.DNSSearch, src.DNSSearch)
+	}
+	dst.Dockerfile = src.Dockerfile
+	dst.DomainName = src.DomainName
+	if src.Entrypoint == nil {
+		dst.Entrypoint = nil
+	} else {
+		if dst.Entrypoint != nil {
+			if len(src.Entrypoint) > len(dst.Entrypoint) {
+				if cap(dst.Entrypoint) >= len(src.Entrypoint) {
+					dst.Entrypoint = (dst.Entrypoint)[:len(src.Entrypoint)]
+				} else {
+					dst.Entrypoint = make([]string, len(src.Entrypoint))
+				}
+			} else if len(src.Entrypoint) < len(dst.Entrypoint) {
+				dst.Entrypoint = (dst.Entrypoint)[:len(src.Entrypoint)]
+			}
+		} else {
+			dst.Entrypoint = make([]string, len(src.Entrypoint))
+		}
+		copy(dst.Entrypoint, src.Entrypoint)
+	}
+	if src.Environment != nil {
+		dst.Environment = make(map[string]*string, len(src.Environment))
+		deriveDeepCopy_12(dst.Environment, src.Environment)
+	} else {
+		dst.Environment = nil
+	}
+	if src.EnvFiles == nil {
+		dst.EnvFiles = nil
+	} else {
+		if dst.EnvFiles != nil {
+			if len(src.EnvFiles) > len(dst.EnvFiles) {
+				if cap(dst.EnvFiles) >= len(src.EnvFiles) {
+					dst.EnvFiles = (dst.EnvFiles)[:len(src.EnvFiles)]
+				} else {
+					dst.EnvFiles = make([]EnvFile, len(src.EnvFiles))
+				}
+			} else if len(src.EnvFiles) < len(dst.EnvFiles) {
+				dst.EnvFiles = (dst.EnvFiles)[:len(src.EnvFiles)]
+			}
+		} else {
+			dst.EnvFiles = make([]EnvFile, len(src.EnvFiles))
+		}
+		copy(dst.EnvFiles, src.EnvFiles)
+	}
+	if src.Expose == nil {
+		dst.Expose = nil
+	} else {
+		if dst.Expose != nil {
+			if len(src.Expose) > len(dst.Expose) {
+				if cap(dst.Expose) >= len(src.Expose) {
+					dst.Expose = (dst.Expose)[:len(src.Expose)]
+				} else {
+					dst.Expose = make([]string, len(src.Expose))
+				}
+			} else if len(src.Expose) < len(dst.Expose) {
+				dst.Expose = (dst.Expose)[:len(src.Expose)]
+			}
+		} else {
+			dst.Expose = make([]string, len(src.Expose))
+		}
+		copy(dst.Expose, src.Expose)
+	}
+	if src.Extends == nil {
+		dst.Extends = nil
+	} else {
+		dst.Extends = new(ExtendsConfig)
+		*dst.Extends = *src.Extends
+	}
+	if src.ExternalLinks == nil {
+		dst.ExternalLinks = nil
+	} else {
+		if dst.ExternalLinks != nil {
+			if len(src.ExternalLinks) > len(dst.ExternalLinks) {
+				if cap(dst.ExternalLinks) >= len(src.ExternalLinks) {
+					dst.ExternalLinks = (dst.ExternalLinks)[:len(src.ExternalLinks)]
+				} else {
+					dst.ExternalLinks = make([]string, len(src.ExternalLinks))
+				}
+			} else if len(src.ExternalLinks) < len(dst.ExternalLinks) {
+				dst.ExternalLinks = (dst.ExternalLinks)[:len(src.ExternalLinks)]
+			}
+		} else {
+			dst.ExternalLinks = make([]string, len(src.ExternalLinks))
+		}
+		copy(dst.ExternalLinks, src.ExternalLinks)
+	}
+	if src.ExtraHosts != nil {
+		dst.ExtraHosts = make(map[string][]string, len(src.ExtraHosts))
+		deriveDeepCopy_13(dst.ExtraHosts, src.ExtraHosts)
+	} else {
+		dst.ExtraHosts = nil
+	}
+	if src.GroupAdd == nil {
+		dst.GroupAdd = nil
+	} else {
+		if dst.GroupAdd != nil {
+			if len(src.GroupAdd) > len(dst.GroupAdd) {
+				if cap(dst.GroupAdd) >= len(src.GroupAdd) {
+					dst.GroupAdd = (dst.GroupAdd)[:len(src.GroupAdd)]
+				} else {
+					dst.GroupAdd = make([]string, len(src.GroupAdd))
+				}
+			} else if len(src.GroupAdd) < len(dst.GroupAdd) {
+				dst.GroupAdd = (dst.GroupAdd)[:len(src.GroupAdd)]
+			}
+		} else {
+			dst.GroupAdd = make([]string, len(src.GroupAdd))
+		}
+		copy(dst.GroupAdd, src.GroupAdd)
+	}
+	dst.Hostname = src.Hostname
+	if src.HealthCheck == nil {
+		dst.HealthCheck = nil
+	} else {
+		dst.HealthCheck = new(HealthCheckConfig)
+		deriveDeepCopy_14(dst.HealthCheck, src.HealthCheck)
+	}
+	dst.Image = src.Image
+	if src.Init == nil {
+		dst.Init = nil
+	} else {
+		dst.Init = new(bool)
+		*dst.Init = *src.Init
+	}
+	dst.Ipc = src.Ipc
+	dst.Isolation = src.Isolation
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	if src.CustomLabels != nil {
+		dst.CustomLabels = make(map[string]string, len(src.CustomLabels))
+		deriveDeepCopy_4(dst.CustomLabels, src.CustomLabels)
+	} else {
+		dst.CustomLabels = nil
+	}
+	if src.Links == nil {
+		dst.Links = nil
+	} else {
+		if dst.Links != nil {
+			if len(src.Links) > len(dst.Links) {
+				if cap(dst.Links) >= len(src.Links) {
+					dst.Links = (dst.Links)[:len(src.Links)]
+				} else {
+					dst.Links = make([]string, len(src.Links))
+				}
+			} else if len(src.Links) < len(dst.Links) {
+				dst.Links = (dst.Links)[:len(src.Links)]
+			}
+		} else {
+			dst.Links = make([]string, len(src.Links))
+		}
+		copy(dst.Links, src.Links)
+	}
+	if src.Logging == nil {
+		dst.Logging = nil
+	} else {
+		dst.Logging = new(LoggingConfig)
+		deriveDeepCopy_15(dst.Logging, src.Logging)
+	}
+	dst.LogDriver = src.LogDriver
+	if src.LogOpt != nil {
+		dst.LogOpt = make(map[string]string, len(src.LogOpt))
+		deriveDeepCopy_4(dst.LogOpt, src.LogOpt)
+	} else {
+		dst.LogOpt = nil
+	}
+	dst.MemLimit = src.MemLimit
+	dst.MemReservation = src.MemReservation
+	dst.MemSwapLimit = src.MemSwapLimit
+	dst.MemSwappiness = src.MemSwappiness
+	dst.MacAddress = src.MacAddress
+	dst.Net = src.Net
+	dst.NetworkMode = src.NetworkMode
+	if src.Networks != nil {
+		dst.Networks = make(map[string]*ServiceNetworkConfig, len(src.Networks))
+		deriveDeepCopy_16(dst.Networks, src.Networks)
+	} else {
+		dst.Networks = nil
+	}
+	dst.OomKillDisable = src.OomKillDisable
+	dst.OomScoreAdj = src.OomScoreAdj
+	dst.Pid = src.Pid
+	dst.PidsLimit = src.PidsLimit
+	dst.Platform = src.Platform
+	if src.Ports == nil {
+		dst.Ports = nil
+	} else {
+		if dst.Ports != nil {
+			if len(src.Ports) > len(dst.Ports) {
+				if cap(dst.Ports) >= len(src.Ports) {
+					dst.Ports = (dst.Ports)[:len(src.Ports)]
+				} else {
+					dst.Ports = make([]ServicePortConfig, len(src.Ports))
+				}
+			} else if len(src.Ports) < len(dst.Ports) {
+				dst.Ports = (dst.Ports)[:len(src.Ports)]
+			}
+		} else {
+			dst.Ports = make([]ServicePortConfig, len(src.Ports))
+		}
+		deriveDeepCopy_17(dst.Ports, src.Ports)
+	}
+	dst.Privileged = src.Privileged
+	dst.PullPolicy = src.PullPolicy
+	dst.ReadOnly = src.ReadOnly
+	dst.Restart = src.Restart
+	dst.Runtime = src.Runtime
+	if src.Scale == nil {
+		dst.Scale = nil
+	} else {
+		dst.Scale = new(int)
+		*dst.Scale = *src.Scale
+	}
+	if src.Secrets == nil {
+		dst.Secrets = nil
+	} else {
+		if dst.Secrets != nil {
+			if len(src.Secrets) > len(dst.Secrets) {
+				if cap(dst.Secrets) >= len(src.Secrets) {
+					dst.Secrets = (dst.Secrets)[:len(src.Secrets)]
+				} else {
+					dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
+				}
+			} else if len(src.Secrets) < len(dst.Secrets) {
+				dst.Secrets = (dst.Secrets)[:len(src.Secrets)]
+			}
+		} else {
+			dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
+		}
+		deriveDeepCopy_18(dst.Secrets, src.Secrets)
+	}
+	if src.SecurityOpt == nil {
+		dst.SecurityOpt = nil
+	} else {
+		if dst.SecurityOpt != nil {
+			if len(src.SecurityOpt) > len(dst.SecurityOpt) {
+				if cap(dst.SecurityOpt) >= len(src.SecurityOpt) {
+					dst.SecurityOpt = (dst.SecurityOpt)[:len(src.SecurityOpt)]
+				} else {
+					dst.SecurityOpt = make([]string, len(src.SecurityOpt))
+				}
+			} else if len(src.SecurityOpt) < len(dst.SecurityOpt) {
+				dst.SecurityOpt = (dst.SecurityOpt)[:len(src.SecurityOpt)]
+			}
+		} else {
+			dst.SecurityOpt = make([]string, len(src.SecurityOpt))
+		}
+		copy(dst.SecurityOpt, src.SecurityOpt)
+	}
+	dst.ShmSize = src.ShmSize
+	dst.StdinOpen = src.StdinOpen
+	if src.StopGracePeriod == nil {
+		dst.StopGracePeriod = nil
+	} else {
+		dst.StopGracePeriod = new(Duration)
+		*dst.StopGracePeriod = *src.StopGracePeriod
+	}
+	dst.StopSignal = src.StopSignal
+	if src.StorageOpt != nil {
+		dst.StorageOpt = make(map[string]string, len(src.StorageOpt))
+		deriveDeepCopy_4(dst.StorageOpt, src.StorageOpt)
+	} else {
+		dst.StorageOpt = nil
+	}
+	if src.Sysctls != nil {
+		dst.Sysctls = make(map[string]string, len(src.Sysctls))
+		deriveDeepCopy_4(dst.Sysctls, src.Sysctls)
+	} else {
+		dst.Sysctls = nil
+	}
+	if src.Tmpfs == nil {
+		dst.Tmpfs = nil
+	} else {
+		if dst.Tmpfs != nil {
+			if len(src.Tmpfs) > len(dst.Tmpfs) {
+				if cap(dst.Tmpfs) >= len(src.Tmpfs) {
+					dst.Tmpfs = (dst.Tmpfs)[:len(src.Tmpfs)]
+				} else {
+					dst.Tmpfs = make([]string, len(src.Tmpfs))
+				}
+			} else if len(src.Tmpfs) < len(dst.Tmpfs) {
+				dst.Tmpfs = (dst.Tmpfs)[:len(src.Tmpfs)]
+			}
+		} else {
+			dst.Tmpfs = make([]string, len(src.Tmpfs))
+		}
+		copy(dst.Tmpfs, src.Tmpfs)
+	}
+	dst.Tty = src.Tty
+	if src.Ulimits != nil {
+		dst.Ulimits = make(map[string]*UlimitsConfig, len(src.Ulimits))
+		deriveDeepCopy_19(dst.Ulimits, src.Ulimits)
+	} else {
+		dst.Ulimits = nil
+	}
+	dst.User = src.User
+	dst.UserNSMode = src.UserNSMode
+	dst.Uts = src.Uts
+	dst.VolumeDriver = src.VolumeDriver
+	if src.Volumes == nil {
+		dst.Volumes = nil
+	} else {
+		if dst.Volumes != nil {
+			if len(src.Volumes) > len(dst.Volumes) {
+				if cap(dst.Volumes) >= len(src.Volumes) {
+					dst.Volumes = (dst.Volumes)[:len(src.Volumes)]
+				} else {
+					dst.Volumes = make([]ServiceVolumeConfig, len(src.Volumes))
+				}
+			} else if len(src.Volumes) < len(dst.Volumes) {
+				dst.Volumes = (dst.Volumes)[:len(src.Volumes)]
+			}
+		} else {
+			dst.Volumes = make([]ServiceVolumeConfig, len(src.Volumes))
+		}
+		deriveDeepCopy_20(dst.Volumes, src.Volumes)
+	}
+	if src.VolumesFrom == nil {
+		dst.VolumesFrom = nil
+	} else {
+		if dst.VolumesFrom != nil {
+			if len(src.VolumesFrom) > len(dst.VolumesFrom) {
+				if cap(dst.VolumesFrom) >= len(src.VolumesFrom) {
+					dst.VolumesFrom = (dst.VolumesFrom)[:len(src.VolumesFrom)]
+				} else {
+					dst.VolumesFrom = make([]string, len(src.VolumesFrom))
+				}
+			} else if len(src.VolumesFrom) < len(dst.VolumesFrom) {
+				dst.VolumesFrom = (dst.VolumesFrom)[:len(src.VolumesFrom)]
+			}
+		} else {
+			dst.VolumesFrom = make([]string, len(src.VolumesFrom))
+		}
+		copy(dst.VolumesFrom, src.VolumesFrom)
+	}
+	dst.WorkingDir = src.WorkingDir
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy recursively copies the contents of src into dst.
+func deriveDeepCopy(dst, src map[string]ServiceConfig) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(ServiceConfig)
+			deriveDeepCopyService(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_ recursively copies the contents of src into dst.
+func deriveDeepCopy_(dst, src map[string]NetworkConfig) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(NetworkConfig)
+			deriveDeepCopy_21(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_1 recursively copies the contents of src into dst.
+func deriveDeepCopy_1(dst, src map[string]VolumeConfig) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(VolumeConfig)
+			deriveDeepCopy_22(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_2 recursively copies the contents of src into dst.
+func deriveDeepCopy_2(dst, src map[string]SecretConfig) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(SecretConfig)
+			deriveDeepCopy_23(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_3 recursively copies the contents of src into dst.
+func deriveDeepCopy_3(dst, src map[string]ConfigObjConfig) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(ConfigObjConfig)
+			deriveDeepCopy_24(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_4 recursively copies the contents of src into dst.
+func deriveDeepCopy_4(dst, src map[string]string) {
+	for src_key, src_value := range src {
+		dst[src_key] = src_value
+	}
+}
+
+// deriveDeepCopy_5 recursively copies the contents of src into dst.
+func deriveDeepCopy_5(dst, src *BuildConfig) {
+	dst.Context = src.Context
+	dst.Dockerfile = src.Dockerfile
+	dst.DockerfileInline = src.DockerfileInline
+	if src.Entitlements == nil {
+		dst.Entitlements = nil
+	} else {
+		if dst.Entitlements != nil {
+			if len(src.Entitlements) > len(dst.Entitlements) {
+				if cap(dst.Entitlements) >= len(src.Entitlements) {
+					dst.Entitlements = (dst.Entitlements)[:len(src.Entitlements)]
+				} else {
+					dst.Entitlements = make([]string, len(src.Entitlements))
+				}
+			} else if len(src.Entitlements) < len(dst.Entitlements) {
+				dst.Entitlements = (dst.Entitlements)[:len(src.Entitlements)]
+			}
+		} else {
+			dst.Entitlements = make([]string, len(src.Entitlements))
+		}
+		copy(dst.Entitlements, src.Entitlements)
+	}
+	if src.Args != nil {
+		dst.Args = make(map[string]*string, len(src.Args))
+		deriveDeepCopy_12(dst.Args, src.Args)
+	} else {
+		dst.Args = nil
+	}
+	if src.SSH == nil {
+		dst.SSH = nil
+	} else {
+		if dst.SSH != nil {
+			if len(src.SSH) > len(dst.SSH) {
+				if cap(dst.SSH) >= len(src.SSH) {
+					dst.SSH = (dst.SSH)[:len(src.SSH)]
+				} else {
+					dst.SSH = make([]SSHKey, len(src.SSH))
+				}
+			} else if len(src.SSH) < len(dst.SSH) {
+				dst.SSH = (dst.SSH)[:len(src.SSH)]
+			}
+		} else {
+			dst.SSH = make([]SSHKey, len(src.SSH))
+		}
+		copy(dst.SSH, src.SSH)
+	}
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	if src.CacheFrom == nil {
+		dst.CacheFrom = nil
+	} else {
+		if dst.CacheFrom != nil {
+			if len(src.CacheFrom) > len(dst.CacheFrom) {
+				if cap(dst.CacheFrom) >= len(src.CacheFrom) {
+					dst.CacheFrom = (dst.CacheFrom)[:len(src.CacheFrom)]
+				} else {
+					dst.CacheFrom = make([]string, len(src.CacheFrom))
+				}
+			} else if len(src.CacheFrom) < len(dst.CacheFrom) {
+				dst.CacheFrom = (dst.CacheFrom)[:len(src.CacheFrom)]
+			}
+		} else {
+			dst.CacheFrom = make([]string, len(src.CacheFrom))
+		}
+		copy(dst.CacheFrom, src.CacheFrom)
+	}
+	if src.CacheTo == nil {
+		dst.CacheTo = nil
+	} else {
+		if dst.CacheTo != nil {
+			if len(src.CacheTo) > len(dst.CacheTo) {
+				if cap(dst.CacheTo) >= len(src.CacheTo) {
+					dst.CacheTo = (dst.CacheTo)[:len(src.CacheTo)]
+				} else {
+					dst.CacheTo = make([]string, len(src.CacheTo))
+				}
+			} else if len(src.CacheTo) < len(dst.CacheTo) {
+				dst.CacheTo = (dst.CacheTo)[:len(src.CacheTo)]
+			}
+		} else {
+			dst.CacheTo = make([]string, len(src.CacheTo))
+		}
+		copy(dst.CacheTo, src.CacheTo)
+	}
+	dst.NoCache = src.NoCache
+	if src.AdditionalContexts != nil {
+		dst.AdditionalContexts = make(map[string]string, len(src.AdditionalContexts))
+		deriveDeepCopy_4(dst.AdditionalContexts, src.AdditionalContexts)
+	} else {
+		dst.AdditionalContexts = nil
+	}
+	dst.Pull = src.Pull
+	if src.ExtraHosts != nil {
+		dst.ExtraHosts = make(map[string][]string, len(src.ExtraHosts))
+		deriveDeepCopy_13(dst.ExtraHosts, src.ExtraHosts)
+	} else {
+		dst.ExtraHosts = nil
+	}
+	dst.Isolation = src.Isolation
+	dst.Network = src.Network
+	dst.Target = src.Target
+	if src.Secrets == nil {
+		dst.Secrets = nil
+	} else {
+		if dst.Secrets != nil {
+			if len(src.Secrets) > len(dst.Secrets) {
+				if cap(dst.Secrets) >= len(src.Secrets) {
+					dst.Secrets = (dst.Secrets)[:len(src.Secrets)]
+				} else {
+					dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
+				}
+			} else if len(src.Secrets) < len(dst.Secrets) {
+				dst.Secrets = (dst.Secrets)[:len(src.Secrets)]
+			}
+		} else {
+			dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
+		}
+		deriveDeepCopy_18(dst.Secrets, src.Secrets)
+	}
+	dst.ShmSize = src.ShmSize
+	if src.Tags == nil {
+		dst.Tags = nil
+	} else {
+		if dst.Tags != nil {
+			if len(src.Tags) > len(dst.Tags) {
+				if cap(dst.Tags) >= len(src.Tags) {
+					dst.Tags = (dst.Tags)[:len(src.Tags)]
+				} else {
+					dst.Tags = make([]string, len(src.Tags))
+				}
+			} else if len(src.Tags) < len(dst.Tags) {
+				dst.Tags = (dst.Tags)[:len(src.Tags)]
+			}
+		} else {
+			dst.Tags = make([]string, len(src.Tags))
+		}
+		copy(dst.Tags, src.Tags)
+	}
+	if src.Ulimits != nil {
+		dst.Ulimits = make(map[string]*UlimitsConfig, len(src.Ulimits))
+		deriveDeepCopy_19(dst.Ulimits, src.Ulimits)
+	} else {
+		dst.Ulimits = nil
+	}
+	if src.Platforms == nil {
+		dst.Platforms = nil
+	} else {
+		if dst.Platforms != nil {
+			if len(src.Platforms) > len(dst.Platforms) {
+				if cap(dst.Platforms) >= len(src.Platforms) {
+					dst.Platforms = (dst.Platforms)[:len(src.Platforms)]
+				} else {
+					dst.Platforms = make([]string, len(src.Platforms))
+				}
+			} else if len(src.Platforms) < len(dst.Platforms) {
+				dst.Platforms = (dst.Platforms)[:len(src.Platforms)]
+			}
+		} else {
+			dst.Platforms = make([]string, len(src.Platforms))
+		}
+		copy(dst.Platforms, src.Platforms)
+	}
+	dst.Privileged = src.Privileged
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_6 recursively copies the contents of src into dst.
+func deriveDeepCopy_6(dst, src *DevelopConfig) {
+	if src.Watch == nil {
+		dst.Watch = nil
+	} else {
+		if dst.Watch != nil {
+			if len(src.Watch) > len(dst.Watch) {
+				if cap(dst.Watch) >= len(src.Watch) {
+					dst.Watch = (dst.Watch)[:len(src.Watch)]
+				} else {
+					dst.Watch = make([]Trigger, len(src.Watch))
+				}
+			} else if len(src.Watch) < len(dst.Watch) {
+				dst.Watch = (dst.Watch)[:len(src.Watch)]
+			}
+		} else {
+			dst.Watch = make([]Trigger, len(src.Watch))
+		}
+		deriveDeepCopy_25(dst.Watch, src.Watch)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_7 recursively copies the contents of src into dst.
+func deriveDeepCopy_7(dst, src *BlkioConfig) {
+	dst.Weight = src.Weight
+	if src.WeightDevice == nil {
+		dst.WeightDevice = nil
+	} else {
+		if dst.WeightDevice != nil {
+			if len(src.WeightDevice) > len(dst.WeightDevice) {
+				if cap(dst.WeightDevice) >= len(src.WeightDevice) {
+					dst.WeightDevice = (dst.WeightDevice)[:len(src.WeightDevice)]
+				} else {
+					dst.WeightDevice = make([]WeightDevice, len(src.WeightDevice))
+				}
+			} else if len(src.WeightDevice) < len(dst.WeightDevice) {
+				dst.WeightDevice = (dst.WeightDevice)[:len(src.WeightDevice)]
+			}
+		} else {
+			dst.WeightDevice = make([]WeightDevice, len(src.WeightDevice))
+		}
+		deriveDeepCopy_26(dst.WeightDevice, src.WeightDevice)
+	}
+	if src.DeviceReadBps == nil {
+		dst.DeviceReadBps = nil
+	} else {
+		if dst.DeviceReadBps != nil {
+			if len(src.DeviceReadBps) > len(dst.DeviceReadBps) {
+				if cap(dst.DeviceReadBps) >= len(src.DeviceReadBps) {
+					dst.DeviceReadBps = (dst.DeviceReadBps)[:len(src.DeviceReadBps)]
+				} else {
+					dst.DeviceReadBps = make([]ThrottleDevice, len(src.DeviceReadBps))
+				}
+			} else if len(src.DeviceReadBps) < len(dst.DeviceReadBps) {
+				dst.DeviceReadBps = (dst.DeviceReadBps)[:len(src.DeviceReadBps)]
+			}
+		} else {
+			dst.DeviceReadBps = make([]ThrottleDevice, len(src.DeviceReadBps))
+		}
+		deriveDeepCopy_27(dst.DeviceReadBps, src.DeviceReadBps)
+	}
+	if src.DeviceReadIOps == nil {
+		dst.DeviceReadIOps = nil
+	} else {
+		if dst.DeviceReadIOps != nil {
+			if len(src.DeviceReadIOps) > len(dst.DeviceReadIOps) {
+				if cap(dst.DeviceReadIOps) >= len(src.DeviceReadIOps) {
+					dst.DeviceReadIOps = (dst.DeviceReadIOps)[:len(src.DeviceReadIOps)]
+				} else {
+					dst.DeviceReadIOps = make([]ThrottleDevice, len(src.DeviceReadIOps))
+				}
+			} else if len(src.DeviceReadIOps) < len(dst.DeviceReadIOps) {
+				dst.DeviceReadIOps = (dst.DeviceReadIOps)[:len(src.DeviceReadIOps)]
+			}
+		} else {
+			dst.DeviceReadIOps = make([]ThrottleDevice, len(src.DeviceReadIOps))
+		}
+		deriveDeepCopy_27(dst.DeviceReadIOps, src.DeviceReadIOps)
+	}
+	if src.DeviceWriteBps == nil {
+		dst.DeviceWriteBps = nil
+	} else {
+		if dst.DeviceWriteBps != nil {
+			if len(src.DeviceWriteBps) > len(dst.DeviceWriteBps) {
+				if cap(dst.DeviceWriteBps) >= len(src.DeviceWriteBps) {
+					dst.DeviceWriteBps = (dst.DeviceWriteBps)[:len(src.DeviceWriteBps)]
+				} else {
+					dst.DeviceWriteBps = make([]ThrottleDevice, len(src.DeviceWriteBps))
+				}
+			} else if len(src.DeviceWriteBps) < len(dst.DeviceWriteBps) {
+				dst.DeviceWriteBps = (dst.DeviceWriteBps)[:len(src.DeviceWriteBps)]
+			}
+		} else {
+			dst.DeviceWriteBps = make([]ThrottleDevice, len(src.DeviceWriteBps))
+		}
+		deriveDeepCopy_27(dst.DeviceWriteBps, src.DeviceWriteBps)
+	}
+	if src.DeviceWriteIOps == nil {
+		dst.DeviceWriteIOps = nil
+	} else {
+		if dst.DeviceWriteIOps != nil {
+			if len(src.DeviceWriteIOps) > len(dst.DeviceWriteIOps) {
+				if cap(dst.DeviceWriteIOps) >= len(src.DeviceWriteIOps) {
+					dst.DeviceWriteIOps = (dst.DeviceWriteIOps)[:len(src.DeviceWriteIOps)]
+				} else {
+					dst.DeviceWriteIOps = make([]ThrottleDevice, len(src.DeviceWriteIOps))
+				}
+			} else if len(src.DeviceWriteIOps) < len(dst.DeviceWriteIOps) {
+				dst.DeviceWriteIOps = (dst.DeviceWriteIOps)[:len(src.DeviceWriteIOps)]
+			}
+		} else {
+			dst.DeviceWriteIOps = make([]ThrottleDevice, len(src.DeviceWriteIOps))
+		}
+		deriveDeepCopy_27(dst.DeviceWriteIOps, src.DeviceWriteIOps)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_8 recursively copies the contents of src into dst.
+func deriveDeepCopy_8(dst, src []ServiceConfigObjConfig) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(ServiceConfigObjConfig)
+			deriveDeepCopy_28(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_9 recursively copies the contents of src into dst.
+func deriveDeepCopy_9(dst, src *CredentialSpecConfig) {
+	dst.Config = src.Config
+	dst.File = src.File
+	dst.Registry = src.Registry
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_10 recursively copies the contents of src into dst.
+func deriveDeepCopy_10(dst, src map[string]ServiceDependency) {
+	for src_key, src_value := range src {
+		func() {
+			field := new(ServiceDependency)
+			deriveDeepCopy_29(field, &src_value)
+			dst[src_key] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_11 recursively copies the contents of src into dst.
+func deriveDeepCopy_11(dst, src *DeployConfig) {
+	dst.Mode = src.Mode
+	if src.Replicas == nil {
+		dst.Replicas = nil
+	} else {
+		dst.Replicas = new(int)
+		*dst.Replicas = *src.Replicas
+	}
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	if src.UpdateConfig == nil {
+		dst.UpdateConfig = nil
+	} else {
+		dst.UpdateConfig = new(UpdateConfig)
+		deriveDeepCopy_30(dst.UpdateConfig, src.UpdateConfig)
+	}
+	if src.RollbackConfig == nil {
+		dst.RollbackConfig = nil
+	} else {
+		dst.RollbackConfig = new(UpdateConfig)
+		deriveDeepCopy_30(dst.RollbackConfig, src.RollbackConfig)
+	}
+	func() {
+		field := new(Resources)
+		deriveDeepCopy_31(field, &src.Resources)
+		dst.Resources = *field
+	}()
+	if src.RestartPolicy == nil {
+		dst.RestartPolicy = nil
+	} else {
+		dst.RestartPolicy = new(RestartPolicy)
+		deriveDeepCopy_32(dst.RestartPolicy, src.RestartPolicy)
+	}
+	func() {
+		field := new(Placement)
+		deriveDeepCopy_33(field, &src.Placement)
+		dst.Placement = *field
+	}()
+	dst.EndpointMode = src.EndpointMode
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_12 recursively copies the contents of src into dst.
+func deriveDeepCopy_12(dst, src map[string]*string) {
+	for src_key, src_value := range src {
+		if src_value == nil {
+			dst[src_key] = nil
+		}
+		if src_value == nil {
+			dst[src_key] = nil
+		} else {
+			dst[src_key] = new(string)
+			*dst[src_key] = *src_value
+		}
+	}
+}
+
+// deriveDeepCopy_13 recursively copies the contents of src into dst.
+func deriveDeepCopy_13(dst, src map[string][]string) {
+	for src_key, src_value := range src {
+		if src_value == nil {
+			dst[src_key] = nil
+		}
+		if src_value == nil {
+			dst[src_key] = nil
+		} else {
+			if dst[src_key] != nil {
+				if len(src_value) > len(dst[src_key]) {
+					if cap(dst[src_key]) >= len(src_value) {
+						dst[src_key] = (dst[src_key])[:len(src_value)]
+					} else {
+						dst[src_key] = make([]string, len(src_value))
+					}
+				} else if len(src_value) < len(dst[src_key]) {
+					dst[src_key] = (dst[src_key])[:len(src_value)]
+				}
+			} else {
+				dst[src_key] = make([]string, len(src_value))
+			}
+			copy(dst[src_key], src_value)
+		}
+	}
+}
+
+// deriveDeepCopy_14 recursively copies the contents of src into dst.
+func deriveDeepCopy_14(dst, src *HealthCheckConfig) {
+	if src.Test == nil {
+		dst.Test = nil
+	} else {
+		if dst.Test != nil {
+			if len(src.Test) > len(dst.Test) {
+				if cap(dst.Test) >= len(src.Test) {
+					dst.Test = (dst.Test)[:len(src.Test)]
+				} else {
+					dst.Test = make([]string, len(src.Test))
+				}
+			} else if len(src.Test) < len(dst.Test) {
+				dst.Test = (dst.Test)[:len(src.Test)]
+			}
+		} else {
+			dst.Test = make([]string, len(src.Test))
+		}
+		copy(dst.Test, src.Test)
+	}
+	if src.Timeout == nil {
+		dst.Timeout = nil
+	} else {
+		dst.Timeout = new(Duration)
+		*dst.Timeout = *src.Timeout
+	}
+	if src.Interval == nil {
+		dst.Interval = nil
+	} else {
+		dst.Interval = new(Duration)
+		*dst.Interval = *src.Interval
+	}
+	if src.Retries == nil {
+		dst.Retries = nil
+	} else {
+		dst.Retries = new(uint64)
+		*dst.Retries = *src.Retries
+	}
+	if src.StartPeriod == nil {
+		dst.StartPeriod = nil
+	} else {
+		dst.StartPeriod = new(Duration)
+		*dst.StartPeriod = *src.StartPeriod
+	}
+	if src.StartInterval == nil {
+		dst.StartInterval = nil
+	} else {
+		dst.StartInterval = new(Duration)
+		*dst.StartInterval = *src.StartInterval
+	}
+	dst.Disable = src.Disable
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_15 recursively copies the contents of src into dst.
+func deriveDeepCopy_15(dst, src *LoggingConfig) {
+	dst.Driver = src.Driver
+	if src.Options != nil {
+		dst.Options = make(map[string]string, len(src.Options))
+		deriveDeepCopy_4(dst.Options, src.Options)
+	} else {
+		dst.Options = nil
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_16 recursively copies the contents of src into dst.
+func deriveDeepCopy_16(dst, src map[string]*ServiceNetworkConfig) {
+	for src_key, src_value := range src {
+		if src_value == nil {
+			dst[src_key] = nil
+		}
+		if src_value == nil {
+			dst[src_key] = nil
+		} else {
+			dst[src_key] = new(ServiceNetworkConfig)
+			deriveDeepCopy_34(dst[src_key], src_value)
+		}
+	}
+}
+
+// deriveDeepCopy_17 recursively copies the contents of src into dst.
+func deriveDeepCopy_17(dst, src []ServicePortConfig) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(ServicePortConfig)
+			deriveDeepCopy_35(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_18 recursively copies the contents of src into dst.
+func deriveDeepCopy_18(dst, src []ServiceSecretConfig) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(ServiceSecretConfig)
+			deriveDeepCopy_36(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_19 recursively copies the contents of src into dst.
+func deriveDeepCopy_19(dst, src map[string]*UlimitsConfig) {
+	for src_key, src_value := range src {
+		if src_value == nil {
+			dst[src_key] = nil
+		}
+		if src_value == nil {
+			dst[src_key] = nil
+		} else {
+			dst[src_key] = new(UlimitsConfig)
+			deriveDeepCopy_37(dst[src_key], src_value)
+		}
+	}
+}
+
+// deriveDeepCopy_20 recursively copies the contents of src into dst.
+func deriveDeepCopy_20(dst, src []ServiceVolumeConfig) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(ServiceVolumeConfig)
+			deriveDeepCopy_38(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_21 recursively copies the contents of src into dst.
+func deriveDeepCopy_21(dst, src *NetworkConfig) {
+	dst.Name = src.Name
+	dst.Driver = src.Driver
+	if src.DriverOpts != nil {
+		dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
+		deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
+	} else {
+		dst.DriverOpts = nil
+	}
+	func() {
+		field := new(IPAMConfig)
+		deriveDeepCopy_39(field, &src.Ipam)
+		dst.Ipam = *field
+	}()
+	dst.External = src.External
+	dst.Internal = src.Internal
+	dst.Attachable = src.Attachable
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	dst.EnableIPv6 = src.EnableIPv6
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_22 recursively copies the contents of src into dst.
+func deriveDeepCopy_22(dst, src *VolumeConfig) {
+	dst.Name = src.Name
+	dst.Driver = src.Driver
+	if src.DriverOpts != nil {
+		dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
+		deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
+	} else {
+		dst.DriverOpts = nil
+	}
+	dst.External = src.External
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_23 recursively copies the contents of src into dst.
+func deriveDeepCopy_23(dst, src *SecretConfig) {
+	dst.Name = src.Name
+	dst.File = src.File
+	dst.Environment = src.Environment
+	dst.Content = src.Content
+	dst.External = src.External
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	dst.Driver = src.Driver
+	if src.DriverOpts != nil {
+		dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
+		deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
+	} else {
+		dst.DriverOpts = nil
+	}
+	dst.TemplateDriver = src.TemplateDriver
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_24 recursively copies the contents of src into dst.
+func deriveDeepCopy_24(dst, src *ConfigObjConfig) {
+	dst.Name = src.Name
+	dst.File = src.File
+	dst.Environment = src.Environment
+	dst.Content = src.Content
+	dst.External = src.External
+	if src.Labels != nil {
+		dst.Labels = make(map[string]string, len(src.Labels))
+		deriveDeepCopy_4(dst.Labels, src.Labels)
+	} else {
+		dst.Labels = nil
+	}
+	dst.Driver = src.Driver
+	if src.DriverOpts != nil {
+		dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
+		deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
+	} else {
+		dst.DriverOpts = nil
+	}
+	dst.TemplateDriver = src.TemplateDriver
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_25 recursively copies the contents of src into dst.
+func deriveDeepCopy_25(dst, src []Trigger) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(Trigger)
+			deriveDeepCopy_40(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_26 recursively copies the contents of src into dst.
+func deriveDeepCopy_26(dst, src []WeightDevice) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(WeightDevice)
+			deriveDeepCopy_41(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_27 recursively copies the contents of src into dst.
+func deriveDeepCopy_27(dst, src []ThrottleDevice) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(ThrottleDevice)
+			deriveDeepCopy_42(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_28 recursively copies the contents of src into dst.
+func deriveDeepCopy_28(dst, src *ServiceConfigObjConfig) {
+	dst.Source = src.Source
+	dst.Target = src.Target
+	dst.UID = src.UID
+	dst.GID = src.GID
+	if src.Mode == nil {
+		dst.Mode = nil
+	} else {
+		dst.Mode = new(uint32)
+		*dst.Mode = *src.Mode
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_29 recursively copies the contents of src into dst.
+func deriveDeepCopy_29(dst, src *ServiceDependency) {
+	dst.Condition = src.Condition
+	dst.Restart = src.Restart
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+	dst.Required = src.Required
+}
+
+// deriveDeepCopy_30 recursively copies the contents of src into dst.
+func deriveDeepCopy_30(dst, src *UpdateConfig) {
+	if src.Parallelism == nil {
+		dst.Parallelism = nil
+	} else {
+		dst.Parallelism = new(uint64)
+		*dst.Parallelism = *src.Parallelism
+	}
+	dst.Delay = src.Delay
+	dst.FailureAction = src.FailureAction
+	dst.Monitor = src.Monitor
+	dst.MaxFailureRatio = src.MaxFailureRatio
+	dst.Order = src.Order
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_31 recursively copies the contents of src into dst.
+func deriveDeepCopy_31(dst, src *Resources) {
+	if src.Limits == nil {
+		dst.Limits = nil
+	} else {
+		dst.Limits = new(Resource)
+		deriveDeepCopy_43(dst.Limits, src.Limits)
+	}
+	if src.Reservations == nil {
+		dst.Reservations = nil
+	} else {
+		dst.Reservations = new(Resource)
+		deriveDeepCopy_43(dst.Reservations, src.Reservations)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_32 recursively copies the contents of src into dst.
+func deriveDeepCopy_32(dst, src *RestartPolicy) {
+	dst.Condition = src.Condition
+	if src.Delay == nil {
+		dst.Delay = nil
+	} else {
+		dst.Delay = new(Duration)
+		*dst.Delay = *src.Delay
+	}
+	if src.MaxAttempts == nil {
+		dst.MaxAttempts = nil
+	} else {
+		dst.MaxAttempts = new(uint64)
+		*dst.MaxAttempts = *src.MaxAttempts
+	}
+	if src.Window == nil {
+		dst.Window = nil
+	} else {
+		dst.Window = new(Duration)
+		*dst.Window = *src.Window
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_33 recursively copies the contents of src into dst.
+func deriveDeepCopy_33(dst, src *Placement) {
+	if src.Constraints == nil {
+		dst.Constraints = nil
+	} else {
+		if dst.Constraints != nil {
+			if len(src.Constraints) > len(dst.Constraints) {
+				if cap(dst.Constraints) >= len(src.Constraints) {
+					dst.Constraints = (dst.Constraints)[:len(src.Constraints)]
+				} else {
+					dst.Constraints = make([]string, len(src.Constraints))
+				}
+			} else if len(src.Constraints) < len(dst.Constraints) {
+				dst.Constraints = (dst.Constraints)[:len(src.Constraints)]
+			}
+		} else {
+			dst.Constraints = make([]string, len(src.Constraints))
+		}
+		copy(dst.Constraints, src.Constraints)
+	}
+	if src.Preferences == nil {
+		dst.Preferences = nil
+	} else {
+		if dst.Preferences != nil {
+			if len(src.Preferences) > len(dst.Preferences) {
+				if cap(dst.Preferences) >= len(src.Preferences) {
+					dst.Preferences = (dst.Preferences)[:len(src.Preferences)]
+				} else {
+					dst.Preferences = make([]PlacementPreferences, len(src.Preferences))
+				}
+			} else if len(src.Preferences) < len(dst.Preferences) {
+				dst.Preferences = (dst.Preferences)[:len(src.Preferences)]
+			}
+		} else {
+			dst.Preferences = make([]PlacementPreferences, len(src.Preferences))
+		}
+		deriveDeepCopy_44(dst.Preferences, src.Preferences)
+	}
+	dst.MaxReplicas = src.MaxReplicas
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_34 recursively copies the contents of src into dst.
+func deriveDeepCopy_34(dst, src *ServiceNetworkConfig) {
+	dst.Priority = src.Priority
+	if src.Aliases == nil {
+		dst.Aliases = nil
+	} else {
+		if dst.Aliases != nil {
+			if len(src.Aliases) > len(dst.Aliases) {
+				if cap(dst.Aliases) >= len(src.Aliases) {
+					dst.Aliases = (dst.Aliases)[:len(src.Aliases)]
+				} else {
+					dst.Aliases = make([]string, len(src.Aliases))
+				}
+			} else if len(src.Aliases) < len(dst.Aliases) {
+				dst.Aliases = (dst.Aliases)[:len(src.Aliases)]
+			}
+		} else {
+			dst.Aliases = make([]string, len(src.Aliases))
+		}
+		copy(dst.Aliases, src.Aliases)
+	}
+	dst.Ipv4Address = src.Ipv4Address
+	dst.Ipv6Address = src.Ipv6Address
+	if src.LinkLocalIPs == nil {
+		dst.LinkLocalIPs = nil
+	} else {
+		if dst.LinkLocalIPs != nil {
+			if len(src.LinkLocalIPs) > len(dst.LinkLocalIPs) {
+				if cap(dst.LinkLocalIPs) >= len(src.LinkLocalIPs) {
+					dst.LinkLocalIPs = (dst.LinkLocalIPs)[:len(src.LinkLocalIPs)]
+				} else {
+					dst.LinkLocalIPs = make([]string, len(src.LinkLocalIPs))
+				}
+			} else if len(src.LinkLocalIPs) < len(dst.LinkLocalIPs) {
+				dst.LinkLocalIPs = (dst.LinkLocalIPs)[:len(src.LinkLocalIPs)]
+			}
+		} else {
+			dst.LinkLocalIPs = make([]string, len(src.LinkLocalIPs))
+		}
+		copy(dst.LinkLocalIPs, src.LinkLocalIPs)
+	}
+	dst.MacAddress = src.MacAddress
+	if src.DriverOpts != nil {
+		dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
+		deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
+	} else {
+		dst.DriverOpts = nil
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_35 recursively copies the contents of src into dst.
+func deriveDeepCopy_35(dst, src *ServicePortConfig) {
+	dst.Name = src.Name
+	dst.Mode = src.Mode
+	dst.HostIP = src.HostIP
+	dst.Target = src.Target
+	dst.Published = src.Published
+	dst.Protocol = src.Protocol
+	dst.AppProtocol = src.AppProtocol
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_36 recursively copies the contents of src into dst.
+func deriveDeepCopy_36(dst, src *ServiceSecretConfig) {
+	dst.Source = src.Source
+	dst.Target = src.Target
+	dst.UID = src.UID
+	dst.GID = src.GID
+	if src.Mode == nil {
+		dst.Mode = nil
+	} else {
+		dst.Mode = new(uint32)
+		*dst.Mode = *src.Mode
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_37 recursively copies the contents of src into dst.
+func deriveDeepCopy_37(dst, src *UlimitsConfig) {
+	dst.Single = src.Single
+	dst.Soft = src.Soft
+	dst.Hard = src.Hard
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_38 recursively copies the contents of src into dst.
+func deriveDeepCopy_38(dst, src *ServiceVolumeConfig) {
+	dst.Type = src.Type
+	dst.Source = src.Source
+	dst.Target = src.Target
+	dst.ReadOnly = src.ReadOnly
+	dst.Consistency = src.Consistency
+	if src.Bind == nil {
+		dst.Bind = nil
+	} else {
+		dst.Bind = new(ServiceVolumeBind)
+		deriveDeepCopy_45(dst.Bind, src.Bind)
+	}
+	if src.Volume == nil {
+		dst.Volume = nil
+	} else {
+		dst.Volume = new(ServiceVolumeVolume)
+		deriveDeepCopy_46(dst.Volume, src.Volume)
+	}
+	if src.Tmpfs == nil {
+		dst.Tmpfs = nil
+	} else {
+		dst.Tmpfs = new(ServiceVolumeTmpfs)
+		deriveDeepCopy_47(dst.Tmpfs, src.Tmpfs)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_39 recursively copies the contents of src into dst.
+func deriveDeepCopy_39(dst, src *IPAMConfig) {
+	dst.Driver = src.Driver
+	if src.Config == nil {
+		dst.Config = nil
+	} else {
+		if dst.Config != nil {
+			if len(src.Config) > len(dst.Config) {
+				if cap(dst.Config) >= len(src.Config) {
+					dst.Config = (dst.Config)[:len(src.Config)]
+				} else {
+					dst.Config = make([]*IPAMPool, len(src.Config))
+				}
+			} else if len(src.Config) < len(dst.Config) {
+				dst.Config = (dst.Config)[:len(src.Config)]
+			}
+		} else {
+			dst.Config = make([]*IPAMPool, len(src.Config))
+		}
+		deriveDeepCopy_48(dst.Config, src.Config)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_40 recursively copies the contents of src into dst.
+func deriveDeepCopy_40(dst, src *Trigger) {
+	dst.Path = src.Path
+	dst.Action = src.Action
+	dst.Target = src.Target
+	if src.Ignore == nil {
+		dst.Ignore = nil
+	} else {
+		if dst.Ignore != nil {
+			if len(src.Ignore) > len(dst.Ignore) {
+				if cap(dst.Ignore) >= len(src.Ignore) {
+					dst.Ignore = (dst.Ignore)[:len(src.Ignore)]
+				} else {
+					dst.Ignore = make([]string, len(src.Ignore))
+				}
+			} else if len(src.Ignore) < len(dst.Ignore) {
+				dst.Ignore = (dst.Ignore)[:len(src.Ignore)]
+			}
+		} else {
+			dst.Ignore = make([]string, len(src.Ignore))
+		}
+		copy(dst.Ignore, src.Ignore)
+	}
+}
+
+// deriveDeepCopy_41 recursively copies the contents of src into dst.
+func deriveDeepCopy_41(dst, src *WeightDevice) {
+	dst.Path = src.Path
+	dst.Weight = src.Weight
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_42 recursively copies the contents of src into dst.
+func deriveDeepCopy_42(dst, src *ThrottleDevice) {
+	dst.Path = src.Path
+	dst.Rate = src.Rate
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_43 recursively copies the contents of src into dst.
+func deriveDeepCopy_43(dst, src *Resource) {
+	dst.NanoCPUs = src.NanoCPUs
+	dst.MemoryBytes = src.MemoryBytes
+	dst.Pids = src.Pids
+	if src.Devices == nil {
+		dst.Devices = nil
+	} else {
+		if dst.Devices != nil {
+			if len(src.Devices) > len(dst.Devices) {
+				if cap(dst.Devices) >= len(src.Devices) {
+					dst.Devices = (dst.Devices)[:len(src.Devices)]
+				} else {
+					dst.Devices = make([]DeviceRequest, len(src.Devices))
+				}
+			} else if len(src.Devices) < len(dst.Devices) {
+				dst.Devices = (dst.Devices)[:len(src.Devices)]
+			}
+		} else {
+			dst.Devices = make([]DeviceRequest, len(src.Devices))
+		}
+		deriveDeepCopy_49(dst.Devices, src.Devices)
+	}
+	if src.GenericResources == nil {
+		dst.GenericResources = nil
+	} else {
+		if dst.GenericResources != nil {
+			if len(src.GenericResources) > len(dst.GenericResources) {
+				if cap(dst.GenericResources) >= len(src.GenericResources) {
+					dst.GenericResources = (dst.GenericResources)[:len(src.GenericResources)]
+				} else {
+					dst.GenericResources = make([]GenericResource, len(src.GenericResources))
+				}
+			} else if len(src.GenericResources) < len(dst.GenericResources) {
+				dst.GenericResources = (dst.GenericResources)[:len(src.GenericResources)]
+			}
+		} else {
+			dst.GenericResources = make([]GenericResource, len(src.GenericResources))
+		}
+		deriveDeepCopy_50(dst.GenericResources, src.GenericResources)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_44 recursively copies the contents of src into dst.
+func deriveDeepCopy_44(dst, src []PlacementPreferences) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(PlacementPreferences)
+			deriveDeepCopy_51(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_45 recursively copies the contents of src into dst.
+func deriveDeepCopy_45(dst, src *ServiceVolumeBind) {
+	dst.SELinux = src.SELinux
+	dst.Propagation = src.Propagation
+	dst.CreateHostPath = src.CreateHostPath
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_46 recursively copies the contents of src into dst.
+func deriveDeepCopy_46(dst, src *ServiceVolumeVolume) {
+	dst.NoCopy = src.NoCopy
+	dst.Subpath = src.Subpath
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_47 recursively copies the contents of src into dst.
+func deriveDeepCopy_47(dst, src *ServiceVolumeTmpfs) {
+	dst.Size = src.Size
+	dst.Mode = src.Mode
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_48 recursively copies the contents of src into dst.
+func deriveDeepCopy_48(dst, src []*IPAMPool) {
+	for src_i, src_value := range src {
+		if src_value == nil {
+			dst[src_i] = nil
+		} else {
+			dst[src_i] = new(IPAMPool)
+			deriveDeepCopy_52(dst[src_i], src_value)
+		}
+	}
+}
+
+// deriveDeepCopy_49 recursively copies the contents of src into dst.
+func deriveDeepCopy_49(dst, src []DeviceRequest) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(DeviceRequest)
+			deriveDeepCopy_53(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_50 recursively copies the contents of src into dst.
+func deriveDeepCopy_50(dst, src []GenericResource) {
+	for src_i, src_value := range src {
+		func() {
+			field := new(GenericResource)
+			deriveDeepCopy_54(field, &src_value)
+			dst[src_i] = *field
+		}()
+	}
+}
+
+// deriveDeepCopy_51 recursively copies the contents of src into dst.
+func deriveDeepCopy_51(dst, src *PlacementPreferences) {
+	dst.Spread = src.Spread
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_52 recursively copies the contents of src into dst.
+func deriveDeepCopy_52(dst, src *IPAMPool) {
+	dst.Subnet = src.Subnet
+	dst.Gateway = src.Gateway
+	dst.IPRange = src.IPRange
+	if src.AuxiliaryAddresses != nil {
+		dst.AuxiliaryAddresses = make(map[string]string, len(src.AuxiliaryAddresses))
+		deriveDeepCopy_4(dst.AuxiliaryAddresses, src.AuxiliaryAddresses)
+	} else {
+		dst.AuxiliaryAddresses = nil
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_53 recursively copies the contents of src into dst.
+func deriveDeepCopy_53(dst, src *DeviceRequest) {
+	if src.Capabilities == nil {
+		dst.Capabilities = nil
+	} else {
+		if dst.Capabilities != nil {
+			if len(src.Capabilities) > len(dst.Capabilities) {
+				if cap(dst.Capabilities) >= len(src.Capabilities) {
+					dst.Capabilities = (dst.Capabilities)[:len(src.Capabilities)]
+				} else {
+					dst.Capabilities = make([]string, len(src.Capabilities))
+				}
+			} else if len(src.Capabilities) < len(dst.Capabilities) {
+				dst.Capabilities = (dst.Capabilities)[:len(src.Capabilities)]
+			}
+		} else {
+			dst.Capabilities = make([]string, len(src.Capabilities))
+		}
+		copy(dst.Capabilities, src.Capabilities)
+	}
+	dst.Driver = src.Driver
+	dst.Count = src.Count
+	if src.IDs == nil {
+		dst.IDs = nil
+	} else {
+		if dst.IDs != nil {
+			if len(src.IDs) > len(dst.IDs) {
+				if cap(dst.IDs) >= len(src.IDs) {
+					dst.IDs = (dst.IDs)[:len(src.IDs)]
+				} else {
+					dst.IDs = make([]string, len(src.IDs))
+				}
+			} else if len(src.IDs) < len(dst.IDs) {
+				dst.IDs = (dst.IDs)[:len(src.IDs)]
+			}
+		} else {
+			dst.IDs = make([]string, len(src.IDs))
+		}
+		copy(dst.IDs, src.IDs)
+	}
+}
+
+// deriveDeepCopy_54 recursively copies the contents of src into dst.
+func deriveDeepCopy_54(dst, src *GenericResource) {
+	if src.DiscreteResourceSpec == nil {
+		dst.DiscreteResourceSpec = nil
+	} else {
+		dst.DiscreteResourceSpec = new(DiscreteGenericResource)
+		deriveDeepCopy_55(dst.DiscreteResourceSpec, src.DiscreteResourceSpec)
+	}
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
+
+// deriveDeepCopy_55 recursively copies the contents of src into dst.
+func deriveDeepCopy_55(dst, src *DiscreteGenericResource) {
+	dst.Kind = src.Kind
+	dst.Value = src.Value
+	if src.Extensions != nil {
+		dst.Extensions = make(map[string]any, len(src.Extensions))
+		src.Extensions.DeepCopy(dst.Extensions)
+	} else {
+		dst.Extensions = nil
+	}
+}
diff --git a/vendor/github.com/compose-spec/compose-go/v2/types/project.go b/vendor/github.com/compose-spec/compose-go/v2/types/project.go
index 6f049e98..7e3ef5f0 100644
--- a/vendor/github.com/compose-spec/compose-go/v2/types/project.go
+++ b/vendor/github.com/compose-spec/compose-go/v2/types/project.go
@@ -29,7 +29,6 @@ import (
 	"github.com/compose-spec/compose-go/v2/errdefs"
 	"github.com/compose-spec/compose-go/v2/utils"
 	"github.com/distribution/reference"
-	"github.com/mitchellh/copystructure"
 	godigest "github.com/opencontainers/go-digest"
 	"golang.org/x/exp/maps"
 	"golang.org/x/sync/errgroup"
@@ -646,11 +645,13 @@ func (p Project) WithServicesEnvironmentResolved(discardEnvFiles bool) (*Project
 }
 
 func (p *Project) deepCopy() *Project {
-	instance, err := copystructure.Copy(p)
-	if err != nil {
-		panic(err)
+	if p == nil {
+		return nil
 	}
-	return instance.(*Project)
+	n := &Project{}
+	deriveDeepCopyProject(n, p)
+	return n
+
 }
 
 // WithServicesTransform applies a transformation to project services and return a new project with transformation results
diff --git a/vendor/github.com/compose-spec/compose-go/v2/types/types.go b/vendor/github.com/compose-spec/compose-go/v2/types/types.go
index 00b1ac13..56af93e5 100644
--- a/vendor/github.com/compose-spec/compose-go/v2/types/types.go
+++ b/vendor/github.com/compose-spec/compose-go/v2/types/types.go
@@ -24,7 +24,6 @@ import (
 	"strings"
 
 	"github.com/docker/go-connections/nat"
-	"github.com/mitchellh/copystructure"
 )
 
 // ServiceConfig is the configuration of one service
@@ -194,11 +193,12 @@ func (s *ServiceConfig) SetScale(scale int) {
 }
 
 func (s *ServiceConfig) deepCopy() *ServiceConfig {
-	instance, err := copystructure.Copy(s)
-	if err != nil {
-		panic(err)
+	if s == nil {
+		return nil
 	}
-	return instance.(*ServiceConfig)
+	n := &ServiceConfig{}
+	deriveDeepCopyService(n, s)
+	return n
 }
 
 const (
@@ -698,7 +698,7 @@ type NetworkConfig struct {
 	Internal   bool       `yaml:"internal,omitempty" json:"internal,omitempty"`
 	Attachable bool       `yaml:"attachable,omitempty" json:"attachable,omitempty"`
 	Labels     Labels     `yaml:"labels,omitempty" json:"labels,omitempty"`
-	EnableIPv6 bool       `yaml:"enable_ipv6,omitempty" json:"enable_ipv6,omitempty"`
+	EnableIPv6 *bool      `yaml:"enable_ipv6,omitempty" json:"enable_ipv6,omitempty"`
 	Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
 }
 
@@ -711,11 +711,11 @@ type IPAMConfig struct {
 
 // IPAMPool for a network
 type IPAMPool struct {
-	Subnet             string                 `yaml:"subnet,omitempty" json:"subnet,omitempty"`
-	Gateway            string                 `yaml:"gateway,omitempty" json:"gateway,omitempty"`
-	IPRange            string                 `yaml:"ip_range,omitempty" json:"ip_range,omitempty"`
-	AuxiliaryAddresses Mapping                `yaml:"aux_addresses,omitempty" json:"aux_addresses,omitempty"`
-	Extensions         map[string]interface{} `yaml:",inline" json:"-"`
+	Subnet             string     `yaml:"subnet,omitempty" json:"subnet,omitempty"`
+	Gateway            string     `yaml:"gateway,omitempty" json:"gateway,omitempty"`
+	IPRange            string     `yaml:"ip_range,omitempty" json:"ip_range,omitempty"`
+	AuxiliaryAddresses Mapping    `yaml:"aux_addresses,omitempty" json:"aux_addresses,omitempty"`
+	Extensions         Extensions `yaml:",inline" json:"-"`
 }
 
 // VolumeConfig for a volume
diff --git a/vendor/github.com/mitchellh/copystructure/LICENSE b/vendor/github.com/mitchellh/copystructure/LICENSE
deleted file mode 100644
index 22985159..00000000
--- a/vendor/github.com/mitchellh/copystructure/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Mitchell Hashimoto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/vendor/github.com/mitchellh/copystructure/README.md b/vendor/github.com/mitchellh/copystructure/README.md
deleted file mode 100644
index f0fbd2e5..00000000
--- a/vendor/github.com/mitchellh/copystructure/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# copystructure
-
-copystructure is a Go library for deep copying values in Go.
-
-This allows you to copy Go values that may contain reference values
-such as maps, slices, or pointers, and copy their data as well instead
-of just their references.
-
-## Installation
-
-Standard `go get`:
-
-```
-$ go get github.com/mitchellh/copystructure
-```
-
-## Usage & Example
-
-For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/copystructure).
-
-The `Copy` function has examples associated with it there.
diff --git a/vendor/github.com/mitchellh/copystructure/copier_time.go b/vendor/github.com/mitchellh/copystructure/copier_time.go
deleted file mode 100644
index db6a6aa1..00000000
--- a/vendor/github.com/mitchellh/copystructure/copier_time.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package copystructure
-
-import (
-	"reflect"
-	"time"
-)
-
-func init() {
-	Copiers[reflect.TypeOf(time.Time{})] = timeCopier
-}
-
-func timeCopier(v interface{}) (interface{}, error) {
-	// Just... copy it.
-	return v.(time.Time), nil
-}
diff --git a/vendor/github.com/mitchellh/copystructure/copystructure.go b/vendor/github.com/mitchellh/copystructure/copystructure.go
deleted file mode 100644
index 8089e667..00000000
--- a/vendor/github.com/mitchellh/copystructure/copystructure.go
+++ /dev/null
@@ -1,631 +0,0 @@
-package copystructure
-
-import (
-	"errors"
-	"reflect"
-	"sync"
-
-	"github.com/mitchellh/reflectwalk"
-)
-
-const tagKey = "copy"
-
-// Copy returns a deep copy of v.
-//
-// Copy is unable to copy unexported fields in a struct (lowercase field names).
-// Unexported fields can't be reflected by the Go runtime and therefore
-// copystructure can't perform any data copies.
-//
-// For structs, copy behavior can be controlled with struct tags. For example:
-//
-//   struct {
-//     Name string
-//     Data *bytes.Buffer `copy:"shallow"`
-//   }
-//
-// The available tag values are:
-//
-// * "ignore" - The field will be ignored, effectively resulting in it being
-//   assigned the zero value in the copy.
-//
-// * "shallow" - The field will be be shallow copied. This means that references
-//   values such as pointers, maps, slices, etc. will be directly assigned
-//   versus deep copied.
-//
-func Copy(v interface{}) (interface{}, error) {
-	return Config{}.Copy(v)
-}
-
-// CopierFunc is a function that knows how to deep copy a specific type.
-// Register these globally with the Copiers variable.
-type CopierFunc func(interface{}) (interface{}, error)
-
-// Copiers is a map of types that behave specially when they are copied.
-// If a type is found in this map while deep copying, this function
-// will be called to copy it instead of attempting to copy all fields.
-//
-// The key should be the type, obtained using: reflect.TypeOf(value with type).
-//
-// It is unsafe to write to this map after Copies have started. If you
-// are writing to this map while also copying, wrap all modifications to
-// this map as well as to Copy in a mutex.
-var Copiers map[reflect.Type]CopierFunc = make(map[reflect.Type]CopierFunc)
-
-// ShallowCopiers is a map of pointer types that behave specially
-// when they are copied.  If a type is found in this map while deep
-// copying, the pointer value will be shallow copied and not walked
-// into.
-//
-// The key should be the type, obtained using: reflect.TypeOf(value
-// with type).
-//
-// It is unsafe to write to this map after Copies have started. If you
-// are writing to this map while also copying, wrap all modifications to
-// this map as well as to Copy in a mutex.
-var ShallowCopiers map[reflect.Type]struct{} = make(map[reflect.Type]struct{})
-
-// Must is a helper that wraps a call to a function returning
-// (interface{}, error) and panics if the error is non-nil. It is intended
-// for use in variable initializations and should only be used when a copy
-// error should be a crashing case.
-func Must(v interface{}, err error) interface{} {
-	if err != nil {
-		panic("copy error: " + err.Error())
-	}
-
-	return v
-}
-
-var errPointerRequired = errors.New("Copy argument must be a pointer when Lock is true")
-
-type Config struct {
-	// Lock any types that are a sync.Locker and are not a mutex while copying.
-	// If there is an RLocker method, use that to get the sync.Locker.
-	Lock bool
-
-	// Copiers is a map of types associated with a CopierFunc. Use the global
-	// Copiers map if this is nil.
-	Copiers map[reflect.Type]CopierFunc
-
-	// ShallowCopiers is a map of pointer types that when they are
-	// shallow copied no matter where they are encountered. Use the
-	// global ShallowCopiers if this is nil.
-	ShallowCopiers map[reflect.Type]struct{}
-}
-
-func (c Config) Copy(v interface{}) (interface{}, error) {
-	if c.Lock && reflect.ValueOf(v).Kind() != reflect.Ptr {
-		return nil, errPointerRequired
-	}
-
-	w := new(walker)
-	if c.Lock {
-		w.useLocks = true
-	}
-
-	if c.Copiers == nil {
-		c.Copiers = Copiers
-	}
-	w.copiers = c.Copiers
-
-	if c.ShallowCopiers == nil {
-		c.ShallowCopiers = ShallowCopiers
-	}
-	w.shallowCopiers = c.ShallowCopiers
-
-	err := reflectwalk.Walk(v, w)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get the result. If the result is nil, then we want to turn it
-	// into a typed nil if we can.
-	result := w.Result
-	if result == nil {
-		val := reflect.ValueOf(v)
-		result = reflect.Indirect(reflect.New(val.Type())).Interface()
-	}
-
-	return result, nil
-}
-
-// Return the key used to index interfaces types we've seen. Store the number
-// of pointers in the upper 32bits, and the depth in the lower 32bits. This is
-// easy to calculate, easy to match a key with our current depth, and we don't
-// need to deal with initializing and cleaning up nested maps or slices.
-func ifaceKey(pointers, depth int) uint64 {
-	return uint64(pointers)<<32 | uint64(depth)
-}
-
-type walker struct {
-	Result interface{}
-
-	copiers        map[reflect.Type]CopierFunc
-	shallowCopiers map[reflect.Type]struct{}
-	depth          int
-	ignoreDepth    int
-	vals           []reflect.Value
-	cs             []reflect.Value
-
-	// This stores the number of pointers we've walked over, indexed by depth.
-	ps []int
-
-	// If an interface is indirected by a pointer, we need to know the type of
-	// interface to create when creating the new value.  Store the interface
-	// types here, indexed by both the walk depth and the number of pointers
-	// already seen at that depth. Use ifaceKey to calculate the proper uint64
-	// value.
-	ifaceTypes map[uint64]reflect.Type
-
-	// any locks we've taken, indexed by depth
-	locks []sync.Locker
-	// take locks while walking the structure
-	useLocks bool
-}
-
-func (w *walker) Enter(l reflectwalk.Location) error {
-	w.depth++
-
-	// ensure we have enough elements to index via w.depth
-	for w.depth >= len(w.locks) {
-		w.locks = append(w.locks, nil)
-	}
-
-	for len(w.ps) < w.depth+1 {
-		w.ps = append(w.ps, 0)
-	}
-
-	return nil
-}
-
-func (w *walker) Exit(l reflectwalk.Location) error {
-	locker := w.locks[w.depth]
-	w.locks[w.depth] = nil
-	if locker != nil {
-		defer locker.Unlock()
-	}
-
-	// clear out pointers and interfaces as we exit the stack
-	w.ps[w.depth] = 0
-
-	for k := range w.ifaceTypes {
-		mask := uint64(^uint32(0))
-		if k&mask == uint64(w.depth) {
-			delete(w.ifaceTypes, k)
-		}
-	}
-
-	w.depth--
-	if w.ignoreDepth > w.depth {
-		w.ignoreDepth = 0
-	}
-
-	if w.ignoring() {
-		return nil
-	}
-
-	switch l {
-	case reflectwalk.Array:
-		fallthrough
-	case reflectwalk.Map:
-		fallthrough
-	case reflectwalk.Slice:
-		w.replacePointerMaybe()
-
-		// Pop map off our container
-		w.cs = w.cs[:len(w.cs)-1]
-	case reflectwalk.MapValue:
-		// Pop off the key and value
-		mv := w.valPop()
-		mk := w.valPop()
-		m := w.cs[len(w.cs)-1]
-
-		// If mv is the zero value, SetMapIndex deletes the key form the map,
-		// or in this case never adds it. We need to create a properly typed
-		// zero value so that this key can be set.
-		if !mv.IsValid() {
-			mv = reflect.Zero(m.Elem().Type().Elem())
-		}
-		m.Elem().SetMapIndex(mk, mv)
-	case reflectwalk.ArrayElem:
-		// Pop off the value and the index and set it on the array
-		v := w.valPop()
-		i := w.valPop().Interface().(int)
-		if v.IsValid() {
-			a := w.cs[len(w.cs)-1]
-			ae := a.Elem().Index(i) // storing array as pointer on stack - so need Elem() call
-			if ae.CanSet() {
-				ae.Set(v)
-			}
-		}
-	case reflectwalk.SliceElem:
-		// Pop off the value and the index and set it on the slice
-		v := w.valPop()
-		i := w.valPop().Interface().(int)
-		if v.IsValid() {
-			s := w.cs[len(w.cs)-1]
-			se := s.Elem().Index(i)
-			if se.CanSet() {
-				se.Set(v)
-			}
-		}
-	case reflectwalk.Struct:
-		w.replacePointerMaybe()
-
-		// Remove the struct from the container stack
-		w.cs = w.cs[:len(w.cs)-1]
-	case reflectwalk.StructField:
-		// Pop off the value and the field
-		v := w.valPop()
-		f := w.valPop().Interface().(reflect.StructField)
-		if v.IsValid() {
-			s := w.cs[len(w.cs)-1]
-			sf := reflect.Indirect(s).FieldByName(f.Name)
-
-			if sf.CanSet() {
-				sf.Set(v)
-			}
-		}
-	case reflectwalk.WalkLoc:
-		// Clear out the slices for GC
-		w.cs = nil
-		w.vals = nil
-	}
-
-	return nil
-}
-
-func (w *walker) Map(m reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-	w.lock(m)
-
-	// Create the map. If the map itself is nil, then just make a nil map
-	var newMap reflect.Value
-	if m.IsNil() {
-		newMap = reflect.New(m.Type())
-	} else {
-		newMap = wrapPtr(reflect.MakeMap(m.Type()))
-	}
-
-	w.cs = append(w.cs, newMap)
-	w.valPush(newMap)
-	return nil
-}
-
-func (w *walker) MapElem(m, k, v reflect.Value) error {
-	return nil
-}
-
-func (w *walker) PointerEnter(v bool) error {
-	if v {
-		w.ps[w.depth]++
-	}
-	return nil
-}
-
-func (w *walker) PointerExit(v bool) error {
-	if v {
-		w.ps[w.depth]--
-	}
-	return nil
-}
-
-func (w *walker) Pointer(v reflect.Value) error {
-	if _, ok := w.shallowCopiers[v.Type()]; ok {
-		// Shallow copy this value. Use the same logic as primitive, then
-		// return skip.
-		if err := w.Primitive(v); err != nil {
-			return err
-		}
-
-		return reflectwalk.SkipEntry
-	}
-
-	return nil
-}
-
-func (w *walker) Interface(v reflect.Value) error {
-	if !v.IsValid() {
-		return nil
-	}
-	if w.ifaceTypes == nil {
-		w.ifaceTypes = make(map[uint64]reflect.Type)
-	}
-
-	w.ifaceTypes[ifaceKey(w.ps[w.depth], w.depth)] = v.Type()
-	return nil
-}
-
-func (w *walker) Primitive(v reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-	w.lock(v)
-
-	// IsValid verifies the v is non-zero and CanInterface verifies
-	// that we're allowed to read this value (unexported fields).
-	var newV reflect.Value
-	if v.IsValid() && v.CanInterface() {
-		newV = reflect.New(v.Type())
-		newV.Elem().Set(v)
-	}
-
-	w.valPush(newV)
-	w.replacePointerMaybe()
-	return nil
-}
-
-func (w *walker) Slice(s reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-	w.lock(s)
-
-	var newS reflect.Value
-	if s.IsNil() {
-		newS = reflect.New(s.Type())
-	} else {
-		newS = wrapPtr(reflect.MakeSlice(s.Type(), s.Len(), s.Cap()))
-	}
-
-	w.cs = append(w.cs, newS)
-	w.valPush(newS)
-	return nil
-}
-
-func (w *walker) SliceElem(i int, elem reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-
-	// We don't write the slice here because elem might still be
-	// arbitrarily complex. Just record the index and continue on.
-	w.valPush(reflect.ValueOf(i))
-
-	return nil
-}
-
-func (w *walker) Array(a reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-	w.lock(a)
-
-	newA := reflect.New(a.Type())
-
-	w.cs = append(w.cs, newA)
-	w.valPush(newA)
-	return nil
-}
-
-func (w *walker) ArrayElem(i int, elem reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-
-	// We don't write the array here because elem might still be
-	// arbitrarily complex. Just record the index and continue on.
-	w.valPush(reflect.ValueOf(i))
-
-	return nil
-}
-
-func (w *walker) Struct(s reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-	w.lock(s)
-
-	var v reflect.Value
-	if c, ok := w.copiers[s.Type()]; ok {
-		// We have a Copier for this struct, so we use that copier to
-		// get the copy, and we ignore anything deeper than this.
-		w.ignoreDepth = w.depth
-
-		dup, err := c(s.Interface())
-		if err != nil {
-			return err
-		}
-
-		// We need to put a pointer to the value on the value stack,
-		// so allocate a new pointer and set it.
-		v = reflect.New(s.Type())
-		reflect.Indirect(v).Set(reflect.ValueOf(dup))
-	} else {
-		// No copier, we copy ourselves and allow reflectwalk to guide
-		// us deeper into the structure for copying.
-		v = reflect.New(s.Type())
-	}
-
-	// Push the value onto the value stack for setting the struct field,
-	// and add the struct itself to the containers stack in case we walk
-	// deeper so that its own fields can be modified.
-	w.valPush(v)
-	w.cs = append(w.cs, v)
-
-	return nil
-}
-
-func (w *walker) StructField(f reflect.StructField, v reflect.Value) error {
-	if w.ignoring() {
-		return nil
-	}
-
-	// If PkgPath is non-empty, this is a private (unexported) field.
-	// We do not set this unexported since the Go runtime doesn't allow us.
-	if f.PkgPath != "" {
-		return reflectwalk.SkipEntry
-	}
-
-	switch f.Tag.Get(tagKey) {
-	case "shallow":
-		// If we're shallow copying then assign the value directly to the
-		// struct and skip the entry.
-		if v.IsValid() {
-			s := w.cs[len(w.cs)-1]
-			sf := reflect.Indirect(s).FieldByName(f.Name)
-			if sf.CanSet() {
-				sf.Set(v)
-			}
-		}
-
-		return reflectwalk.SkipEntry
-
-	case "ignore":
-		// Do nothing
-		return reflectwalk.SkipEntry
-	}
-
-	// Push the field onto the stack, we'll handle it when we exit
-	// the struct field in Exit...
-	w.valPush(reflect.ValueOf(f))
-
-	return nil
-}
-
-// ignore causes the walker to ignore any more values until we exit this on
-func (w *walker) ignore() {
-	w.ignoreDepth = w.depth
-}
-
-func (w *walker) ignoring() bool {
-	return w.ignoreDepth > 0 && w.depth >= w.ignoreDepth
-}
-
-func (w *walker) pointerPeek() bool {
-	return w.ps[w.depth] > 0
-}
-
-func (w *walker) valPop() reflect.Value {
-	result := w.vals[len(w.vals)-1]
-	w.vals = w.vals[:len(w.vals)-1]
-
-	// If we're out of values, that means we popped everything off. In
-	// this case, we reset the result so the next pushed value becomes
-	// the result.
-	if len(w.vals) == 0 {
-		w.Result = nil
-	}
-
-	return result
-}
-
-func (w *walker) valPush(v reflect.Value) {
-	w.vals = append(w.vals, v)
-
-	// If we haven't set the result yet, then this is the result since
-	// it is the first (outermost) value we're seeing.
-	if w.Result == nil && v.IsValid() {
-		w.Result = v.Interface()
-	}
-}
-
-func (w *walker) replacePointerMaybe() {
-	// Determine the last pointer value. If it is NOT a pointer, then
-	// we need to push that onto the stack.
-	if !w.pointerPeek() {
-		w.valPush(reflect.Indirect(w.valPop()))
-		return
-	}
-
-	v := w.valPop()
-
-	// If the expected type is a pointer to an interface of any depth,
-	// such as *interface{}, **interface{}, etc., then we need to convert
-	// the value "v" from *CONCRETE to *interface{} so types match for
-	// Set.
-	//
-	// Example if v is type *Foo where Foo is a struct, v would become
-	// *interface{} instead. This only happens if we have an interface expectation
-	// at this depth.
-	//
-	// For more info, see GH-16
-	if iType, ok := w.ifaceTypes[ifaceKey(w.ps[w.depth], w.depth)]; ok && iType.Kind() == reflect.Interface {
-		y := reflect.New(iType)           // Create *interface{}
-		y.Elem().Set(reflect.Indirect(v)) // Assign "Foo" to interface{} (dereferenced)
-		v = y                             // v is now typed *interface{} (where *v = Foo)
-	}
-
-	for i := 1; i < w.ps[w.depth]; i++ {
-		if iType, ok := w.ifaceTypes[ifaceKey(w.ps[w.depth]-i, w.depth)]; ok {
-			iface := reflect.New(iType).Elem()
-			iface.Set(v)
-			v = iface
-		}
-
-		p := reflect.New(v.Type())
-		p.Elem().Set(v)
-		v = p
-	}
-
-	w.valPush(v)
-}
-
-// if this value is a Locker, lock it and add it to the locks slice
-func (w *walker) lock(v reflect.Value) {
-	if !w.useLocks {
-		return
-	}
-
-	if !v.IsValid() || !v.CanInterface() {
-		return
-	}
-
-	type rlocker interface {
-		RLocker() sync.Locker
-	}
-
-	var locker sync.Locker
-
-	// We can't call Interface() on a value directly, since that requires
-	// a copy. This is OK, since the pointer to a value which is a sync.Locker
-	// is also a sync.Locker.
-	if v.Kind() == reflect.Ptr {
-		switch l := v.Interface().(type) {
-		case rlocker:
-			// don't lock a mutex directly
-			if _, ok := l.(*sync.RWMutex); !ok {
-				locker = l.RLocker()
-			}
-		case sync.Locker:
-			locker = l
-		}
-	} else if v.CanAddr() {
-		switch l := v.Addr().Interface().(type) {
-		case rlocker:
-			// don't lock a mutex directly
-			if _, ok := l.(*sync.RWMutex); !ok {
-				locker = l.RLocker()
-			}
-		case sync.Locker:
-			locker = l
-		}
-	}
-
-	// still no callable locker
-	if locker == nil {
-		return
-	}
-
-	// don't lock a mutex directly
-	switch locker.(type) {
-	case *sync.Mutex, *sync.RWMutex:
-		return
-	}
-
-	locker.Lock()
-	w.locks[w.depth] = locker
-}
-
-// wrapPtr is a helper that takes v and always make it *v. copystructure
-// stores things internally as pointers until the last moment before unwrapping
-func wrapPtr(v reflect.Value) reflect.Value {
-	if !v.IsValid() {
-		return v
-	}
-	vPtr := reflect.New(v.Type())
-	vPtr.Elem().Set(v)
-	return vPtr
-}
diff --git a/vendor/github.com/mitchellh/reflectwalk/.travis.yml b/vendor/github.com/mitchellh/reflectwalk/.travis.yml
deleted file mode 100644
index 4f2ee4d9..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/.travis.yml
+++ /dev/null
@@ -1 +0,0 @@
-language: go
diff --git a/vendor/github.com/mitchellh/reflectwalk/LICENSE b/vendor/github.com/mitchellh/reflectwalk/LICENSE
deleted file mode 100644
index f9c841a5..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Mitchell Hashimoto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/vendor/github.com/mitchellh/reflectwalk/README.md b/vendor/github.com/mitchellh/reflectwalk/README.md
deleted file mode 100644
index ac82cd2e..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/README.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# reflectwalk
-
-reflectwalk is a Go library for "walking" a value in Go using reflection,
-in the same way a directory tree can be "walked" on the filesystem. Walking
-a complex structure can allow you to do manipulations on unknown structures
-such as those decoded from JSON.
diff --git a/vendor/github.com/mitchellh/reflectwalk/location.go b/vendor/github.com/mitchellh/reflectwalk/location.go
deleted file mode 100644
index 6a7f1761..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/location.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package reflectwalk
-
-//go:generate stringer -type=Location location.go
-
-type Location uint
-
-const (
-	None Location = iota
-	Map
-	MapKey
-	MapValue
-	Slice
-	SliceElem
-	Array
-	ArrayElem
-	Struct
-	StructField
-	WalkLoc
-)
diff --git a/vendor/github.com/mitchellh/reflectwalk/location_string.go b/vendor/github.com/mitchellh/reflectwalk/location_string.go
deleted file mode 100644
index 70760cf4..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/location_string.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Code generated by "stringer -type=Location location.go"; DO NOT EDIT.
-
-package reflectwalk
-
-import "fmt"
-
-const _Location_name = "NoneMapMapKeyMapValueSliceSliceElemArrayArrayElemStructStructFieldWalkLoc"
-
-var _Location_index = [...]uint8{0, 4, 7, 13, 21, 26, 35, 40, 49, 55, 66, 73}
-
-func (i Location) String() string {
-	if i >= Location(len(_Location_index)-1) {
-		return fmt.Sprintf("Location(%d)", i)
-	}
-	return _Location_name[_Location_index[i]:_Location_index[i+1]]
-}
diff --git a/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go b/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go
deleted file mode 100644
index 7fee7b05..00000000
--- a/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go
+++ /dev/null
@@ -1,420 +0,0 @@
-// reflectwalk is a package that allows you to "walk" complex structures
-// similar to how you may "walk" a filesystem: visiting every element one
-// by one and calling callback functions allowing you to handle and manipulate
-// those elements.
-package reflectwalk
-
-import (
-	"errors"
-	"reflect"
-)
-
-// PrimitiveWalker implementations are able to handle primitive values
-// within complex structures. Primitive values are numbers, strings,
-// booleans, funcs, chans.
-//
-// These primitive values are often members of more complex
-// structures (slices, maps, etc.) that are walkable by other interfaces.
-type PrimitiveWalker interface {
-	Primitive(reflect.Value) error
-}
-
-// InterfaceWalker implementations are able to handle interface values as they
-// are encountered during the walk.
-type InterfaceWalker interface {
-	Interface(reflect.Value) error
-}
-
-// MapWalker implementations are able to handle individual elements
-// found within a map structure.
-type MapWalker interface {
-	Map(m reflect.Value) error
-	MapElem(m, k, v reflect.Value) error
-}
-
-// SliceWalker implementations are able to handle slice elements found
-// within complex structures.
-type SliceWalker interface {
-	Slice(reflect.Value) error
-	SliceElem(int, reflect.Value) error
-}
-
-// ArrayWalker implementations are able to handle array elements found
-// within complex structures.
-type ArrayWalker interface {
-	Array(reflect.Value) error
-	ArrayElem(int, reflect.Value) error
-}
-
-// StructWalker is an interface that has methods that are called for
-// structs when a Walk is done.
-type StructWalker interface {
-	Struct(reflect.Value) error
-	StructField(reflect.StructField, reflect.Value) error
-}
-
-// EnterExitWalker implementations are notified before and after
-// they walk deeper into complex structures (into struct fields,
-// into slice elements, etc.)
-type EnterExitWalker interface {
-	Enter(Location) error
-	Exit(Location) error
-}
-
-// PointerWalker implementations are notified when the value they're
-// walking is a pointer or not. Pointer is called for _every_ value whether
-// it is a pointer or not.
-type PointerWalker interface {
-	PointerEnter(bool) error
-	PointerExit(bool) error
-}
-
-// PointerValueWalker implementations are notified with the value of
-// a particular pointer when a pointer is walked. Pointer is called
-// right before PointerEnter.
-type PointerValueWalker interface {
-	Pointer(reflect.Value) error
-}
-
-// SkipEntry can be returned from walk functions to skip walking
-// the value of this field. This is only valid in the following functions:
-//
-//   - Struct: skips all fields from being walked
-//   - StructField: skips walking the struct value
-//
-var SkipEntry = errors.New("skip this entry")
-
-// Walk takes an arbitrary value and an interface and traverses the
-// value, calling callbacks on the interface if they are supported.
-// The interface should implement one or more of the walker interfaces
-// in this package, such as PrimitiveWalker, StructWalker, etc.
-func Walk(data, walker interface{}) (err error) {
-	v := reflect.ValueOf(data)
-	ew, ok := walker.(EnterExitWalker)
-	if ok {
-		err = ew.Enter(WalkLoc)
-	}
-
-	if err == nil {
-		err = walk(v, walker)
-	}
-
-	if ok && err == nil {
-		err = ew.Exit(WalkLoc)
-	}
-
-	return
-}
-
-func walk(v reflect.Value, w interface{}) (err error) {
-	// Determine if we're receiving a pointer and if so notify the walker.
-	// The logic here is convoluted but very important (tests will fail if
-	// almost any part is changed). I will try to explain here.
-	//
-	// First, we check if the value is an interface, if so, we really need
-	// to check the interface's VALUE to see whether it is a pointer.
-	//
-	// Check whether the value is then a pointer. If so, then set pointer
-	// to true to notify the user.
-	//
-	// If we still have a pointer or an interface after the indirections, then
-	// we unwrap another level
-	//
-	// At this time, we also set "v" to be the dereferenced value. This is
-	// because once we've unwrapped the pointer we want to use that value.
-	pointer := false
-	pointerV := v
-
-	for {
-		if pointerV.Kind() == reflect.Interface {
-			if iw, ok := w.(InterfaceWalker); ok {
-				if err = iw.Interface(pointerV); err != nil {
-					return
-				}
-			}
-
-			pointerV = pointerV.Elem()
-		}
-
-		if pointerV.Kind() == reflect.Ptr {
-			if pw, ok := w.(PointerValueWalker); ok {
-				if err = pw.Pointer(pointerV); err != nil {
-					if err == SkipEntry {
-						// Skip the rest of this entry but clear the error
-						return nil
-					}
-
-					return
-				}
-			}
-
-			pointer = true
-			v = reflect.Indirect(pointerV)
-		}
-		if pw, ok := w.(PointerWalker); ok {
-			if err = pw.PointerEnter(pointer); err != nil {
-				return
-			}
-
-			defer func(pointer bool) {
-				if err != nil {
-					return
-				}
-
-				err = pw.PointerExit(pointer)
-			}(pointer)
-		}
-
-		if pointer {
-			pointerV = v
-		}
-		pointer = false
-
-		// If we still have a pointer or interface we have to indirect another level.
-		switch pointerV.Kind() {
-		case reflect.Ptr, reflect.Interface:
-			continue
-		}
-		break
-	}
-
-	// We preserve the original value here because if it is an interface
-	// type, we want to pass that directly into the walkPrimitive, so that
-	// we can set it.
-	originalV := v
-	if v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-
-	k := v.Kind()
-	if k >= reflect.Int && k <= reflect.Complex128 {
-		k = reflect.Int
-	}
-
-	switch k {
-	// Primitives
-	case reflect.Bool, reflect.Chan, reflect.Func, reflect.Int, reflect.String, reflect.Invalid:
-		err = walkPrimitive(originalV, w)
-		return
-	case reflect.Map:
-		err = walkMap(v, w)
-		return
-	case reflect.Slice:
-		err = walkSlice(v, w)
-		return
-	case reflect.Struct:
-		err = walkStruct(v, w)
-		return
-	case reflect.Array:
-		err = walkArray(v, w)
-		return
-	default:
-		panic("unsupported type: " + k.String())
-	}
-}
-
-func walkMap(v reflect.Value, w interface{}) error {
-	ew, ewok := w.(EnterExitWalker)
-	if ewok {
-		ew.Enter(Map)
-	}
-
-	if mw, ok := w.(MapWalker); ok {
-		if err := mw.Map(v); err != nil {
-			return err
-		}
-	}
-
-	for _, k := range v.MapKeys() {
-		kv := v.MapIndex(k)
-
-		if mw, ok := w.(MapWalker); ok {
-			if err := mw.MapElem(v, k, kv); err != nil {
-				return err
-			}
-		}
-
-		ew, ok := w.(EnterExitWalker)
-		if ok {
-			ew.Enter(MapKey)
-		}
-
-		if err := walk(k, w); err != nil {
-			return err
-		}
-
-		if ok {
-			ew.Exit(MapKey)
-			ew.Enter(MapValue)
-		}
-
-		// get the map value again as it may have changed in the MapElem call
-		if err := walk(v.MapIndex(k), w); err != nil {
-			return err
-		}
-
-		if ok {
-			ew.Exit(MapValue)
-		}
-	}
-
-	if ewok {
-		ew.Exit(Map)
-	}
-
-	return nil
-}
-
-func walkPrimitive(v reflect.Value, w interface{}) error {
-	if pw, ok := w.(PrimitiveWalker); ok {
-		return pw.Primitive(v)
-	}
-
-	return nil
-}
-
-func walkSlice(v reflect.Value, w interface{}) (err error) {
-	ew, ok := w.(EnterExitWalker)
-	if ok {
-		ew.Enter(Slice)
-	}
-
-	if sw, ok := w.(SliceWalker); ok {
-		if err := sw.Slice(v); err != nil {
-			return err
-		}
-	}
-
-	for i := 0; i < v.Len(); i++ {
-		elem := v.Index(i)
-
-		if sw, ok := w.(SliceWalker); ok {
-			if err := sw.SliceElem(i, elem); err != nil {
-				return err
-			}
-		}
-
-		ew, ok := w.(EnterExitWalker)
-		if ok {
-			ew.Enter(SliceElem)
-		}
-
-		if err := walk(elem, w); err != nil {
-			return err
-		}
-
-		if ok {
-			ew.Exit(SliceElem)
-		}
-	}
-
-	ew, ok = w.(EnterExitWalker)
-	if ok {
-		ew.Exit(Slice)
-	}
-
-	return nil
-}
-
-func walkArray(v reflect.Value, w interface{}) (err error) {
-	ew, ok := w.(EnterExitWalker)
-	if ok {
-		ew.Enter(Array)
-	}
-
-	if aw, ok := w.(ArrayWalker); ok {
-		if err := aw.Array(v); err != nil {
-			return err
-		}
-	}
-
-	for i := 0; i < v.Len(); i++ {
-		elem := v.Index(i)
-
-		if aw, ok := w.(ArrayWalker); ok {
-			if err := aw.ArrayElem(i, elem); err != nil {
-				return err
-			}
-		}
-
-		ew, ok := w.(EnterExitWalker)
-		if ok {
-			ew.Enter(ArrayElem)
-		}
-
-		if err := walk(elem, w); err != nil {
-			return err
-		}
-
-		if ok {
-			ew.Exit(ArrayElem)
-		}
-	}
-
-	ew, ok = w.(EnterExitWalker)
-	if ok {
-		ew.Exit(Array)
-	}
-
-	return nil
-}
-
-func walkStruct(v reflect.Value, w interface{}) (err error) {
-	ew, ewok := w.(EnterExitWalker)
-	if ewok {
-		ew.Enter(Struct)
-	}
-
-	skip := false
-	if sw, ok := w.(StructWalker); ok {
-		err = sw.Struct(v)
-		if err == SkipEntry {
-			skip = true
-			err = nil
-		}
-		if err != nil {
-			return
-		}
-	}
-
-	if !skip {
-		vt := v.Type()
-		for i := 0; i < vt.NumField(); i++ {
-			sf := vt.Field(i)
-			f := v.FieldByIndex([]int{i})
-
-			if sw, ok := w.(StructWalker); ok {
-				err = sw.StructField(sf, f)
-
-				// SkipEntry just pretends this field doesn't even exist
-				if err == SkipEntry {
-					continue
-				}
-
-				if err != nil {
-					return
-				}
-			}
-
-			ew, ok := w.(EnterExitWalker)
-			if ok {
-				ew.Enter(StructField)
-			}
-
-			err = walk(f, w)
-			if err != nil {
-				return
-			}
-
-			if ok {
-				ew.Exit(StructField)
-			}
-		}
-	}
-
-	if ewok {
-		ew.Exit(Struct)
-	}
-
-	return nil
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 2a5c5761..598e5733 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -131,7 +131,7 @@ github.com/cenkalti/backoff/v4
 # github.com/cespare/xxhash/v2 v2.2.0
 ## explicit; go 1.11
 github.com/cespare/xxhash/v2
-# github.com/compose-spec/compose-go/v2 v2.1.2
+# github.com/compose-spec/compose-go/v2 v2.1.3
 ## explicit; go 1.21
 github.com/compose-spec/compose-go/v2/cli
 github.com/compose-spec/compose-go/v2/consts
@@ -508,17 +508,11 @@ github.com/matttproud/golang_protobuf_extensions/pbutil
 # github.com/miekg/pkcs11 v1.1.1
 ## explicit; go 1.12
 github.com/miekg/pkcs11
-# github.com/mitchellh/copystructure v1.2.0
-## explicit; go 1.15
-github.com/mitchellh/copystructure
 # github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7
 ## explicit
 github.com/mitchellh/go-wordwrap
 # github.com/mitchellh/mapstructure v1.5.0
 ## explicit; go 1.14
-# github.com/mitchellh/reflectwalk v1.0.2
-## explicit
-github.com/mitchellh/reflectwalk
 # github.com/moby/buildkit v0.14.1
 ## explicit; go 1.21
 github.com/moby/buildkit/api/services/control