vendor: delete

14 files changed, 0 insertions, 1677 deletions

diff --git a/vendor/github.com/ettle/strcase/.gitignore b/vendor/github.com/ettle/strcase/.gitignore
deleted file mode 100644
index 54bc1fbff..000000000
--- a/vendor/github.com/ettle/strcase/.gitignore
+++ /dev/null
@@ -1,18 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# CPU and memory profiles
-*.prof
-
-# Dependency directories
-vendor/
diff --git a/vendor/github.com/ettle/strcase/.golangci.yml b/vendor/github.com/ettle/strcase/.golangci.yml
deleted file mode 100644
index b7ce85d42..000000000
--- a/vendor/github.com/ettle/strcase/.golangci.yml
+++ /dev/null
@@ -1,82 +0,0 @@
-linters-settings:
-  dupl:
-    threshold: 100
-  gocyclo:
-    min-complexity: 15
-  gocritic:
-    enabled-tags:
-      - diagnostic
-      - experimental
-      - opinionated
-      - performance
-      - style
-    disabled-checks:
-      - ifElseChain
-      - whyNoLint
-      - wrapperFunc
-  govet:
-    check-shadowing: true
-  lll:
-    line-length: 140
-  maligned:
-    suggest-new: true
-  misspell:
-    locale: US
-  nolintlint:
-    allow-leading-space: false
-    allow-unused: false
-    require-specific: true
-
-    require-explanation: true
-    allow-no-explanation:
-      - gocyclo
-
-linters:
-  disable-all: true
-  enable:
-    - bodyclose
-    - depguard
-    - dogsled
-    - dupl
-    - errcheck
-    - gochecknoinits
-    - gocritic
-    - gocyclo
-    - gofmt
-    - goimports
-    - goprintffuncname
-    - gosec
-    - gosimple
-    - govet
-    - ineffassign
-    - lll
-    - misspell
-    - nakedret
-    - nolintlint
-    - revive
-    - rowserrcheck
-    - staticcheck
-    - stylecheck
-    - typecheck
-    - unconvert
-    - unparam
-    - unused
-    - whitespace
-
-  # don't enable:
-  # - asciicheck
-  # - gochecknoglobals
-  # - gocognit
-  # - godot
-  # - godox
-  # - goerr113
-  # - maligned
-  # - nestif
-  # - prealloc
-  # - testpackage
-  # - wsl
-
-issues:
-  exclude-use-default: false
-  max-issues-per-linter: 0
-  max-same-issues: 0
diff --git a/vendor/github.com/ettle/strcase/.readme.tmpl b/vendor/github.com/ettle/strcase/.readme.tmpl
deleted file mode 100644
index 4d7a894f0..000000000
--- a/vendor/github.com/ettle/strcase/.readme.tmpl
+++ /dev/null
@@ -1,80 +0,0 @@
-{{with .PDoc}}
-# Go Strcase
-
-[![Go Report Card](https://goreportcard.com/badge/github.com/ettle/strcase)](https://goreportcard.com/report/github.com/ettle/strcase)
-[![Coverage](http://gocover.io/_badge/github.com/ettle/strcase?0)](http://gocover.io/github.com/ettle/strcase)
-[![GoDoc](https://godoc.org/github.com/ettle/strcase?status.svg)](https://pkg.go.dev/github.com/ettle/strcase)
-
-Convert strings to `snake_case`, `camelCase`, `PascalCase`, `kebab-case` and more! Supports Go initialisms, customization, and Unicode.
-
-`import "{{.ImportPath}}"`
-
-## <a name="pkg-overview">Overview</a>
-{{comment_md .Doc}}
-{{example_html $ ""}}
-
-## <a name="pkg-index">Index</a>{{if .Consts}}
-* [Constants](#pkg-constants){{end}}{{if .Vars}}
-* [Variables](#pkg-variables){{end}}{{- range .Funcs -}}{{$name_html := html .Name}}
-* [{{node_html $ .Decl false | sanitize}}](#func-{{$name_html}}){{- end}}{{- range .Types}}{{$tname_html := html .Name}}
-* [type {{$tname_html}}](#type-{{$tname_html}}){{- range .Funcs}}{{$name_html := html .Name}}
-  * [{{node_html $ .Decl false | sanitize}}](#func-{{$name_html}}){{- end}}{{- range .Methods}}{{$name_html := html .Name}}
-  * [{{node_html $ .Decl false | sanitize}}](#type-{{$tname_html}}.{{$name_html}}){{- end}}{{- end}}{{- if $.Notes}}{{- range $marker, $item := $.Notes}}
-* [{{noteTitle $marker | html}}s](#pkg-note-{{$marker}}){{end}}{{end}}
-{{if $.Examples}}
-#### <a name="pkg-examples">Examples</a>{{- range $.Examples}}
-* [{{example_name .Name}}](#example_{{.Name}}){{- end}}{{- end}}
-
-{{with .Consts}}## <a name="pkg-constants">Constants</a>
-{{range .}}{{node $ .Decl | pre}}
-{{comment_md .Doc}}{{end}}{{end}}
-{{with .Vars}}## <a name="pkg-variables">Variables</a>
-{{range .}}{{node $ .Decl | pre}}
-{{comment_md .Doc}}{{end}}{{end}}
-
-{{range .Funcs}}{{$name_html := html .Name}}## <a name="{{$name_html}}">func</a> [{{$name_html}}]({{gh_url $ .Decl}})
-{{node $ .Decl | pre}}
-{{comment_md .Doc}}
-{{example_html $ .Name}}
-{{callgraph_html $ "" .Name}}{{end}}
-{{range .Types}}{{$tname := .Name}}{{$tname_html := html .Name}}## <a name="{{$tname_html}}">type</a> [{{$tname_html}}]({{gh_url $ .Decl}})
-{{node $ .Decl | pre}}
-{{comment_md .Doc}}{{range .Consts}}
-{{node $ .Decl | pre }}
-{{comment_md .Doc}}{{end}}{{range .Vars}}
-{{node $ .Decl | pre }}
-{{comment_md .Doc}}{{end}}
-
-{{example_html $ $tname}}
-{{implements_html $ $tname}}
-{{methodset_html $ $tname}}
-
-{{range .Funcs}}{{$name_html := html .Name}}### <a name="{{$name_html}}">func</a> [{{$name_html}}]({{gh_url $ .Decl}})
-{{node $ .Decl | pre}}
-{{comment_md .Doc}}
-{{example_html $ .Name}}{{end}}
-{{callgraph_html $ "" .Name}}
-
-{{range .Methods}}{{$name_html := html .Name}}### <a name="{{$tname_html}}.{{$name_html}}">func</a> ({{md .Recv}}) [{{$name_html}}]({{gh_url $ .Decl}})
-{{node $ .Decl | pre}}
-{{comment_md .Doc}}
-{{$name := printf "%s_%s" $tname .Name}}{{example_html $ $name}}
-{{callgraph_html $ .Recv .Name}}
-{{end}}{{end}}{{end}}
-
-{{with $.Notes}}
-{{range $marker, $content := .}}
-## <a name="pkg-note-{{$marker}}">{{noteTitle $marker | html}}s
-<ul style="list-style: none; padding: 0;">
-{{range .}}
-<li><a href="{{gh_url $ .}}">&#x261e;</a> {{html .Body}}</li>
-{{end}}
-</ul>
-{{end}}
-{{end}}
-{{if .Dirs}}
-## <a name="Subdirectories">Subdirectories</a>
-{{range $.Dirs.List}}
-{{indent .Depth}}* [{{.Name | html}}]({{print "./" .Path}}){{if .Synopsis}} {{ .Synopsis}}{{end -}}
-{{end}}
-{{end}}
diff --git a/vendor/github.com/ettle/strcase/LICENSE b/vendor/github.com/ettle/strcase/LICENSE
deleted file mode 100644
index 4f0116be2..000000000
--- a/vendor/github.com/ettle/strcase/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Liyan David Chang
-
-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/ettle/strcase/Makefile b/vendor/github.com/ettle/strcase/Makefile
deleted file mode 100644
index ac98b4aa5..000000000
--- a/vendor/github.com/ettle/strcase/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-.PHONY: benchmark docs lint test
-
-docs:
-	which godoc2ghmd || go get github.com/DevotedHealth/godoc2ghmd
-	godoc2ghmd -template .readme.tmpl github.com/ettle/strcase > README.md
-	go mod tidy
-
-test:
-	go test -cover ./...
-
-lint:
-	which golangci-lint || go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.50.1
-	golangci-lint run
-	golangci-lint run benchmark/*.go
-	go mod tidy
-
-benchmark:
-	cd benchmark && go test -bench=. -test.benchmem
-	go mod tidy
diff --git a/vendor/github.com/ettle/strcase/README.md b/vendor/github.com/ettle/strcase/README.md
deleted file mode 100644
index a984da80d..000000000
--- a/vendor/github.com/ettle/strcase/README.md
+++ /dev/null
@@ -1,553 +0,0 @@
-
-# Go Strcase
-
-[![Go Report Card](https://goreportcard.com/badge/github.com/ettle/strcase)](https://goreportcard.com/report/github.com/ettle/strcase)
-[![Coverage](http://gocover.io/_badge/github.com/ettle/strcase?0)](http://gocover.io/github.com/ettle/strcase)
-[![GoDoc](https://godoc.org/github.com/ettle/strcase?status.svg)](https://pkg.go.dev/github.com/ettle/strcase)
-
-Convert strings to `snake_case`, `camelCase`, `PascalCase`, `kebab-case` and more! Supports Go initialisms, customization, and Unicode.
-
-`import "github.com/ettle/strcase"`
-
-## <a name="pkg-overview">Overview</a>
-Package strcase is a package for converting strings into various word cases
-(e.g. snake_case, camelCase)
-
-
-	go get -u github.com/ettle/strcase
-
-Example usage
-
-
-	strcase.ToSnake("Hello World")     // hello_world
-	strcase.ToSNAKE("Hello World")     // HELLO_WORLD
-	
-	strcase.ToKebab("helloWorld")      // hello-world
-	strcase.ToKEBAB("helloWorld")      // HELLO-WORLD
-	
-	strcase.ToPascal("hello-world")    // HelloWorld
-	strcase.ToCamel("hello-world")     // helloWorld
-	
-	// Handle odd cases
-	strcase.ToSnake("FOOBar")          // foo_bar
-	
-	// Support Go initialisms
-	strcase.ToGoPascal("http_response") // HTTPResponse
-	
-	// Specify case and delimiter
-	strcase.ToCase("HelloWorld", strcase.UpperCase, '.') // HELLO.WORLD
-
-## Why this package
-
-String strcase is pretty straight forward and there are a number of methods to
-do it. This package is fully featured, more customizable, better tested, and
-faster than other packages and what you would probably whip up yourself.
-
-### Unicode support
-
-We work for with unicode strings and pay very little performance penalty for it
-as we optimized for the common use case of ASCII only strings.
-
-### Customization
-
-You can create a custom caser that changes the behavior to what you want. This
-customization also reduces the pressure for us to change the default behavior
-which means that things are more stable for everyone involved.  The goal is to
-make the common path easy and fast, while making the uncommon path possible.
-
-
-	 c := NewCaser(
-		// Use Go's default initialisms e.g. ID, HTML
-	 	true,
-		// Override initialisms (e.g. don't initialize HTML but initialize SSL
-	 	map[string]bool{"SSL": true, "HTML": false},
-		// Write your own custom SplitFn
-		//
-	 	NewSplitFn(
-	 		[]rune{'*', '.', ','},
-	 		SplitCase,
-	 		SplitAcronym,
-	 		PreserveNumberFormatting,
-	 		SplitBeforeNumber,
-	 		SplitAfterNumber,
-	 	))
-	 assert.Equal(t, "http_200", c.ToSnake("http200"))
-
-### Initialism support
-
-By default, we use the golint intialisms list. You can customize and override
-the initialisms if you wish to add additional ones, such as "SSL" or "CMS" or
-domain specific ones to your industry.
-
-
-	ToGoPascal("http_response") // HTTPResponse
-	ToGoSnake("http_response") // HTTP_response
-
-### Test coverage
-
-We have a wide ranging test suite to make sure that we understand our behavior.
-Test coverage isn't everything, but we aim for 100% coverage.
-
-### Fast
-
-Optimized to reduce memory allocations with Builder. Benchmarked and optimized
-around common cases.
-
-We're on par with the fastest packages (that have less features) and much
-faster than others. We also benchmarked against code snippets. Using string
-builders to reduce memory allocation and reordering boolean checks for the
-common cases have a large performance impact.
-
-Hopefully I was fair to each library and happy to rerun benchmarks differently
-or reword my commentary based on suggestions or updates.
-
-
-	// This package - faster then almost all libraries
-	// Initialisms are more complicated and slightly slower, but still fast
-	BenchmarkToTitle-96                      9617142               125.7 ns/op            16 B/op          1 allocs/op
-	BenchmarkToSnake-96                     10659919               120.7 ns/op            16 B/op          1 allocs/op
-	BenchmarkToSNAKE-96                      9018282               126.4 ns/op            16 B/op          1 allocs/op
-	BenchmarkToGoSnake-96                    4903687               254.5 ns/op            26 B/op          4 allocs/op
-	BenchmarkToCustomCaser-96                4434489               265.0 ns/op            28 B/op          4 allocs/op
-	
-	// Segment has very fast snake case and camel case libraries
-	// No features or customization, but very very fast
-	BenchmarkSegment-96                     33625734                35.54 ns/op           16 B/op          1 allocs/op
-	
-	// Iancoleman has gotten some performance improvements, but remains
-	// without unicode support and lacks fine-grained customization
-	BenchmarkToSnakeIan-96                  13141522                92.99 ns/op           16 B/op          1 allocs/op
-	
-	// Stdlib strings.Title is deprecated; using golang.org/x.text
-	BenchmarkGolangOrgXTextCases-96          4665676               262.5 ns/op           272 B/op          2 allocs/op
-	
-	// Other libraries or code snippets
-	// - Most are slower, by up to an order of magnitude
-	// - No support for initialisms or customization
-	// - Some generate only camelCase or snake_case
-	// - Many lack unicode support
-	BenchmarkToSnakeStoewer-96               8095468               148.9 ns/op            64 B/op          2 allocs/op
-	// Copying small rune arrays is slow
-	BenchmarkToSnakeSiongui-96               2912593               401.7 ns/op           112 B/op         19 allocs/op
-	BenchmarkGoValidator-96                  3493800               342.6 ns/op           184 B/op          9 allocs/op
-	// String alloction is slow
-	BenchmarkToSnakeFatih-96                 1282648               945.1 ns/op           616 B/op         26 allocs/op
-	// Regexp is slow
-	BenchmarkToSnakeGolangPrograms-96         778674              1495 ns/op             227 B/op         11 allocs/op
-	
-	// These results aren't a surprise - my initial version of this library was
-	// painfully slow. I think most of us, without spending some time with
-	// profilers and benchmarks, would write also something on the slower side.
-
-### Zero dependencies
-
-That's right - zero. We only import the Go standard library. No hassles with
-dependencies, licensing, security alerts.
-
-## Why not this package
-
-If every nanosecond matters and this is used in a tight loop, use segment.io's
-libraries (<a href="https://github.com/segmentio/go-snakecase">https://github.com/segmentio/go-snakecase</a> and
-<a href="https://github.com/segmentio/go-camelcase">https://github.com/segmentio/go-camelcase</a>). They lack features, but make up for
-it by being blazing fast.
-
-## Migrating from other packages
-
-If you are migrating from from another package, you may find slight differences
-in output. To reduce the delta, you may find it helpful to use the following
-custom casers to mimic the behavior of the other package.
-
-
-	// From <a href="https://github.com/iancoleman/strcase">https://github.com/iancoleman/strcase</a>
-	var c = NewCaser(false, nil, NewSplitFn([]rune{'_', '-', '.'}, SplitCase, SplitAcronym, SplitBeforeNumber))
-	
-	// From <a href="https://github.com/stoewer/go-strcase">https://github.com/stoewer/go-strcase</a>
-	var c = NewCaser(false, nil, NewSplitFn([]rune{'_', '-'}, SplitCase), SplitAcronym)
-
-
-
-
-## <a name="pkg-index">Index</a>
-* [func ToCamel(s string) string](#func-ToCamel)
-* [func ToCase(s string, wordCase WordCase, delimiter rune) string](#func-ToCase)
-* [func ToGoCamel(s string) string](#func-ToGoCamel)
-* [func ToGoCase(s string, wordCase WordCase, delimiter rune) string](#func-ToGoCase)
-* [func ToGoKebab(s string) string](#func-ToGoKebab)
-* [func ToGoPascal(s string) string](#func-ToGoPascal)
-* [func ToGoSnake(s string) string](#func-ToGoSnake)
-* [func ToKEBAB(s string) string](#func-ToKEBAB)
-* [func ToKebab(s string) string](#func-ToKebab)
-* [func ToPascal(s string) string](#func-ToPascal)
-* [func ToSNAKE(s string) string](#func-ToSNAKE)
-* [func ToSnake(s string) string](#func-ToSnake)
-* [type Caser](#type-Caser)
-  * [func NewCaser(goInitialisms bool, initialismOverrides map[string]bool, splitFn SplitFn) *Caser](#func-NewCaser)
-  * [func (c *Caser) ToCamel(s string) string](#type-Caser.ToCamel)
-  * [func (c *Caser) ToCase(s string, wordCase WordCase, delimiter rune) string](#type-Caser.ToCase)
-  * [func (c *Caser) ToKEBAB(s string) string](#type-Caser.ToKEBAB)
-  * [func (c *Caser) ToKebab(s string) string](#type-Caser.ToKebab)
-  * [func (c *Caser) ToPascal(s string) string](#type-Caser.ToPascal)
-  * [func (c *Caser) ToSNAKE(s string) string](#type-Caser.ToSNAKE)
-  * [func (c *Caser) ToSnake(s string) string](#type-Caser.ToSnake)
-* [type SplitAction](#type-SplitAction)
-* [type SplitFn](#type-SplitFn)
-  * [func NewSplitFn(delimiters []rune, splitOptions ...SplitOption) SplitFn](#func-NewSplitFn)
-* [type SplitOption](#type-SplitOption)
-* [type WordCase](#type-WordCase)
-
-
-
-
-
-## <a name="ToCamel">func</a> [ToCamel](./strcase.go#L57)
-``` go
-func ToCamel(s string) string
-```
-ToCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-Also known as lowerCamelCase or mixedCase.
-
-
-
-## <a name="ToCase">func</a> [ToCase](./strcase.go#L72)
-``` go
-func ToCase(s string, wordCase WordCase, delimiter rune) string
-```
-ToCase returns words in given case and delimiter.
-
-
-
-## <a name="ToGoCamel">func</a> [ToGoCamel](./strcase.go#L67)
-``` go
-func ToGoCamel(s string) string
-```
-ToGoCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-Also known as lowerCamelCase or mixedCase.
-
-Respects Go's common initialisms, but first word remains lowercased which is
-important for code generator use cases (e.g. toJson -> toJSON, httpResponse
--> httpResponse).
-
-
-
-## <a name="ToGoCase">func</a> [ToGoCase](./strcase.go#L79)
-``` go
-func ToGoCase(s string, wordCase WordCase, delimiter rune) string
-```
-ToGoCase returns words in given case and delimiter.
-
-Respects Go's common initialisms (e.g. httpResponse -> HTTPResponse).
-
-
-
-## <a name="ToGoKebab">func</a> [ToGoKebab](./strcase.go#L31)
-``` go
-func ToGoKebab(s string) string
-```
-ToGoKebab returns words in kebab-case (lower case words with dashes).
-Also known as dash-case.
-
-Respects Go's common initialisms (e.g. http-response -> HTTP-response).
-
-
-
-## <a name="ToGoPascal">func</a> [ToGoPascal](./strcase.go#L51)
-``` go
-func ToGoPascal(s string) string
-```
-ToGoPascal returns words in PascalCase (capitalized words concatenated together).
-Also known as UpperPascalCase.
-
-Respects Go's common initialisms (e.g. HttpResponse -> HTTPResponse).
-
-
-
-## <a name="ToGoSnake">func</a> [ToGoSnake](./strcase.go#L11)
-``` go
-func ToGoSnake(s string) string
-```
-ToGoSnake returns words in snake_case (lower case words with underscores).
-
-Respects Go's common initialisms (e.g. http_response -> HTTP_response).
-
-
-
-## <a name="ToKEBAB">func</a> [ToKEBAB](./strcase.go#L37)
-``` go
-func ToKEBAB(s string) string
-```
-ToKEBAB returns words in KEBAB-CASE (upper case words with dashes).
-Also known as SCREAMING-KEBAB-CASE or SCREAMING-DASH-CASE.
-
-
-
-## <a name="ToKebab">func</a> [ToKebab](./strcase.go#L23)
-``` go
-func ToKebab(s string) string
-```
-ToKebab returns words in kebab-case (lower case words with dashes).
-Also known as dash-case.
-
-
-
-## <a name="ToPascal">func</a> [ToPascal](./strcase.go#L43)
-``` go
-func ToPascal(s string) string
-```
-ToPascal returns words in PascalCase (capitalized words concatenated together).
-Also known as UpperPascalCase.
-
-
-
-## <a name="ToSNAKE">func</a> [ToSNAKE](./strcase.go#L17)
-``` go
-func ToSNAKE(s string) string
-```
-ToSNAKE returns words in SNAKE_CASE (upper case words with underscores).
-Also known as SCREAMING_SNAKE_CASE or UPPER_CASE.
-
-
-
-## <a name="ToSnake">func</a> [ToSnake](./strcase.go#L4)
-``` go
-func ToSnake(s string) string
-```
-ToSnake returns words in snake_case (lower case words with underscores).
-
-
-
-
-## <a name="Caser">type</a> [Caser](./caser.go#L4-L7)
-``` go
-type Caser struct {
-    // contains filtered or unexported fields
-}
-
-```
-Caser allows for customization of parsing and intialisms
-
-
-
-
-
-
-
-### <a name="NewCaser">func</a> [NewCaser](./caser.go#L24)
-``` go
-func NewCaser(goInitialisms bool, initialismOverrides map[string]bool, splitFn SplitFn) *Caser
-```
-NewCaser returns a configured Caser.
-
-A Caser should be created when you want fine grained control over how the words are split.
-
-
-	Notes on function arguments
-	
-	goInitialisms: Whether to use Golint's intialisms
-	
-	initialismOverrides: A mapping of extra initialisms
-	Keys must be in ALL CAPS. Merged with Golint's if goInitialisms is set.
-	Setting a key to false will override Golint's.
-	
-	splitFn: How to separate words
-	Override the default split function. Consider using NewSplitFn to
-	configure one instead of writing your own.
-
-
-
-
-
-### <a name="Caser.ToCamel">func</a> (\*Caser) [ToCamel](./caser.go#L80)
-``` go
-func (c *Caser) ToCamel(s string) string
-```
-ToCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-Also known as lowerCamelCase or mixedCase.
-
-
-
-
-### <a name="Caser.ToCase">func</a> (\*Caser) [ToCase](./caser.go#L85)
-``` go
-func (c *Caser) ToCase(s string, wordCase WordCase, delimiter rune) string
-```
-ToCase returns words with a given case and delimiter.
-
-
-
-
-### <a name="Caser.ToKEBAB">func</a> (\*Caser) [ToKEBAB](./caser.go#L68)
-``` go
-func (c *Caser) ToKEBAB(s string) string
-```
-ToKEBAB returns words in KEBAB-CASE (upper case words with dashes).
-Also known as SCREAMING-KEBAB-CASE or SCREAMING-DASH-CASE.
-
-
-
-
-### <a name="Caser.ToKebab">func</a> (\*Caser) [ToKebab](./caser.go#L62)
-``` go
-func (c *Caser) ToKebab(s string) string
-```
-ToKebab returns words in kebab-case (lower case words with dashes).
-Also known as dash-case.
-
-
-
-
-### <a name="Caser.ToPascal">func</a> (\*Caser) [ToPascal](./caser.go#L74)
-``` go
-func (c *Caser) ToPascal(s string) string
-```
-ToPascal returns words in PascalCase (capitalized words concatenated together).
-Also known as UpperPascalCase.
-
-
-
-
-### <a name="Caser.ToSNAKE">func</a> (\*Caser) [ToSNAKE](./caser.go#L56)
-``` go
-func (c *Caser) ToSNAKE(s string) string
-```
-ToSNAKE returns words in SNAKE_CASE (upper case words with underscores).
-Also known as SCREAMING_SNAKE_CASE or UPPER_CASE.
-
-
-
-
-### <a name="Caser.ToSnake">func</a> (\*Caser) [ToSnake](./caser.go#L50)
-``` go
-func (c *Caser) ToSnake(s string) string
-```
-ToSnake returns words in snake_case (lower case words with underscores).
-
-
-
-
-## <a name="SplitAction">type</a> [SplitAction](./split.go#L111)
-``` go
-type SplitAction int
-```
-SplitAction defines if and how to split a string
-
-
-``` go
-const (
-    // Noop - Continue to next character
-    Noop SplitAction = iota
-    // Split - Split between words
-    // e.g. to split between wordsWithoutDelimiters
-    Split
-    // SkipSplit - Split the word and drop the character
-    // e.g. to split words with delimiters
-    SkipSplit
-    // Skip - Remove the character completely
-    Skip
-)
-```
-
-
-
-
-
-
-
-
-
-## <a name="SplitFn">type</a> [SplitFn](./split.go#L6)
-``` go
-type SplitFn func(prev, curr, next rune) SplitAction
-```
-SplitFn defines how to split a string into words
-
-
-
-
-
-
-
-### <a name="NewSplitFn">func</a> [NewSplitFn](./split.go#L15-L18)
-``` go
-func NewSplitFn(
-    delimiters []rune,
-    splitOptions ...SplitOption,
-) SplitFn
-```
-NewSplitFn returns a SplitFn based on the options provided.
-
-NewSplitFn covers the majority of common options that other strcase
-libraries provide and should allow you to simply create a custom caser.
-For more complicated use cases, feel free to write your own SplitFn
-
-
-
-
-
-## <a name="SplitOption">type</a> [SplitOption](./split.go#L94)
-``` go
-type SplitOption int
-```
-SplitOption are options that allow for configuring NewSplitFn
-
-
-``` go
-const (
-    // SplitCase - FooBar -> Foo_Bar
-    SplitCase SplitOption = iota
-    // SplitAcronym - FOOBar -> Foo_Bar
-    // It won't preserve FOO's case. If you want, you can set the Caser's initialisms so FOO will be in all caps
-    SplitAcronym
-    // SplitBeforeNumber - port80 -> port_80
-    SplitBeforeNumber
-    // SplitAfterNumber - 200status -> 200_status
-    SplitAfterNumber
-    // PreserveNumberFormatting - a.b.2,000.3.c -> a_b_2,000.3_c
-    PreserveNumberFormatting
-)
-```
-
-
-
-
-
-
-
-
-
-## <a name="WordCase">type</a> [WordCase](./convert.go#L6)
-``` go
-type WordCase int
-```
-WordCase is an enumeration of the ways to format a word.
-
-
-``` go
-const (
-    // Original - Preserve the original input strcase
-    Original WordCase = iota
-    // LowerCase - All letters lower cased (example)
-    LowerCase
-    // UpperCase - All letters upper cased (EXAMPLE)
-    UpperCase
-    // TitleCase - Only first letter upper cased (Example)
-    TitleCase
-    // CamelCase - TitleCase except lower case first word (exampleText)
-    // Notably, even if the first word is an initialism, it will be lower
-    // cased. This is important for code generators where capital letters
-    // mean exported functions. i.e. jsonString(), not JSONString()
-    CamelCase
-)
-```
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/vendor/github.com/ettle/strcase/assert.go b/vendor/github.com/ettle/strcase/assert.go
deleted file mode 100644
index 09344e40f..000000000
--- a/vendor/github.com/ettle/strcase/assert.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package strcase
-
-// We use a lightweight replacement for testify/assert to reduce dependencies
-
-// testingT interface allows us to test our assert functions
-type testingT interface {
-	Logf(format string, args ...interface{})
-	Fail()
-}
-
-// assertTrue will fail if the value is not true
-func assertTrue(t testingT, value bool) {
-	if !value {
-		t.Fail()
-	}
-}
-
-// assertEqual will fail if the two strings are not equal
-func assertEqual(t testingT, expected, actual string) {
-	if expected != actual {
-		t.Logf("Expected: %s Actual: %s", expected, actual)
-		t.Fail()
-	}
-}
diff --git a/vendor/github.com/ettle/strcase/caser.go b/vendor/github.com/ettle/strcase/caser.go
deleted file mode 100644
index 2e7eb955b..000000000
--- a/vendor/github.com/ettle/strcase/caser.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package strcase
-
-// Caser allows for customization of parsing and intialisms
-type Caser struct {
-	initialisms map[string]bool
-	splitFn     SplitFn
-}
-
-// NewCaser returns a configured Caser.
-//
-// A Caser should be created when you want fine grained control over how the words are split.
-//
-//	Notes on function arguments
-//
-//	goInitialisms: Whether to use Golint's intialisms
-//
-//	initialismOverrides: A mapping of extra initialisms
-//	Keys must be in ALL CAPS. Merged with Golint's if goInitialisms is set.
-//	Setting a key to false will override Golint's.
-//
-//	splitFn: How to separate words
-//	Override the default split function. Consider using NewSplitFn to
-//	configure one instead of writing your own.
-func NewCaser(goInitialisms bool, initialismOverrides map[string]bool, splitFn SplitFn) *Caser {
-	c := &Caser{
-		initialisms: golintInitialisms,
-		splitFn:     splitFn,
-	}
-
-	if c.splitFn == nil {
-		c.splitFn = defaultSplitFn
-	}
-
-	if goInitialisms && initialismOverrides != nil {
-		c.initialisms = map[string]bool{}
-		for k, v := range golintInitialisms {
-			c.initialisms[k] = v
-		}
-		for k, v := range initialismOverrides {
-			c.initialisms[k] = v
-		}
-	} else if !goInitialisms {
-		c.initialisms = initialismOverrides
-	}
-
-	return c
-}
-
-// ToSnake returns words in snake_case (lower case words with underscores).
-func (c *Caser) ToSnake(s string) string {
-	return convert(s, c.splitFn, '_', LowerCase, c.initialisms)
-}
-
-// ToSNAKE returns words in SNAKE_CASE (upper case words with underscores).
-// Also known as SCREAMING_SNAKE_CASE or UPPER_CASE.
-func (c *Caser) ToSNAKE(s string) string {
-	return convert(s, c.splitFn, '_', UpperCase, c.initialisms)
-}
-
-// ToKebab returns words in kebab-case (lower case words with dashes).
-// Also known as dash-case.
-func (c *Caser) ToKebab(s string) string {
-	return convert(s, c.splitFn, '-', LowerCase, c.initialisms)
-}
-
-// ToKEBAB returns words in KEBAB-CASE (upper case words with dashes).
-// Also known as SCREAMING-KEBAB-CASE or SCREAMING-DASH-CASE.
-func (c *Caser) ToKEBAB(s string) string {
-	return convert(s, c.splitFn, '-', UpperCase, c.initialisms)
-}
-
-// ToPascal returns words in PascalCase (capitalized words concatenated together).
-// Also known as UpperPascalCase.
-func (c *Caser) ToPascal(s string) string {
-	return convert(s, c.splitFn, '\x00', TitleCase, c.initialisms)
-}
-
-// ToCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-// Also known as lowerCamelCase or mixedCase.
-func (c *Caser) ToCamel(s string) string {
-	return convert(s, c.splitFn, '\x00', CamelCase, c.initialisms)
-}
-
-// ToCase returns words with a given case and delimiter.
-func (c *Caser) ToCase(s string, wordCase WordCase, delimiter rune) string {
-	return convert(s, c.splitFn, delimiter, wordCase, c.initialisms)
-}
diff --git a/vendor/github.com/ettle/strcase/convert.go b/vendor/github.com/ettle/strcase/convert.go
deleted file mode 100644
index cb901d079..000000000
--- a/vendor/github.com/ettle/strcase/convert.go
+++ /dev/null
@@ -1,306 +0,0 @@
-package strcase
-
-import "strings"
-
-// WordCase is an enumeration of the ways to format a word.
-type WordCase int
-
-const (
-	// Original - Preserve the original input strcase
-	Original WordCase = iota
-	// LowerCase - All letters lower cased (example)
-	LowerCase
-	// UpperCase - All letters upper cased (EXAMPLE)
-	UpperCase
-	// TitleCase - Only first letter upper cased (Example)
-	TitleCase
-	// CamelCase - TitleCase except lower case first word (exampleText)
-	// Notably, even if the first word is an initialism, it will be lower
-	// cased. This is important for code generators where capital letters
-	// mean exported functions. i.e. jsonString(), not JSONString()
-	CamelCase
-)
-
-// We have 3 convert functions for performance reasons
-// The general convert could handle everything, but is not optimized
-//
-// The other two functions are optimized for the general use cases - that is the non-custom caser functions
-// Case 1: Any Case and supports Go Initialisms
-// Case 2: UpperCase words, which don't need to support initialisms since everything is in upper case
-
-// convertWithoutInitialims only works for to UpperCase and LowerCase
-//
-//nolint:gocyclo
-func convertWithoutInitialisms(input string, delimiter rune, wordCase WordCase) string {
-	input = strings.TrimSpace(input)
-	runes := []rune(input)
-	if len(runes) == 0 {
-		return ""
-	}
-
-	var b strings.Builder
-	b.Grow(len(input) + 4) // In case we need to write delimiters where they weren't before
-
-	var prev, curr rune
-	next := runes[0] // 0 length will have already returned so safe to index
-	inWord := false
-	firstWord := true
-	for i := 0; i < len(runes); i++ {
-		prev = curr
-		curr = next
-		if i+1 == len(runes) {
-			next = 0
-		} else {
-			next = runes[i+1]
-		}
-
-		switch defaultSplitFn(prev, curr, next) {
-		case SkipSplit:
-			if inWord && delimiter != 0 {
-				b.WriteRune(delimiter)
-			}
-			inWord = false
-			continue
-		case Split:
-			if inWord && delimiter != 0 {
-				b.WriteRune(delimiter)
-			}
-			inWord = false
-		}
-		switch wordCase {
-		case UpperCase:
-			b.WriteRune(toUpper(curr))
-		case LowerCase:
-			b.WriteRune(toLower(curr))
-		case TitleCase:
-			if inWord {
-				b.WriteRune(toLower(curr))
-			} else {
-				b.WriteRune(toUpper(curr))
-			}
-		case CamelCase:
-			if inWord {
-				b.WriteRune(toLower(curr))
-			} else if firstWord {
-				b.WriteRune(toLower(curr))
-				firstWord = false
-			} else {
-				b.WriteRune(toUpper(curr))
-			}
-		default:
-			// Must be original case
-			b.WriteRune(curr)
-		}
-		inWord = true
-	}
-	return b.String()
-}
-
-// convertWithGoInitialisms changes a input string to a certain case with a
-// delimiter, respecting go initialisms but not skip runes
-//
-//nolint:gocyclo
-func convertWithGoInitialisms(input string, delimiter rune, wordCase WordCase) string {
-	input = strings.TrimSpace(input)
-	runes := []rune(input)
-	if len(runes) == 0 {
-		return ""
-	}
-
-	var b strings.Builder
-	b.Grow(len(input) + 4) // In case we need to write delimiters where they weren't before
-
-	firstWord := true
-
-	addWord := func(start, end int) {
-		if start == end {
-			return
-		}
-
-		if !firstWord && delimiter != 0 {
-			b.WriteRune(delimiter)
-		}
-
-		// Don't bother with initialisms if the word is longer than 5
-		// A quick proxy to avoid the extra memory allocations
-		if end-start <= 5 {
-			var word strings.Builder
-			word.Grow(end - start)
-			for i := start; i < end; i++ {
-				word.WriteRune(toUpper(runes[i]))
-			}
-			w := word.String()
-			if golintInitialisms[w] {
-				if !firstWord || wordCase != CamelCase {
-					b.WriteString(w)
-					firstWord = false
-					return
-				}
-			}
-		}
-
-		for i := start; i < end; i++ {
-			r := runes[i]
-			switch wordCase {
-			case UpperCase:
-				panic("use convertWithoutInitialisms instead")
-			case LowerCase:
-				b.WriteRune(toLower(r))
-			case TitleCase:
-				if i == start {
-					b.WriteRune(toUpper(r))
-				} else {
-					b.WriteRune(toLower(r))
-				}
-			case CamelCase:
-				if !firstWord && i == start {
-					b.WriteRune(toUpper(r))
-				} else {
-					b.WriteRune(toLower(r))
-				}
-			default:
-				b.WriteRune(r)
-			}
-		}
-		firstWord = false
-	}
-
-	var prev, curr rune
-	next := runes[0] // 0 length will have already returned so safe to index
-	wordStart := 0
-	for i := 0; i < len(runes); i++ {
-		prev = curr
-		curr = next
-		if i+1 == len(runes) {
-			next = 0
-		} else {
-			next = runes[i+1]
-		}
-
-		switch defaultSplitFn(prev, curr, next) {
-		case Split:
-			addWord(wordStart, i)
-			wordStart = i
-		case SkipSplit:
-			addWord(wordStart, i)
-			wordStart = i + 1
-		}
-	}
-
-	if wordStart != len(runes) {
-		addWord(wordStart, len(runes))
-	}
-	return b.String()
-}
-
-// convert changes a input string to a certain case with a delimiter,
-// respecting arbitrary initialisms and skip characters
-//
-//nolint:gocyclo
-func convert(input string, fn SplitFn, delimiter rune, wordCase WordCase,
-	initialisms map[string]bool) string {
-	input = strings.TrimSpace(input)
-	runes := []rune(input)
-	if len(runes) == 0 {
-		return ""
-	}
-
-	var b strings.Builder
-	b.Grow(len(input) + 4) // In case we need to write delimiters where they weren't before
-
-	firstWord := true
-	var skipIndexes []int
-
-	addWord := func(start, end int) {
-		// If you have nothing good to say, say nothing at all
-		if start == end || len(skipIndexes) == end-start {
-			skipIndexes = nil
-			return
-		}
-
-		// If you have something to say, start with a delimiter
-		if !firstWord && delimiter != 0 {
-			b.WriteRune(delimiter)
-		}
-
-		// Check if you're an initialism
-		// Note - we don't check skip characters here since initialisms
-		// will probably never have junk characters in between
-		// I'm open to it if there is a use case
-		if initialisms != nil {
-			var word strings.Builder
-			word.Grow(end - start)
-			for i := start; i < end; i++ {
-				word.WriteRune(toUpper(runes[i]))
-			}
-			w := word.String()
-			if initialisms[w] {
-				if !firstWord || wordCase != CamelCase {
-					b.WriteString(w)
-					firstWord = false
-					return
-				}
-			}
-		}
-
-		skipIdx := 0
-		for i := start; i < end; i++ {
-			if len(skipIndexes) > 0 && skipIdx < len(skipIndexes) && i == skipIndexes[skipIdx] {
-				skipIdx++
-				continue
-			}
-			r := runes[i]
-			switch wordCase {
-			case UpperCase:
-				b.WriteRune(toUpper(r))
-			case LowerCase:
-				b.WriteRune(toLower(r))
-			case TitleCase:
-				if i == start {
-					b.WriteRune(toUpper(r))
-				} else {
-					b.WriteRune(toLower(r))
-				}
-			case CamelCase:
-				if !firstWord && i == start {
-					b.WriteRune(toUpper(r))
-				} else {
-					b.WriteRune(toLower(r))
-				}
-			default:
-				b.WriteRune(r)
-			}
-		}
-		firstWord = false
-		skipIndexes = nil
-	}
-
-	var prev, curr rune
-	next := runes[0] // 0 length will have already returned so safe to index
-	wordStart := 0
-	for i := 0; i < len(runes); i++ {
-		prev = curr
-		curr = next
-		if i+1 == len(runes) {
-			next = 0
-		} else {
-			next = runes[i+1]
-		}
-
-		switch fn(prev, curr, next) {
-		case Skip:
-			skipIndexes = append(skipIndexes, i)
-		case Split:
-			addWord(wordStart, i)
-			wordStart = i
-		case SkipSplit:
-			addWord(wordStart, i)
-			wordStart = i + 1
-		}
-	}
-
-	if wordStart != len(runes) {
-		addWord(wordStart, len(runes))
-	}
-	return b.String()
-}
diff --git a/vendor/github.com/ettle/strcase/doc.go b/vendor/github.com/ettle/strcase/doc.go
deleted file mode 100644
index c3bf14a8f..000000000
--- a/vendor/github.com/ettle/strcase/doc.go
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
-Package strcase is a package for converting strings into various word cases
-(e.g. snake_case, camelCase)
-
-	go get -u github.com/ettle/strcase
-
-Example usage
-
-	strcase.ToSnake("Hello World")     // hello_world
-	strcase.ToSNAKE("Hello World")     // HELLO_WORLD
-
-	strcase.ToKebab("helloWorld")      // hello-world
-	strcase.ToKEBAB("helloWorld")      // HELLO-WORLD
-
-	strcase.ToPascal("hello-world")    // HelloWorld
-	strcase.ToCamel("hello-world")     // helloWorld
-
-	// Handle odd cases
-	strcase.ToSnake("FOOBar")          // foo_bar
-
-	// Support Go initialisms
-	strcase.ToGoPascal("http_response") // HTTPResponse
-
-	// Specify case and delimiter
-	strcase.ToCase("HelloWorld", strcase.UpperCase, '.') // HELLO.WORLD
-
-## Why this package
-
-String strcase is pretty straight forward and there are a number of methods to
-do it. This package is fully featured, more customizable, better tested, and
-faster than other packages and what you would probably whip up yourself.
-
-### Unicode support
-
-We work for with unicode strings and pay very little performance penalty for it
-as we optimized for the common use case of ASCII only strings.
-
-### Customization
-
-You can create a custom caser that changes the behavior to what you want. This
-customization also reduces the pressure for us to change the default behavior
-which means that things are more stable for everyone involved.  The goal is to
-make the common path easy and fast, while making the uncommon path possible.
-
-	 c := NewCaser(
-		// Use Go's default initialisms e.g. ID, HTML
-	 	true,
-		// Override initialisms (e.g. don't initialize HTML but initialize SSL
-	 	map[string]bool{"SSL": true, "HTML": false},
-		// Write your own custom SplitFn
-		//
-	 	NewSplitFn(
-	 		[]rune{'*', '.', ','},
-	 		SplitCase,
-	 		SplitAcronym,
-	 		PreserveNumberFormatting,
-	 		SplitBeforeNumber,
-	 		SplitAfterNumber,
-	 	))
-	 assert.Equal(t, "http_200", c.ToSnake("http200"))
-
-### Initialism support
-
-By default, we use the golint intialisms list. You can customize and override
-the initialisms if you wish to add additional ones, such as "SSL" or "CMS" or
-domain specific ones to your industry.
-
-	ToGoPascal("http_response") // HTTPResponse
-	ToGoSnake("http_response") // HTTP_response
-
-### Test coverage
-
-We have a wide ranging test suite to make sure that we understand our behavior.
-Test coverage isn't everything, but we aim for 100% coverage.
-
-### Fast
-
-Optimized to reduce memory allocations with Builder. Benchmarked and optimized
-around common cases.
-
-We're on par with the fastest packages (that have less features) and much
-faster than others. We also benchmarked against code snippets. Using string
-builders to reduce memory allocation and reordering boolean checks for the
-common cases have a large performance impact.
-
-Hopefully I was fair to each library and happy to rerun benchmarks differently
-or reword my commentary based on suggestions or updates.
-
-	// This package - faster then almost all libraries
-	// Initialisms are more complicated and slightly slower, but still fast
-	BenchmarkToTitle-96                      9617142               125.7 ns/op            16 B/op          1 allocs/op
-	BenchmarkToSnake-96                     10659919               120.7 ns/op            16 B/op          1 allocs/op
-	BenchmarkToSNAKE-96                      9018282               126.4 ns/op            16 B/op          1 allocs/op
-	BenchmarkToGoSnake-96                    4903687               254.5 ns/op            26 B/op          4 allocs/op
-	BenchmarkToCustomCaser-96                4434489               265.0 ns/op            28 B/op          4 allocs/op
-
-	// Segment has very fast snake case and camel case libraries
-	// No features or customization, but very very fast
-	BenchmarkSegment-96                     33625734                35.54 ns/op           16 B/op          1 allocs/op
-
-	// Iancoleman has gotten some performance improvements, but remains
-	// without unicode support and lacks fine-grained customization
-	BenchmarkToSnakeIan-96                  13141522                92.99 ns/op           16 B/op          1 allocs/op
-
-	// Stdlib strings.Title is deprecated; using golang.org/x.text
-	BenchmarkGolangOrgXTextCases-96          4665676               262.5 ns/op           272 B/op          2 allocs/op
-
-	// Other libraries or code snippets
-	// - Most are slower, by up to an order of magnitude
-	// - No support for initialisms or customization
-	// - Some generate only camelCase or snake_case
-	// - Many lack unicode support
-	BenchmarkToSnakeStoewer-96               8095468               148.9 ns/op            64 B/op          2 allocs/op
-	// Copying small rune arrays is slow
-	BenchmarkToSnakeSiongui-96               2912593               401.7 ns/op           112 B/op         19 allocs/op
-	BenchmarkGoValidator-96                  3493800               342.6 ns/op           184 B/op          9 allocs/op
-	// String alloction is slow
-	BenchmarkToSnakeFatih-96                 1282648               945.1 ns/op           616 B/op         26 allocs/op
-	// Regexp is slow
-	BenchmarkToSnakeGolangPrograms-96         778674              1495 ns/op             227 B/op         11 allocs/op
-
-	// These results aren't a surprise - my initial version of this library was
-	// painfully slow. I think most of us, without spending some time with
-	// profilers and benchmarks, would write also something on the slower side.
-
-### Zero dependencies
-
-That's right - zero. We only import the Go standard library. No hassles with
-dependencies, licensing, security alerts.
-
-## Why not this package
-
-If every nanosecond matters and this is used in a tight loop, use segment.io's
-libraries (https://github.com/segmentio/go-snakecase and
-https://github.com/segmentio/go-camelcase). They lack features, but make up for
-it by being blazing fast.
-
-## Migrating from other packages
-
-If you are migrating from from another package, you may find slight differences
-in output. To reduce the delta, you may find it helpful to use the following
-custom casers to mimic the behavior of the other package.
-
-	// From https://github.com/iancoleman/strcase
-	var c = NewCaser(false, nil, NewSplitFn([]rune{'_', '-', '.'}, SplitCase, SplitAcronym, SplitBeforeNumber))
-
-	// From https://github.com/stoewer/go-strcase
-	var c = NewCaser(false, nil, NewSplitFn([]rune{'_', '-'}, SplitCase), SplitAcronym)
-*/
-package strcase
diff --git a/vendor/github.com/ettle/strcase/initialism.go b/vendor/github.com/ettle/strcase/initialism.go
deleted file mode 100644
index 3c313d3e9..000000000
--- a/vendor/github.com/ettle/strcase/initialism.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package strcase
-
-// golintInitialisms are the golint initialisms
-var golintInitialisms = map[string]bool{
-	"ACL":   true,
-	"API":   true,
-	"ASCII": true,
-	"CPU":   true,
-	"CSS":   true,
-	"DNS":   true,
-	"EOF":   true,
-	"GUID":  true,
-	"HTML":  true,
-	"HTTP":  true,
-	"HTTPS": true,
-	"ID":    true,
-	"IP":    true,
-	"JSON":  true,
-	"LHS":   true,
-	"QPS":   true,
-	"RAM":   true,
-	"RHS":   true,
-	"RPC":   true,
-	"SLA":   true,
-	"SMTP":  true,
-	"SQL":   true,
-	"SSH":   true,
-	"TCP":   true,
-	"TLS":   true,
-	"TTL":   true,
-	"UDP":   true,
-	"UI":    true,
-	"UID":   true,
-	"UUID":  true,
-	"URI":   true,
-	"URL":   true,
-	"UTF8":  true,
-	"VM":    true,
-	"XML":   true,
-	"XMPP":  true,
-	"XSRF":  true,
-	"XSS":   true,
-}
diff --git a/vendor/github.com/ettle/strcase/split.go b/vendor/github.com/ettle/strcase/split.go
deleted file mode 100644
index 32bc29759..000000000
--- a/vendor/github.com/ettle/strcase/split.go
+++ /dev/null
@@ -1,165 +0,0 @@
-package strcase
-
-import "unicode"
-
-// SplitFn defines how to split a string into words
-type SplitFn func(prev, curr, next rune) SplitAction
-
-// NewSplitFn returns a SplitFn based on the options provided.
-//
-// NewSplitFn covers the majority of common options that other strcase
-// libraries provide and should allow you to simply create a custom caser.
-// For more complicated use cases, feel free to write your own SplitFn
-//
-//nolint:gocyclo
-func NewSplitFn(
-	delimiters []rune,
-	splitOptions ...SplitOption,
-) SplitFn {
-	var splitCase, splitAcronym, splitBeforeNumber, splitAfterNumber, preserveNumberFormatting bool
-
-	for _, option := range splitOptions {
-		switch option {
-		case SplitCase:
-			splitCase = true
-		case SplitAcronym:
-			splitAcronym = true
-		case SplitBeforeNumber:
-			splitBeforeNumber = true
-		case SplitAfterNumber:
-			splitAfterNumber = true
-		case PreserveNumberFormatting:
-			preserveNumberFormatting = true
-		}
-	}
-
-	return func(prev, curr, next rune) SplitAction {
-		// The most common case will be that it's just a letter
-		// There are safe cases to process
-		if isLower(curr) && !isNumber(prev) {
-			return Noop
-		}
-		if isUpper(prev) && isUpper(curr) && isUpper(next) {
-			return Noop
-		}
-
-		if preserveNumberFormatting {
-			if (curr == '.' || curr == ',') &&
-				isNumber(prev) && isNumber(next) {
-				return Noop
-			}
-		}
-
-		if unicode.IsSpace(curr) {
-			return SkipSplit
-		}
-		for _, d := range delimiters {
-			if curr == d {
-				return SkipSplit
-			}
-		}
-
-		if splitBeforeNumber {
-			if isNumber(curr) && !isNumber(prev) {
-				if preserveNumberFormatting && (prev == '.' || prev == ',') {
-					return Noop
-				}
-				return Split
-			}
-		}
-
-		if splitAfterNumber {
-			if isNumber(prev) && !isNumber(curr) {
-				return Split
-			}
-		}
-
-		if splitCase {
-			if !isUpper(prev) && isUpper(curr) {
-				return Split
-			}
-		}
-
-		if splitAcronym {
-			if isUpper(prev) && isUpper(curr) && isLower(next) {
-				return Split
-			}
-		}
-
-		return Noop
-	}
-}
-
-// SplitOption are options that allow for configuring NewSplitFn
-type SplitOption int
-
-const (
-	// SplitCase - FooBar -> Foo_Bar
-	SplitCase SplitOption = iota
-	// SplitAcronym - FOOBar -> Foo_Bar
-	// It won't preserve FOO's case. If you want, you can set the Caser's initialisms so FOO will be in all caps
-	SplitAcronym
-	// SplitBeforeNumber - port80 -> port_80
-	SplitBeforeNumber
-	// SplitAfterNumber - 200status -> 200_status
-	SplitAfterNumber
-	// PreserveNumberFormatting - a.b.2,000.3.c -> a_b_2,000.3_c
-	PreserveNumberFormatting
-)
-
-// SplitAction defines if and how to split a string
-type SplitAction int
-
-const (
-	// Noop - Continue to next character
-	Noop SplitAction = iota
-	// Split - Split between words
-	// e.g. to split between wordsWithoutDelimiters
-	Split
-	// SkipSplit - Split the word and drop the character
-	// e.g. to split words with delimiters
-	SkipSplit
-	// Skip - Remove the character completely
-	Skip
-)
-
-//nolint:gocyclo
-func defaultSplitFn(prev, curr, next rune) SplitAction {
-	// The most common case will be that it's just a letter so let lowercase letters return early since we know what they should do
-	if isLower(curr) {
-		return Noop
-	}
-	// Delimiters are _, -, ., and unicode spaces
-	// Handle . lower down as it needs to happen after number exceptions
-	if curr == '_' || curr == '-' || isSpace(curr) {
-		return SkipSplit
-	}
-
-	if isUpper(curr) {
-		if isLower(prev) {
-			// fooBar
-			return Split
-		} else if isUpper(prev) && isLower(next) {
-			// FOOBar
-			return Split
-		}
-	}
-
-	// Do numeric exceptions last to avoid perf penalty
-	if unicode.IsNumber(prev) {
-		// v4.3 is not split
-		if (curr == '.' || curr == ',') && unicode.IsNumber(next) {
-			return Noop
-		}
-		if !unicode.IsNumber(curr) && curr != '.' {
-			return Split
-		}
-	}
-	// While period is a default delimiter, keep it down here to avoid
-	// penalty for other delimiters
-	if curr == '.' {
-		return SkipSplit
-	}
-
-	return Noop
-}
diff --git a/vendor/github.com/ettle/strcase/strcase.go b/vendor/github.com/ettle/strcase/strcase.go
deleted file mode 100644
index 46b4f7a68..000000000
--- a/vendor/github.com/ettle/strcase/strcase.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package strcase
-
-// ToSnake returns words in snake_case (lower case words with underscores).
-func ToSnake(s string) string {
-	return convertWithoutInitialisms(s, '_', LowerCase)
-}
-
-// ToGoSnake returns words in snake_case (lower case words with underscores).
-//
-// Respects Go's common initialisms (e.g. http_response -> HTTP_response).
-func ToGoSnake(s string) string {
-	return convertWithGoInitialisms(s, '_', LowerCase)
-}
-
-// ToSNAKE returns words in SNAKE_CASE (upper case words with underscores).
-// Also known as SCREAMING_SNAKE_CASE or UPPER_CASE.
-func ToSNAKE(s string) string {
-	return convertWithoutInitialisms(s, '_', UpperCase)
-}
-
-// ToKebab returns words in kebab-case (lower case words with dashes).
-// Also known as dash-case.
-func ToKebab(s string) string {
-	return convertWithoutInitialisms(s, '-', LowerCase)
-}
-
-// ToGoKebab returns words in kebab-case (lower case words with dashes).
-// Also known as dash-case.
-//
-// Respects Go's common initialisms (e.g. http-response -> HTTP-response).
-func ToGoKebab(s string) string {
-	return convertWithGoInitialisms(s, '-', LowerCase)
-}
-
-// ToKEBAB returns words in KEBAB-CASE (upper case words with dashes).
-// Also known as SCREAMING-KEBAB-CASE or SCREAMING-DASH-CASE.
-func ToKEBAB(s string) string {
-	return convertWithoutInitialisms(s, '-', UpperCase)
-}
-
-// ToPascal returns words in PascalCase (capitalized words concatenated together).
-// Also known as UpperPascalCase.
-func ToPascal(s string) string {
-	return convertWithoutInitialisms(s, 0, TitleCase)
-}
-
-// ToGoPascal returns words in PascalCase (capitalized words concatenated together).
-// Also known as UpperPascalCase.
-//
-// Respects Go's common initialisms (e.g. HttpResponse -> HTTPResponse).
-func ToGoPascal(s string) string {
-	return convertWithGoInitialisms(s, 0, TitleCase)
-}
-
-// ToCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-// Also known as lowerCamelCase or mixedCase.
-func ToCamel(s string) string {
-	return convertWithoutInitialisms(s, 0, CamelCase)
-}
-
-// ToGoCamel returns words in camelCase (capitalized words concatenated together, with first word lower case).
-// Also known as lowerCamelCase or mixedCase.
-//
-// Respects Go's common initialisms, but first word remains lowercased which is
-// important for code generator use cases (e.g. toJson -> toJSON, httpResponse
-// -> httpResponse).
-func ToGoCamel(s string) string {
-	return convertWithGoInitialisms(s, 0, CamelCase)
-}
-
-// ToCase returns words in given case and delimiter.
-func ToCase(s string, wordCase WordCase, delimiter rune) string {
-	return convertWithoutInitialisms(s, delimiter, wordCase)
-}
-
-// ToGoCase returns words in given case and delimiter.
-//
-// Respects Go's common initialisms (e.g. httpResponse -> HTTPResponse).
-func ToGoCase(s string, wordCase WordCase, delimiter rune) string {
-	return convertWithGoInitialisms(s, delimiter, wordCase)
-}
diff --git a/vendor/github.com/ettle/strcase/unicode.go b/vendor/github.com/ettle/strcase/unicode.go
deleted file mode 100644
index b75e25a51..000000000
--- a/vendor/github.com/ettle/strcase/unicode.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package strcase
-
-import "unicode"
-
-// Unicode functions, optimized for the common case of ascii
-// No performance lost by wrapping since these functions get inlined by the compiler
-
-func isUpper(r rune) bool {
-	return unicode.IsUpper(r)
-}
-
-func isLower(r rune) bool {
-	return unicode.IsLower(r)
-}
-
-func isNumber(r rune) bool {
-	if r >= '0' && r <= '9' {
-		return true
-	}
-	return unicode.IsNumber(r)
-}
-
-func isSpace(r rune) bool {
-	if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
-		return true
-	} else if r < 128 {
-		return false
-	}
-	return unicode.IsSpace(r)
-}
-
-func toUpper(r rune) rune {
-	if r >= 'a' && r <= 'z' {
-		return r - 32
-	} else if r < 128 {
-		return r
-	}
-	return unicode.ToUpper(r)
-}
-
-func toLower(r rune) rune {
-	if r >= 'A' && r <= 'Z' {
-		return r + 32
-	} else if r < 128 {
-		return r
-	}
-	return unicode.ToLower(r)
-}