deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

11 files changed, 820 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/registry/client.go b/vendor/github.com/hashicorp/terraform/registry/client.go
new file mode 100644
index 0000000..a18e6b8
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/client.go
@@ -0,0 +1,227 @@
+package registry
+
+import (
+        "encoding/json"
+        "fmt"
+        "io/ioutil"
+        "log"
+        "net/http"
+        "net/url"
+        "path"
+        "strings"
+        "time"
+
+        "github.com/hashicorp/terraform/httpclient"
+        "github.com/hashicorp/terraform/registry/regsrc"
+        "github.com/hashicorp/terraform/registry/response"
+        "github.com/hashicorp/terraform/svchost"
+        "github.com/hashicorp/terraform/svchost/disco"
+        "github.com/hashicorp/terraform/version"
+)
+
+const (
+        xTerraformGet     = "X-Terraform-Get"
+        xTerraformVersion = "X-Terraform-Version"
+        requestTimeout    = 10 * time.Second
+        serviceID         = "modules.v1"
+)
+
+var tfVersion = version.String()
+
+// Client provides methods to query Terraform Registries.
+type Client struct {
+        // this is the client to be used for all requests.
+        client *http.Client
+
+        // services is a required *disco.Disco, which may have services and
+        // credentials pre-loaded.
+        services *disco.Disco
+}
+
+// NewClient returns a new initialized registry client.
+func NewClient(services *disco.Disco, client *http.Client) *Client {
+        if services == nil {
+                services = disco.New()
+        }
+
+        if client == nil {
+                client = httpclient.New()
+                client.Timeout = requestTimeout
+        }
+
+        services.Transport = client.Transport
+
+        return &Client{
+                client:   client,
+                services: services,
+        }
+}
+
+// Discover queries the host, and returns the url for the registry.
+func (c *Client) Discover(host svchost.Hostname) (*url.URL, error) {
+        service, err := c.services.DiscoverServiceURL(host, serviceID)
+        if err != nil {
+                return nil, err
+        }
+        if !strings.HasSuffix(service.Path, "/") {
+                service.Path += "/"
+        }
+        return service, nil
+}
+
+// Versions queries the registry for a module, and returns the available versions.
+func (c *Client) Versions(module *regsrc.Module) (*response.ModuleVersions, error) {
+        host, err := module.SvcHost()
+        if err != nil {
+                return nil, err
+        }
+
+        service, err := c.Discover(host)
+        if err != nil {
+                return nil, err
+        }
+
+        p, err := url.Parse(path.Join(module.Module(), "versions"))
+        if err != nil {
+                return nil, err
+        }
+
+        service = service.ResolveReference(p)
+
+        log.Printf("[DEBUG] fetching module versions from %q", service)
+
+        req, err := http.NewRequest("GET", service.String(), nil)
+        if err != nil {
+                return nil, err
+        }
+
+        c.addRequestCreds(host, req)
+        req.Header.Set(xTerraformVersion, tfVersion)
+
+        resp, err := c.client.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+
+        switch resp.StatusCode {
+        case http.StatusOK:
+                // OK
+        case http.StatusNotFound:
+                return nil, &errModuleNotFound{addr: module}
+        default:
+                return nil, fmt.Errorf("error looking up module versions: %s", resp.Status)
+        }
+
+        var versions response.ModuleVersions
+
+        dec := json.NewDecoder(resp.Body)
+        if err := dec.Decode(&versions); err != nil {
+                return nil, err
+        }
+
+        for _, mod := range versions.Modules {
+                for _, v := range mod.Versions {
+                        log.Printf("[DEBUG] found available version %q for %s", v.Version, mod.Source)
+                }
+        }
+
+        return &versions, nil
+}
+
+func (c *Client) addRequestCreds(host svchost.Hostname, req *http.Request) {
+        creds, err := c.services.CredentialsForHost(host)
+        if err != nil {
+                log.Printf("[WARN] Failed to get credentials for %s: %s (ignoring)", host, err)
+                return
+        }
+
+        if creds != nil {
+                creds.PrepareRequest(req)
+        }
+}
+
+// Location find the download location for a specific version module.
+// This returns a string, because the final location may contain special go-getter syntax.
+func (c *Client) Location(module *regsrc.Module, version string) (string, error) {
+        host, err := module.SvcHost()
+        if err != nil {
+                return "", err
+        }
+
+        service, err := c.Discover(host)
+        if err != nil {
+                return "", err
+        }
+
+        var p *url.URL
+        if version == "" {
+                p, err = url.Parse(path.Join(module.Module(), "download"))
+        } else {
+                p, err = url.Parse(path.Join(module.Module(), version, "download"))
+        }
+        if err != nil {
+                return "", err
+        }
+        download := service.ResolveReference(p)
+
+        log.Printf("[DEBUG] looking up module location from %q", download)
+
+        req, err := http.NewRequest("GET", download.String(), nil)
+        if err != nil {
+                return "", err
+        }
+
+        c.addRequestCreds(host, req)
+        req.Header.Set(xTerraformVersion, tfVersion)
+
+        resp, err := c.client.Do(req)
+        if err != nil {
+                return "", err
+        }
+        defer resp.Body.Close()
+
+        // there should be no body, but save it for logging
+        body, err := ioutil.ReadAll(resp.Body)
+        if err != nil {
+                return "", fmt.Errorf("error reading response body from registry: %s", err)
+        }
+
+        switch resp.StatusCode {
+        case http.StatusOK, http.StatusNoContent:
+                // OK
+        case http.StatusNotFound:
+                return "", fmt.Errorf("module %q version %q not found", module, version)
+        default:
+                // anything else is an error:
+                return "", fmt.Errorf("error getting download location for %q: %s resp:%s", module, resp.Status, body)
+        }
+
+        // the download location is in the X-Terraform-Get header
+        location := resp.Header.Get(xTerraformGet)
+        if location == "" {
+                return "", fmt.Errorf("failed to get download URL for %q: %s resp:%s", module, resp.Status, body)
+        }
+
+        // If location looks like it's trying to be a relative URL, treat it as
+        // one.
+        //
+        // We don't do this for just _any_ location, since the X-Terraform-Get
+        // header is a go-getter location rather than a URL, and so not all
+        // possible values will parse reasonably as URLs.)
+        //
+        // When used in conjunction with go-getter we normally require this header
+        // to be an absolute URL, but we are more liberal here because third-party
+        // registry implementations may not "know" their own absolute URLs if
+        // e.g. they are running behind a reverse proxy frontend, or such.
+        if strings.HasPrefix(location, "/") || strings.HasPrefix(location, "./") || strings.HasPrefix(location, "../") {
+                locationURL, err := url.Parse(location)
+                if err != nil {
+                        return "", fmt.Errorf("invalid relative URL for %q: %s", module, err)
+                }
+                locationURL = download.ResolveReference(locationURL)
+                location = locationURL.String()
+        }
+
+        return location, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/errors.go b/vendor/github.com/hashicorp/terraform/registry/errors.go
new file mode 100644
index 0000000..b8dcd31
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/errors.go
@@ -0,0 +1,23 @@
+package registry
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/terraform/registry/regsrc"
+)
+
+type errModuleNotFound struct {
+        addr *regsrc.Module
+}
+
+func (e *errModuleNotFound) Error() string {
+        return fmt.Sprintf("module %s not found", e.addr)
+}
+
+// IsModuleNotFound returns true only if the given error is a "module not found"
+// error. This allows callers to recognize this particular error condition
+// as distinct from operational errors such as poor network connectivity.
+func IsModuleNotFound(err error) bool {
+        _, ok := err.(*errModuleNotFound)
+        return ok
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go
new file mode 100644
index 0000000..14b4dce
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go
@@ -0,0 +1,140 @@
+package regsrc
+
+import (
+        "regexp"
+        "strings"
+
+        "github.com/hashicorp/terraform/svchost"
+)
+
+var (
+        // InvalidHostString is a placeholder returned when a raw host can't be
+        // converted by IDNA spec. It will never be returned for any host for which
+        // Valid() is true.
+        InvalidHostString = "<invalid host>"
+
+        // urlLabelEndSubRe is a sub-expression that matches any character that's
+        // allowed at the start or end of a URL label according to RFC1123.
+        urlLabelEndSubRe = "[0-9A-Za-z]"
+
+        // urlLabelEndSubRe is a sub-expression that matches any character that's
+        // allowed at in a non-start or end of a URL label according to RFC1123.
+        urlLabelMidSubRe = "[0-9A-Za-z-]"
+
+        // urlLabelUnicodeSubRe is a sub-expression that matches any non-ascii char
+        // in an IDN (Unicode) display URL. It's not strict - there are only ~15k
+        // valid Unicode points in IDN RFC (some with conditions). We are just going
+        // with being liberal with matching and then erroring if we fail to convert
+        // to punycode later (which validates chars fully). This at least ensures
+        // ascii chars dissalowed by the RC1123 parts above don't become legal
+        // again.
+        urlLabelUnicodeSubRe = "[^[:ascii:]]"
+
+        // hostLabelSubRe is the sub-expression that matches a valid hostname label.
+        // It does not anchor the start or end so it can be composed into more
+        // complex RegExps below. Note that for sanity we don't handle disallowing
+        // raw punycode in this regexp (esp. since re2 doesn't support negative
+        // lookbehind, but we can capture it's presence here to check later).
+        hostLabelSubRe = "" +
+                // Match valid initial char, or unicode char
+                "(?:" + urlLabelEndSubRe + "|" + urlLabelUnicodeSubRe + ")" +
+                // Optionally, match 0 to 61 valid URL or Unicode chars,
+                // followed by one valid end char or unicode char
+                "(?:" +
+                "(?:" + urlLabelMidSubRe + "|" + urlLabelUnicodeSubRe + "){0,61}" +
+                "(?:" + urlLabelEndSubRe + "|" + urlLabelUnicodeSubRe + ")" +
+                ")?"
+
+        // hostSubRe is the sub-expression that matches a valid host prefix.
+        // Allows custom port.
+        hostSubRe = hostLabelSubRe + "(?:\\." + hostLabelSubRe + ")+(?::\\d+)?"
+
+        // hostRe is a regexp that matches a valid host prefix. Additional
+        // validation of unicode strings is needed for matches.
+        hostRe = regexp.MustCompile("^" + hostSubRe + "$")
+)
+
+// FriendlyHost describes a registry instance identified in source strings by a
+// simple bare hostname like registry.terraform.io.
+type FriendlyHost struct {
+        Raw string
+}
+
+func NewFriendlyHost(host string) *FriendlyHost {
+        return &FriendlyHost{Raw: host}
+}
+
+// ParseFriendlyHost attempts to parse a valid "friendly host" prefix from the
+// given string. If no valid prefix is found, host will be nil and rest will
+// contain the full source string. The host prefix must terminate at the end of
+// the input or at the first / character. If one or more characters exist after
+// the first /, they will be returned as rest (without the / delimiter).
+// Hostnames containing punycode WILL be parsed successfully since they may have
+// come from an internal normalized source string, however should be considered
+// invalid if the string came from a user directly. This must be checked
+// explicitly for user-input strings by calling Valid() on the
+// returned host.
+func ParseFriendlyHost(source string) (host *FriendlyHost, rest string) {
+        parts := strings.SplitN(source, "/", 2)
+
+        if hostRe.MatchString(parts[0]) {
+                host = &FriendlyHost{Raw: parts[0]}
+                if len(parts) == 2 {
+                        rest = parts[1]
+                }
+                return
+        }
+
+        // No match, return whole string as rest along with nil host
+        rest = source
+        return
+}
+
+// Valid returns whether the host prefix is considered valid in any case.
+// Example of invalid prefixes might include ones that don't conform to the host
+// name specifications. Not that IDN prefixes containing punycode are not valid
+// input which we expect to always be in user-input or normalised display form.
+func (h *FriendlyHost) Valid() bool {
+        return svchost.IsValid(h.Raw)
+}
+
+// Display returns the host formatted for display to the user in CLI or web
+// output.
+func (h *FriendlyHost) Display() string {
+        return svchost.ForDisplay(h.Raw)
+}
+
+// Normalized returns the host formatted for internal reference or comparison.
+func (h *FriendlyHost) Normalized() string {
+        host, err := svchost.ForComparison(h.Raw)
+        if err != nil {
+                return InvalidHostString
+        }
+        return string(host)
+}
+
+// String returns the host formatted as the user originally typed it assuming it
+// was parsed from user input.
+func (h *FriendlyHost) String() string {
+        return h.Raw
+}
+
+// Equal compares the FriendlyHost against another instance taking normalization
+// into account. Invalid hosts cannot be compared and will always return false.
+func (h *FriendlyHost) Equal(other *FriendlyHost) bool {
+        if other == nil {
+                return false
+        }
+
+        otherHost, err := svchost.ForComparison(other.Raw)
+        if err != nil {
+                return false
+        }
+
+        host, err := svchost.ForComparison(h.Raw)
+        if err != nil {
+                return false
+        }
+
+        return otherHost == host
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go
new file mode 100644
index 0000000..325706e
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go
@@ -0,0 +1,205 @@
+package regsrc
+
+import (
+        "errors"
+        "fmt"
+        "regexp"
+        "strings"
+
+        "github.com/hashicorp/terraform/svchost"
+)
+
+var (
+        ErrInvalidModuleSource = errors.New("not a valid registry module source")
+
+        // nameSubRe is the sub-expression that matches a valid module namespace or
+        // name. It's strictly a super-set of what GitHub allows for user/org and
+        // repo names respectively, but more restrictive than our original repo-name
+        // regex which allowed periods but could cause ambiguity with hostname
+        // prefixes. It does not anchor the start or end so it can be composed into
+        // more complex RegExps below. Alphanumeric with - and _ allowed in non
+        // leading or trailing positions. Max length 64 chars. (GitHub username is
+        // 38 max.)
+        nameSubRe = "[0-9A-Za-z](?:[0-9A-Za-z-_]{0,62}[0-9A-Za-z])?"
+
+        // providerSubRe is the sub-expression that matches a valid provider. It
+        // does not anchor the start or end so it can be composed into more complex
+        // RegExps below. Only lowercase chars and digits are supported in practice.
+        // Max length 64 chars.
+        providerSubRe = "[0-9a-z]{1,64}"
+
+        // moduleSourceRe is a regular expression that matches the basic
+        // namespace/name/provider[//...] format for registry sources. It assumes
+        // any FriendlyHost prefix has already been removed if present.
+        moduleSourceRe = regexp.MustCompile(
+                fmt.Sprintf("^(%s)\\/(%s)\\/(%s)(?:\\/\\/(.*))?$",
+                        nameSubRe, nameSubRe, providerSubRe))
+
+        // NameRe is a regular expression defining the format allowed for namespace
+        // or name fields in module registry implementations.
+        NameRe = regexp.MustCompile("^" + nameSubRe + "$")
+
+        // ProviderRe is a regular expression defining the format allowed for
+        // provider fields in module registry implementations.
+        ProviderRe = regexp.MustCompile("^" + providerSubRe + "$")
+
+        // these hostnames are not allowed as registry sources, because they are
+        // already special case module sources in terraform.
+        disallowed = map[string]bool{
+                "github.com":    true,
+                "bitbucket.org": true,
+        }
+)
+
+// Module describes a Terraform Registry Module source.
+type Module struct {
+        // RawHost is the friendly host prefix if one was present. It might be nil
+        // if the original source had no host prefix which implies
+        // PublicRegistryHost but is distinct from having an actual pointer to
+        // PublicRegistryHost since it encodes the fact the original string didn't
+        // include a host prefix at all which is significant for recovering actual
+        // input not just normalized form. Most callers should access it with Host()
+        // which will return public registry host instance if it's nil.
+        RawHost      *FriendlyHost
+        RawNamespace string
+        RawName      string
+        RawProvider  string
+        RawSubmodule string
+}
+
+// NewModule construct a new module source from separate parts. Pass empty
+// string if host or submodule are not needed.
+func NewModule(host, namespace, name, provider, submodule string) (*Module, error) {
+        m := &Module{
+                RawNamespace: namespace,
+                RawName:      name,
+                RawProvider:  provider,
+                RawSubmodule: submodule,
+        }
+        if host != "" {
+                h := NewFriendlyHost(host)
+                if h != nil {
+                        fmt.Println("HOST:", h)
+                        if !h.Valid() || disallowed[h.Display()] {
+                                return nil, ErrInvalidModuleSource
+                        }
+                }
+                m.RawHost = h
+        }
+        return m, nil
+}
+
+// ParseModuleSource attempts to parse source as a Terraform registry module
+// source. If the string is not found to be in a valid format,
+// ErrInvalidModuleSource is returned. Note that this can only be used on
+// "input" strings, e.g. either ones supplied by the user or potentially
+// normalised but in Display form (unicode). It will fail to parse a source with
+// a punycoded domain since this is not permitted input from a user. If you have
+// an already normalized string internally, you can compare it without parsing
+// by comparing with the normalized version of the subject with the normal
+// string equality operator.
+func ParseModuleSource(source string) (*Module, error) {
+        // See if there is a friendly host prefix.
+        host, rest := ParseFriendlyHost(source)
+        if host != nil {
+                if !host.Valid() || disallowed[host.Display()] {
+                        return nil, ErrInvalidModuleSource
+                }
+        }
+
+        matches := moduleSourceRe.FindStringSubmatch(rest)
+        if len(matches) < 4 {
+                return nil, ErrInvalidModuleSource
+        }
+
+        m := &Module{
+                RawHost:      host,
+                RawNamespace: matches[1],
+                RawName:      matches[2],
+                RawProvider:  matches[3],
+        }
+
+        if len(matches) == 5 {
+                m.RawSubmodule = matches[4]
+        }
+
+        return m, nil
+}
+
+// Display returns the source formatted for display to the user in CLI or web
+// output.
+func (m *Module) Display() string {
+        return m.formatWithPrefix(m.normalizedHostPrefix(m.Host().Display()), false)
+}
+
+// Normalized returns the source formatted for internal reference or comparison.
+func (m *Module) Normalized() string {
+        return m.formatWithPrefix(m.normalizedHostPrefix(m.Host().Normalized()), false)
+}
+
+// String returns the source formatted as the user originally typed it assuming
+// it was parsed from user input.
+func (m *Module) String() string {
+        // Don't normalize public registry hostname - leave it exactly like the user
+        // input it.
+        hostPrefix := ""
+        if m.RawHost != nil {
+                hostPrefix = m.RawHost.String() + "/"
+        }
+        return m.formatWithPrefix(hostPrefix, true)
+}
+
+// Equal compares the module source against another instance taking
+// normalization into account.
+func (m *Module) Equal(other *Module) bool {
+        return m.Normalized() == other.Normalized()
+}
+
+// Host returns the FriendlyHost object describing which registry this module is
+// in. If the original source string had not host component this will return the
+// PublicRegistryHost.
+func (m *Module) Host() *FriendlyHost {
+        if m.RawHost == nil {
+                return PublicRegistryHost
+        }
+        return m.RawHost
+}
+
+func (m *Module) normalizedHostPrefix(host string) string {
+        if m.Host().Equal(PublicRegistryHost) {
+                return ""
+        }
+        return host + "/"
+}
+
+func (m *Module) formatWithPrefix(hostPrefix string, preserveCase bool) string {
+        suffix := ""
+        if m.RawSubmodule != "" {
+                suffix = "//" + m.RawSubmodule
+        }
+        str := fmt.Sprintf("%s%s/%s/%s%s", hostPrefix, m.RawNamespace, m.RawName,
+                m.RawProvider, suffix)
+
+        // lower case by default
+        if !preserveCase {
+                return strings.ToLower(str)
+        }
+        return str
+}
+
+// Module returns just the registry ID of the module, without a hostname or
+// suffix.
+func (m *Module) Module() string {
+        return fmt.Sprintf("%s/%s/%s", m.RawNamespace, m.RawName, m.RawProvider)
+}
+
+// SvcHost returns the svchost.Hostname for this module. Since FriendlyHost may
+// contain an invalid hostname, this also returns an error indicating if it
+// could be converted to a svchost.Hostname. If no host is specified, the
+// default PublicRegistryHost is returned.
+func (m *Module) SvcHost() (svchost.Hostname, error) {
+        if m.RawHost == nil {
+                return svchost.ForComparison(PublicRegistryHost.Raw)
+        }
+        return svchost.ForComparison(m.RawHost.Raw)
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/regsrc.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/regsrc.go
new file mode 100644
index 0000000..c430bf1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/regsrc.go
@@ -0,0 +1,8 @@
+// Package regsrc provides helpers for working with source strings that identify
+// resources within a Terraform registry.
+package regsrc
+
+var (
+        // PublicRegistryHost is a FriendlyHost that represents the public registry.
+        PublicRegistryHost = NewFriendlyHost("registry.terraform.io")
+)
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/module.go b/vendor/github.com/hashicorp/terraform/registry/response/module.go
new file mode 100644
index 0000000..3bd2b3d
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/module.go
@@ -0,0 +1,93 @@
+package response
+
+import (
+        "time"
+)
+
+// Module is the response structure with the data for a single module version.
+type Module struct {
+        ID string `json:"id"`
+
+        //---------------------------------------------------------------
+        // Metadata about the overall module.
+
+        Owner       string    `json:"owner"`
+        Namespace   string    `json:"namespace"`
+        Name        string    `json:"name"`
+        Version     string    `json:"version"`
+        Provider    string    `json:"provider"`
+        Description string    `json:"description"`
+        Source      string    `json:"source"`
+        PublishedAt time.Time `json:"published_at"`
+        Downloads   int       `json:"downloads"`
+        Verified    bool      `json:"verified"`
+}
+
+// ModuleDetail represents a module in full detail.
+type ModuleDetail struct {
+        Module
+
+        //---------------------------------------------------------------
+        // Metadata about the overall module. This is only available when
+        // requesting the specific module (not in list responses).
+
+        // Root is the root module.
+        Root *ModuleSubmodule `json:"root"`
+
+        // Submodules are the other submodules that are available within
+        // this module.
+        Submodules []*ModuleSubmodule `json:"submodules"`
+
+        //---------------------------------------------------------------
+        // The fields below are only set when requesting this specific
+        // module. They are available to easily know all available versions
+        // and providers without multiple API calls.
+
+        Providers []string `json:"providers"` // All available providers
+        Versions  []string `json:"versions"`  // All versions
+}
+
+// ModuleSubmodule is the metadata about a specific submodule within
+// a module. This includes the root module as a special case.
+type ModuleSubmodule struct {
+        Path   string `json:"path"`
+        Readme string `json:"readme"`
+        Empty  bool   `json:"empty"`
+
+        Inputs       []*ModuleInput    `json:"inputs"`
+        Outputs      []*ModuleOutput   `json:"outputs"`
+        Dependencies []*ModuleDep      `json:"dependencies"`
+        Resources    []*ModuleResource `json:"resources"`
+}
+
+// ModuleInput is an input for a module.
+type ModuleInput struct {
+        Name        string `json:"name"`
+        Description string `json:"description"`
+        Default     string `json:"default"`
+}
+
+// ModuleOutput is an output for a module.
+type ModuleOutput struct {
+        Name        string `json:"name"`
+        Description string `json:"description"`
+}
+
+// ModuleDep is an output for a module.
+type ModuleDep struct {
+        Name    string `json:"name"`
+        Source  string `json:"source"`
+        Version string `json:"version"`
+}
+
+// ModuleProviderDep is the output for a provider dependency
+type ModuleProviderDep struct {
+        Name    string `json:"name"`
+        Version string `json:"version"`
+}
+
+// ModuleResource is an output for a module.
+type ModuleResource struct {
+        Name string `json:"name"`
+        Type string `json:"type"`
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/module_list.go b/vendor/github.com/hashicorp/terraform/registry/response/module_list.go
new file mode 100644
index 0000000..9783748
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/module_list.go
@@ -0,0 +1,7 @@
+package response
+
+// ModuleList is the response structure for a pageable list of modules.
+type ModuleList struct {
+        Meta    PaginationMeta `json:"meta"`
+        Modules []*Module      `json:"modules"`
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/module_provider.go b/vendor/github.com/hashicorp/terraform/registry/response/module_provider.go
new file mode 100644
index 0000000..e48499d
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/module_provider.go
@@ -0,0 +1,14 @@
+package response
+
+// ModuleProvider represents a single provider for modules.
+type ModuleProvider struct {
+        Name        string `json:"name"`
+        Downloads   int    `json:"downloads"`
+        ModuleCount int    `json:"module_count"`
+}
+
+// ModuleProviderList is the response structure for a pageable list of ModuleProviders.
+type ModuleProviderList struct {
+        Meta      PaginationMeta    `json:"meta"`
+        Providers []*ModuleProvider `json:"providers"`
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/module_versions.go b/vendor/github.com/hashicorp/terraform/registry/response/module_versions.go
new file mode 100644
index 0000000..f69e975
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/module_versions.go
@@ -0,0 +1,32 @@
+package response
+
+// ModuleVersions is the response format that contains all metadata about module
+// versions needed for terraform CLI to resolve version constraints. See RFC
+// TF-042 for details on this format.
+type ModuleVersions struct {
+        Modules []*ModuleProviderVersions `json:"modules"`
+}
+
+// ModuleProviderVersions is the response format for a single module instance,
+// containing metadata about all versions and their dependencies.
+type ModuleProviderVersions struct {
+        Source   string           `json:"source"`
+        Versions []*ModuleVersion `json:"versions"`
+}
+
+// ModuleVersion is the output metadata for a given version needed by CLI to
+// resolve candidate versions to satisfy requirements.
+type ModuleVersion struct {
+        Version    string              `json:"version"`
+        Root       VersionSubmodule    `json:"root"`
+        Submodules []*VersionSubmodule `json:"submodules"`
+}
+
+// VersionSubmodule is the output metadata for a submodule within a given
+// version needed by CLI to resolve candidate versions to satisfy requirements.
+// When representing the Root in JSON the path is omitted.
+type VersionSubmodule struct {
+        Path         string               `json:"path,omitempty"`
+        Providers    []*ModuleProviderDep `json:"providers"`
+        Dependencies []*ModuleDep         `json:"dependencies"`
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/pagination.go b/vendor/github.com/hashicorp/terraform/registry/response/pagination.go
new file mode 100644
index 0000000..75a9254
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/pagination.go
@@ -0,0 +1,65 @@
+package response
+
+import (
+        "net/url"
+        "strconv"
+)
+
+// PaginationMeta is a structure included in responses for pagination.
+type PaginationMeta struct {
+        Limit         int    `json:"limit"`
+        CurrentOffset int    `json:"current_offset"`
+        NextOffset    *int   `json:"next_offset,omitempty"`
+        PrevOffset    *int   `json:"prev_offset,omitempty"`
+        NextURL       string `json:"next_url,omitempty"`
+        PrevURL       string `json:"prev_url,omitempty"`
+}
+
+// NewPaginationMeta populates pagination meta data from result parameters
+func NewPaginationMeta(offset, limit int, hasMore bool, currentURL string) PaginationMeta {
+        pm := PaginationMeta{
+                Limit:         limit,
+                CurrentOffset: offset,
+        }
+
+        // Calculate next/prev offsets, leave nil if not valid pages
+        nextOffset := offset + limit
+        if hasMore {
+                pm.NextOffset = &nextOffset
+        }
+
+        prevOffset := offset - limit
+        if prevOffset < 0 {
+                prevOffset = 0
+        }
+        if prevOffset < offset {
+                pm.PrevOffset = &prevOffset
+        }
+
+        // If URL format provided, populate URLs. Intentionally swallow URL errors for now, API should
+        // catch missing URLs if we call with bad URL arg (and we care about them being present).
+        if currentURL != "" && pm.NextOffset != nil {
+                pm.NextURL, _ = setQueryParam(currentURL, "offset", *pm.NextOffset, 0)
+        }
+        if currentURL != "" && pm.PrevOffset != nil {
+                pm.PrevURL, _ = setQueryParam(currentURL, "offset", *pm.PrevOffset, 0)
+        }
+
+        return pm
+}
+
+func setQueryParam(baseURL, key string, val, defaultVal int) (string, error) {
+        u, err := url.Parse(baseURL)
+        if err != nil {
+                return "", err
+        }
+        q := u.Query()
+        if val == defaultVal {
+                // elide param if it's the default value
+                q.Del(key)
+        } else {
+                q.Set(key, strconv.Itoa(val))
+        }
+        u.RawQuery = q.Encode()
+        return u.String(), nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/redirect.go b/vendor/github.com/hashicorp/terraform/registry/response/redirect.go
new file mode 100644
index 0000000..d5eb49b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/redirect.go
@@ -0,0 +1,6 @@
+package response
+
+// Redirect causes the frontend to perform a window redirect.
+type Redirect struct {
+        URL string `json:"url"`
+}