├── .github └── workflows │ └── ci.yml ├── .gitignore ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── LICENSE ├── README.md ├── abuse_reports └── client.go ├── agent_ingresses └── client.go ├── api_keys └── client.go ├── application_sessions └── client.go ├── application_users └── client.go ├── backends ├── failover │ └── client.go ├── http_response │ └── client.go ├── static_address │ └── client.go ├── tunnel_group │ └── client.go └── weighted │ └── client.go ├── bot_users └── client.go ├── certificate_authorities └── client.go ├── client.go ├── client_config.go ├── client_test.go ├── credentials └── client.go ├── datatypes.go ├── doc.go ├── edge_modules ├── https_edge_mutual_tls │ └── client.go ├── https_edge_route_backend │ └── client.go ├── https_edge_route_circuit_breaker │ └── client.go ├── https_edge_route_compression │ └── client.go ├── https_edge_route_ip_restriction │ └── client.go ├── https_edge_route_oauth │ └── client.go ├── https_edge_route_oidc │ └── client.go ├── https_edge_route_request_headers │ └── client.go ├── https_edge_route_response_headers │ └── client.go ├── https_edge_route_saml │ └── client.go ├── https_edge_route_traffic_policy │ └── client.go ├── https_edge_route_user_agent_filter │ └── client.go ├── https_edge_route_webhook_verification │ └── client.go ├── https_edge_route_websocket_tcp_converter │ └── client.go ├── https_edge_tls_termination │ └── client.go ├── tcp_edge_backend │ └── client.go ├── tcp_edge_ip_restriction │ └── client.go ├── tcp_edge_traffic_policy │ └── client.go ├── tls_edge_backend │ └── client.go ├── tls_edge_ip_restriction │ └── client.go ├── tls_edge_mutual_tls │ └── client.go ├── tls_edge_tls_termination │ └── client.go └── tls_edge_traffic_policy │ └── client.go ├── edges ├── https │ └── client.go ├── https_routes │ └── client.go ├── tcp │ └── client.go └── tls │ └── client.go ├── endpoints └── client.go ├── error.go ├── event_destinations └── client.go ├── event_sources └── client.go ├── event_subscriptions └── client.go ├── go.mod ├── go.sum ├── integration_test.go ├── internal └── api │ ├── client.go │ ├── client_test.go │ └── version.go ├── ip_policies └── client.go ├── ip_policy_rules └── client.go ├── ip_restrictions └── client.go ├── iter.go ├── kubernetes_operators └── client.go ├── reserved_addrs └── client.go ├── reserved_domains └── client.go ├── ssh_certificate_authorities └── client.go ├── ssh_credentials └── client.go ├── ssh_host_certificates └── client.go ├── ssh_user_certificates └── client.go ├── tls_certificates └── client.go ├── transports_test.go ├── tunnel_sessions └── client.go ├── tunnels └── client.go ├── type_helpers.go └── version.go /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | on: [push, pull_request] 3 | jobs: 4 | test: 5 | name: Test / go ${{ matrix.go-version }} 6 | runs-on: ubuntu-latest 7 | timeout-minutes: 10 8 | strategy: 9 | fail-fast: false 10 | matrix: 11 | go-version: 12 | - '1.18' 13 | - '1.19' 14 | - '1.20' 15 | - '1.21' 16 | - '1.22' 17 | - '1.23' 18 | steps: 19 | - uses: actions/checkout@v3 20 | - name: Set up Go ${{ matrix.go-version }} 21 | uses: actions/setup-go@v5 22 | with: 23 | go-version: ${{ matrix.go-version }} 24 | - name: Test 25 | run: go test -v -race -covermode=atomic ./... 26 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | BUILD.bazel 4 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | 2 | ## v7.3.0 3 | * Add `version` to KubernetesOperatorDeploymentUpdate. 4 | 5 | ## v7.2.0 6 | * Add support for `pooling_enabled` on Endpoints. 7 | 8 | ## v7.1.0 9 | * Updates to KubernetesOperators and Bindings (currently in private beta). 10 | 11 | ## v7.0.0 12 | ### Breaking Changes 13 | * Renamed `upstream_proto` to `upstream_protocol` for `endpoint` resources 14 | 15 | ## v6.2.0 16 | * Added support for KubernetesOperators and Bindings (currently in private beta). 17 | 18 | ## v6.1.0 19 | * Added support for Cloud Endpoints (currently in private beta). 20 | * Renamed `principal_id` to `principal` for `endpoint` resources 21 | 22 | ## v6.0.0 23 | ### Breaking Changes 24 | * Renamed the Policy Module to the Traffic Policy Module on HTTP Edge Routes, TCP Edges, and TLS Edges, which allows you to configure rules that can be used to influence and control traffic to and from your upstream service. The Traffic Policy itself is now specified as either a JSON or YAML string. 25 | 26 | ## v5.4.1 27 | 28 | FIXES: 29 | 30 | * Fixed an issue with pagination for some resources, like `reserved_addrs`, by using the `next_page_uri` returned in the response instead of the id of the last resource. 31 | 32 | ## v5.4.0 33 | 34 | ENHANCEMENTS: 35 | 36 | * Added support for the Bot User API. The Bot User API allows you to manage the bots that are registered to your ngrok account. You can automate the creation, management, and deletion of bot users in your account. 37 | 38 | * Added support for the Policy Module on HTTP Edge Routes, TCP Edges, and TLS Edges, which allows you to configure rules that can be used to influence and control traffic to and from your upstream service. 39 | 40 | ## v5.3.1 41 | 42 | INTERNAL: 43 | 44 | * Moved location of BaseClient 45 | 46 | ## v5.3.0 47 | 48 | ENHANCEMENTS: 49 | 50 | * Added support for the Traffic Policy module on TCP edges, TLS edges, and HTTPS edge routes. A Traffic Policy allows traffic to and from your edges to be shaped and influenced by defining rules that contain expression to filter the traffic and actions to take effect. 51 | * Added `static_backend` resource, which defines a static address at which traffic should be forwarded. 52 | 53 | ## v5.2.0 54 | 55 | ENHANCEMENTS: 56 | 57 | * Added support for the User Agent Filter module on HTTPS edge routes. The User Agent Filter module enables you to block bots, crawlers, or certain browsers from accessing your web application. It allows or denies traffic based on the User-Agent header of incoming HTTP requests. 58 | * Added support for the JWT Validation module on HTTPS edge routes. The JWT Validation module allows or denies traffic based on validation of the JSON Web Token (JWT) provided within the request that was initiated to your ngrok endpoints. 59 | 60 | ## v5.1.0 61 | 62 | ENHANCEMENTS: 63 | 64 | * Added `owner_id` field to the `api_key`, `credential`, and `ssh_credential` resources. If supplied at credential creation, ownership will be assigned to the specified User or Bot. Only admins may specify an owner other than themselves. Defaults to the authenticated User or Bot. 65 | * Added `failover_backend`, `http_response_backend`, and `tunnel_group_backend` resources. A Failover backend defines failover behavior within a list of referenced backends. Traffic is sent to the first backend in the list. If that backend is offline or no connection can be established, ngrok attempts to connect to the next backend in the list until one is successful. 66 | 67 | ## v5.0.0 68 | 69 | ### Breaking Changes 70 | 71 | `v5.0.0` has breaking changes. Notably, properties that 72 | previously had pointers to slices or maps no longer have pointers. For instance, 73 | 74 | ```go 75 | Hostports: *[]string `json:"hostports,omitempty"` 76 | ``` 77 | 78 | are now 79 | 80 | ```go 81 | Hostports: []string `json:"hostports,omitempty"` 82 | ``` 83 | 84 | ### Additions 85 | 86 | New clients have been generated for `ApplicationSessions` and `ApplicationUsers`. 87 | 88 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # ngrok Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. 6 | 7 | ## Our Standards 8 | 9 | Examples of behavior that contributes to creating a positive environment include: 10 | 11 | - Using welcoming and inclusive language 12 | - Being respectful of differing viewpoints and experiences 13 | - Gracefully accepting constructive criticism 14 | - Focusing on what is best for the community 15 | - Showing empathy towards other community members 16 | 17 | Examples of unacceptable behavior by participants include: 18 | 19 | - The use of sexualized language or imagery and unwelcome sexual attention or advances 20 | - Trolling, insulting/derogatory comments, and personal or political attacks 21 | - Public or private harassment 22 | - Publishing others' private information, such as a physical or electronic address, without explicit permission 23 | - Other conduct which could reasonably be considered inappropriate in a professional setting 24 | 25 | ## Our Responsibilities 26 | 27 | The ngrok documentation team is responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. 28 | 29 | The ngrok documentation team has the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. 30 | 31 | ## Scope 32 | 33 | This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the ngrok docs project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. 34 | 35 | ## Enforcement 36 | 37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [support@ngrok.com](mailto:support@ngrok.com). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. 38 | 39 | Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. 40 | 41 | ## Attribution 42 | 43 | This Code of Conduct is adapted from the Contributor Covenant, version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. 44 | 45 | For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq 46 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2021 ngrok, Inc. 2 | 3 | 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: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | 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. 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # ngrok API client library for Golang 4 | [![CI](https://github.com/ngrok/ngrok-api-go/actions/workflows/ci.yml/badge.svg)](https://github.com/ngrok/ngrok-api-go/actions/workflows/ci.yml) 5 | [![Go Reference](https://pkg.go.dev/badge/github.com/ngrok/ngrok-api-go.svg)](https://pkg.go.dev/github.com/ngrok/ngrok-api-go/v7) 6 | 7 | This library wraps the [ngrok HTTP API](https://ngrok.com/docs/api) to make it 8 | easier to consume in Go. 9 | 10 | For creating ngrok tunnels directly from your Go application, check out the [ngrok Go Agent SDK](https://github.com/ngrok/ngrok-go) instead. 11 | 12 | ## Installation 13 | 14 | Installation is as simple as using `go get`. 15 | 16 | go get github.com/ngrok/ngrok-api-go/v7 17 | 18 | ## Support 19 | 20 | The best place to get support using this library is through the [ngrok Slack Community](https://ngrok.com/slack). If you find any bugs, please contribute by opening a [new GitHub issue](https://github.com/ngrok/ngrok-api-go/issues/new/choose). 21 | 22 | ## Documentation 23 | 24 | A quickstart guide and a full API reference are included in the [ngrok go API documentation on pkg.go.dev](https://pkg.go.dev/github.com/ngrok/ngrok-api-go/v6) 25 | 26 | ## Quickstart 27 | 28 | Please consult the [documentation](https://pkg.go.dev/github.com/ngrok/ngrok-api-go/v6) for additional examples. 29 | 30 | ### Create an IP Policy that allows traffic from some subnets 31 | 32 | ```go 33 | package main 34 | 35 | import ( 36 | "context" 37 | "fmt" 38 | "os" 39 | 40 | "github.com/ngrok/ngrok-api-go/v7" 41 | "github.com/ngrok/ngrok-api-go/v7/ip_policies" 42 | "github.com/ngrok/ngrok-api-go/v7/ip_policy_rules" 43 | ) 44 | 45 | func main() { 46 | fmt.Println(example(context.Background())) 47 | } 48 | 49 | func example(ctx context.Context) error { 50 | // create clients to api resources 51 | clientConfig := ngrok.NewClientConfig(os.Getenv("NGROK_API_KEY")) 52 | policies := ip_policies.NewClient(clientConfig) 53 | policyRules := ip_policy_rules.NewClient(clientConfig) 54 | 55 | // create the ip policy 56 | policy, err := policies.Create(ctx, &ngrok.IPPolicyCreate{}) 57 | if err != nil { 58 | return err 59 | } 60 | fmt.Println(policy) 61 | 62 | // create rules for each cidr 63 | for _, cidr := range []string{"24.0.0.0/8", "12.0.0.0/8"} { 64 | rule, err := policyRules.Create(ctx, &ngrok.IPPolicyRuleCreate{ 65 | CIDR: cidr, 66 | IPPolicyID: policy.ID, 67 | Action: ngrok.String("allow"), 68 | }) 69 | if err != nil { 70 | return err 71 | } 72 | fmt.Println(rule) 73 | } 74 | return nil 75 | } 76 | ``` 77 | 78 | ### List all online tunnels 79 | 80 | ```go 81 | package main 82 | 83 | import ( 84 | "context" 85 | "fmt" 86 | "os" 87 | 88 | "github.com/ngrok/ngrok-api-go/v7" 89 | "github.com/ngrok/ngrok-api-go/v7/tunnels" 90 | ) 91 | 92 | func main() { 93 | fmt.Println(example(context.Background())) 94 | } 95 | 96 | func example(ctx context.Context) error { 97 | // construct the api client 98 | clientConfig := ngrok.NewClientConfig(os.Getenv("NGROK_API_KEY")) 99 | 100 | // list all online tunnels 101 | tunnels := tunnels.NewClient(clientConfig) 102 | iter := tunnels.List(nil) 103 | for iter.Next(ctx) { 104 | fmt.Println(iter.Item()) 105 | } 106 | if err := iter.Err(); err != nil { 107 | return err 108 | } 109 | return nil 110 | } 111 | ``` 112 | -------------------------------------------------------------------------------- /abuse_reports/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package abuse_reports 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // Abuse Reports allow you to submit take-down requests for URLs hosted by 16 | // ngrok that violate ngrok's terms of service. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // Creates a new abuse report which will be reviewed by our system and abuse 27 | // response team. This API is only available to authorized accounts. Contact 28 | // abuse@ngrok.com to request access 29 | // 30 | // https://ngrok.com/docs/api#api-abuse-reports-create 31 | func (c *Client) Create(ctx context.Context, arg *ngrok.AbuseReportCreate) (*ngrok.AbuseReport, error) { 32 | var res ngrok.AbuseReport 33 | var path bytes.Buffer 34 | if err := template.Must(template.New("create_path").Parse("/abuse_reports")).Execute(&path, arg); err != nil { 35 | panic(err) 36 | } 37 | var ( 38 | apiURL = &url.URL{Path: path.String()} 39 | bodyArg interface{} 40 | ) 41 | apiURL.Path = path.String() 42 | bodyArg = arg 43 | 44 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 45 | return nil, err 46 | } 47 | return &res, nil 48 | } 49 | 50 | // Get the detailed status of abuse report by ID. 51 | // 52 | // https://ngrok.com/docs/api#api-abuse-reports-get 53 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.AbuseReport, error) { 54 | arg := &ngrok.Item{ID: id} 55 | 56 | var res ngrok.AbuseReport 57 | var path bytes.Buffer 58 | if err := template.Must(template.New("get_path").Parse("/abuse_reports/{{ .ID }}")).Execute(&path, arg); err != nil { 59 | panic(err) 60 | } 61 | arg.ID = "" 62 | var ( 63 | apiURL = &url.URL{Path: path.String()} 64 | bodyArg interface{} 65 | ) 66 | apiURL.Path = path.String() 67 | 68 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 69 | return nil, err 70 | } 71 | return &res, nil 72 | } 73 | -------------------------------------------------------------------------------- /agent_ingresses/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package agent_ingresses 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create a new Agent Ingress. The ngrok agent can be configured to connect to 24 | // ngrok via the new set of addresses on the returned Agent Ingress. 25 | // 26 | // https://ngrok.com/docs/api#api-agent-ingresses-create 27 | func (c *Client) Create(ctx context.Context, arg *ngrok.AgentIngressCreate) (*ngrok.AgentIngress, error) { 28 | var res ngrok.AgentIngress 29 | var path bytes.Buffer 30 | if err := template.Must(template.New("create_path").Parse("/agent_ingresses")).Execute(&path, arg); err != nil { 31 | panic(err) 32 | } 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg 39 | 40 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | // Delete an Agent Ingress by ID 47 | // 48 | // https://ngrok.com/docs/api#api-agent-ingresses-delete 49 | func (c *Client) Delete(ctx context.Context, id string) error { 50 | arg := &ngrok.Item{ID: id} 51 | 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("delete_path").Parse("/agent_ingresses/{{ .ID }}")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.ID = "" 57 | var ( 58 | apiURL = &url.URL{Path: path.String()} 59 | bodyArg interface{} 60 | ) 61 | apiURL.Path = path.String() 62 | 63 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 64 | return err 65 | } 66 | return nil 67 | } 68 | 69 | // Get the details of an Agent Ingress by ID. 70 | // 71 | // https://ngrok.com/docs/api#api-agent-ingresses-get 72 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.AgentIngress, error) { 73 | arg := &ngrok.Item{ID: id} 74 | 75 | var res ngrok.AgentIngress 76 | var path bytes.Buffer 77 | if err := template.Must(template.New("get_path").Parse("/agent_ingresses/{{ .ID }}")).Execute(&path, arg); err != nil { 78 | panic(err) 79 | } 80 | arg.ID = "" 81 | var ( 82 | apiURL = &url.URL{Path: path.String()} 83 | bodyArg interface{} 84 | ) 85 | apiURL.Path = path.String() 86 | 87 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 88 | return nil, err 89 | } 90 | return &res, nil 91 | } 92 | 93 | // List all Agent Ingresses owned by this account 94 | // 95 | // https://ngrok.com/docs/api#api-agent-ingresses-list 96 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.AgentIngress] { 97 | if paging == nil { 98 | paging = new(ngrok.Paging) 99 | } 100 | var path bytes.Buffer 101 | if err := template.Must(template.New("list_path").Parse("/agent_ingresses")).Execute(&path, paging); err != nil { 102 | panic(err) 103 | } 104 | var apiURL = &url.URL{Path: path.String()} 105 | queryVals := make(url.Values) 106 | if paging.BeforeID != nil { 107 | queryVals.Set("before_id", *paging.BeforeID) 108 | } 109 | if paging.Limit != nil { 110 | queryVals.Set("limit", *paging.Limit) 111 | } 112 | apiURL.RawQuery = queryVals.Encode() 113 | return &iterAgentIngress{ 114 | client: c, 115 | n: -1, 116 | nextPage: apiURL, 117 | } 118 | } 119 | 120 | // iter allows the caller to iterate through a list of values while 121 | // automatically fetching new pages worth of values from the API. 122 | type iterAgentIngress struct { 123 | client *Client 124 | n int 125 | items []ngrok.AgentIngress 126 | err error 127 | 128 | nextPage *url.URL 129 | } 130 | 131 | // Next returns true if there is another value available in the iterator. If it 132 | // returs true it also advances the iterator to that next available item. 133 | func (it *iterAgentIngress) Next(ctx context.Context) bool { 134 | // no more if there is an error 135 | if it.err != nil { 136 | return false 137 | } 138 | 139 | // advance the iterator 140 | it.n += 1 141 | 142 | // is there an available item? 143 | if it.n < len(it.items) { 144 | return true 145 | } 146 | 147 | // no more items, do we have a next page? 148 | if it.nextPage == nil { 149 | return false 150 | } 151 | 152 | // fetch the next page 153 | var resp ngrok.AgentIngressList 154 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 155 | if err != nil { 156 | it.err = err 157 | return false 158 | } 159 | 160 | // parse the next page URI as soon as we get it and store it 161 | // so we can use it on the next fetch 162 | if resp.NextPageURI != nil { 163 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 164 | if it.err != nil { 165 | return false 166 | } 167 | } else { 168 | it.nextPage = nil 169 | } 170 | 171 | // page with zero items means there are no more 172 | if len(resp.Ingresses) == 0 { 173 | return false 174 | } 175 | 176 | it.n = -1 177 | it.items = resp.Ingresses 178 | return it.Next(ctx) 179 | } 180 | 181 | // Item() returns the AgentIngress currently 182 | // pointed to by the iterator. 183 | func (it *iterAgentIngress) Item() *ngrok.AgentIngress { 184 | return &it.items[it.n] 185 | } 186 | 187 | // If Next() returned false because an error was encountered while fetching the 188 | // next value Err() will return that error. A caller should always check Err() 189 | // after Next() returns false. 190 | func (it *iterAgentIngress) Err() error { 191 | return it.err 192 | } 193 | 194 | // Update attributes of an Agent Ingress by ID. 195 | // 196 | // https://ngrok.com/docs/api#api-agent-ingresses-update 197 | func (c *Client) Update(ctx context.Context, arg *ngrok.AgentIngressUpdate) (*ngrok.AgentIngress, error) { 198 | if arg == nil { 199 | arg = new(ngrok.AgentIngressUpdate) 200 | } 201 | var res ngrok.AgentIngress 202 | var path bytes.Buffer 203 | if err := template.Must(template.New("update_path").Parse("/agent_ingresses/{{ .ID }}")).Execute(&path, arg); err != nil { 204 | panic(err) 205 | } 206 | arg.ID = "" 207 | var ( 208 | apiURL = &url.URL{Path: path.String()} 209 | bodyArg interface{} 210 | ) 211 | apiURL.Path = path.String() 212 | bodyArg = arg 213 | 214 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 215 | return nil, err 216 | } 217 | return &res, nil 218 | } 219 | -------------------------------------------------------------------------------- /api_keys/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package api_keys 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // API Keys are used to authenticate to the ngrok 16 | // API (https://ngrok.com/docs/api#authentication). You may use the API itself 17 | // to provision and manage API Keys but you'll need to provision your first API 18 | // key from the API Keys page (https://dashboard.ngrok.com/api/keys) on your 19 | // ngrok.com dashboard. 20 | 21 | type Client struct { 22 | apiClient *api.Client 23 | } 24 | 25 | func NewClient(cfg *ngrok.ClientConfig) *Client { 26 | return &Client{apiClient: api.NewClient(cfg)} 27 | } 28 | 29 | // Create a new API key. The generated API key can be used to authenticate to the 30 | // ngrok API. 31 | // 32 | // https://ngrok.com/docs/api#api-api-keys-create 33 | func (c *Client) Create(ctx context.Context, arg *ngrok.APIKeyCreate) (*ngrok.APIKey, error) { 34 | if arg == nil { 35 | arg = new(ngrok.APIKeyCreate) 36 | } 37 | var res ngrok.APIKey 38 | var path bytes.Buffer 39 | if err := template.Must(template.New("create_path").Parse("/api_keys")).Execute(&path, arg); err != nil { 40 | panic(err) 41 | } 42 | var ( 43 | apiURL = &url.URL{Path: path.String()} 44 | bodyArg interface{} 45 | ) 46 | apiURL.Path = path.String() 47 | bodyArg = arg 48 | 49 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 50 | return nil, err 51 | } 52 | return &res, nil 53 | } 54 | 55 | // Delete an API key by ID 56 | // 57 | // https://ngrok.com/docs/api#api-api-keys-delete 58 | func (c *Client) Delete(ctx context.Context, id string) error { 59 | arg := &ngrok.Item{ID: id} 60 | 61 | var path bytes.Buffer 62 | if err := template.Must(template.New("delete_path").Parse("/api_keys/{{ .ID }}")).Execute(&path, arg); err != nil { 63 | panic(err) 64 | } 65 | arg.ID = "" 66 | var ( 67 | apiURL = &url.URL{Path: path.String()} 68 | bodyArg interface{} 69 | ) 70 | apiURL.Path = path.String() 71 | 72 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 73 | return err 74 | } 75 | return nil 76 | } 77 | 78 | // Get the details of an API key by ID. 79 | // 80 | // https://ngrok.com/docs/api#api-api-keys-get 81 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.APIKey, error) { 82 | arg := &ngrok.Item{ID: id} 83 | 84 | var res ngrok.APIKey 85 | var path bytes.Buffer 86 | if err := template.Must(template.New("get_path").Parse("/api_keys/{{ .ID }}")).Execute(&path, arg); err != nil { 87 | panic(err) 88 | } 89 | arg.ID = "" 90 | var ( 91 | apiURL = &url.URL{Path: path.String()} 92 | bodyArg interface{} 93 | ) 94 | apiURL.Path = path.String() 95 | 96 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 97 | return nil, err 98 | } 99 | return &res, nil 100 | } 101 | 102 | // List all API keys owned by this account 103 | // 104 | // https://ngrok.com/docs/api#api-api-keys-list 105 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.APIKey] { 106 | if paging == nil { 107 | paging = new(ngrok.Paging) 108 | } 109 | var path bytes.Buffer 110 | if err := template.Must(template.New("list_path").Parse("/api_keys")).Execute(&path, paging); err != nil { 111 | panic(err) 112 | } 113 | var apiURL = &url.URL{Path: path.String()} 114 | queryVals := make(url.Values) 115 | if paging.BeforeID != nil { 116 | queryVals.Set("before_id", *paging.BeforeID) 117 | } 118 | if paging.Limit != nil { 119 | queryVals.Set("limit", *paging.Limit) 120 | } 121 | apiURL.RawQuery = queryVals.Encode() 122 | return &iterAPIKey{ 123 | client: c, 124 | n: -1, 125 | nextPage: apiURL, 126 | } 127 | } 128 | 129 | // iter allows the caller to iterate through a list of values while 130 | // automatically fetching new pages worth of values from the API. 131 | type iterAPIKey struct { 132 | client *Client 133 | n int 134 | items []ngrok.APIKey 135 | err error 136 | 137 | nextPage *url.URL 138 | } 139 | 140 | // Next returns true if there is another value available in the iterator. If it 141 | // returs true it also advances the iterator to that next available item. 142 | func (it *iterAPIKey) Next(ctx context.Context) bool { 143 | // no more if there is an error 144 | if it.err != nil { 145 | return false 146 | } 147 | 148 | // advance the iterator 149 | it.n += 1 150 | 151 | // is there an available item? 152 | if it.n < len(it.items) { 153 | return true 154 | } 155 | 156 | // no more items, do we have a next page? 157 | if it.nextPage == nil { 158 | return false 159 | } 160 | 161 | // fetch the next page 162 | var resp ngrok.APIKeyList 163 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 164 | if err != nil { 165 | it.err = err 166 | return false 167 | } 168 | 169 | // parse the next page URI as soon as we get it and store it 170 | // so we can use it on the next fetch 171 | if resp.NextPageURI != nil { 172 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 173 | if it.err != nil { 174 | return false 175 | } 176 | } else { 177 | it.nextPage = nil 178 | } 179 | 180 | // page with zero items means there are no more 181 | if len(resp.Keys) == 0 { 182 | return false 183 | } 184 | 185 | it.n = -1 186 | it.items = resp.Keys 187 | return it.Next(ctx) 188 | } 189 | 190 | // Item() returns the APIKey currently 191 | // pointed to by the iterator. 192 | func (it *iterAPIKey) Item() *ngrok.APIKey { 193 | return &it.items[it.n] 194 | } 195 | 196 | // If Next() returned false because an error was encountered while fetching the 197 | // next value Err() will return that error. A caller should always check Err() 198 | // after Next() returns false. 199 | func (it *iterAPIKey) Err() error { 200 | return it.err 201 | } 202 | 203 | // Update attributes of an API key by ID. 204 | // 205 | // https://ngrok.com/docs/api#api-api-keys-update 206 | func (c *Client) Update(ctx context.Context, arg *ngrok.APIKeyUpdate) (*ngrok.APIKey, error) { 207 | if arg == nil { 208 | arg = new(ngrok.APIKeyUpdate) 209 | } 210 | var res ngrok.APIKey 211 | var path bytes.Buffer 212 | if err := template.Must(template.New("update_path").Parse("/api_keys/{{ .ID }}")).Execute(&path, arg); err != nil { 213 | panic(err) 214 | } 215 | arg.ID = "" 216 | var ( 217 | apiURL = &url.URL{Path: path.String()} 218 | bodyArg interface{} 219 | ) 220 | apiURL.Path = path.String() 221 | bodyArg = arg 222 | 223 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 224 | return nil, err 225 | } 226 | return &res, nil 227 | } 228 | -------------------------------------------------------------------------------- /application_sessions/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package application_sessions 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Get an application session by ID. 24 | // 25 | // https://ngrok.com/docs/api#api-application-sessions-get 26 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.ApplicationSession, error) { 27 | arg := &ngrok.Item{ID: id} 28 | 29 | var res ngrok.ApplicationSession 30 | var path bytes.Buffer 31 | if err := template.Must(template.New("get_path").Parse("/app/sessions/{{ .ID }}")).Execute(&path, arg); err != nil { 32 | panic(err) 33 | } 34 | arg.ID = "" 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | 41 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | // Delete an application session by ID. 48 | // 49 | // https://ngrok.com/docs/api#api-application-sessions-delete 50 | func (c *Client) Delete(ctx context.Context, id string) error { 51 | arg := &ngrok.Item{ID: id} 52 | 53 | var path bytes.Buffer 54 | if err := template.Must(template.New("delete_path").Parse("/app/sessions/{{ .ID }}")).Execute(&path, arg); err != nil { 55 | panic(err) 56 | } 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | // List all application sessions for this account. 71 | // 72 | // https://ngrok.com/docs/api#api-application-sessions-list 73 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.ApplicationSession] { 74 | if paging == nil { 75 | paging = new(ngrok.Paging) 76 | } 77 | var path bytes.Buffer 78 | if err := template.Must(template.New("list_path").Parse("/app/sessions")).Execute(&path, paging); err != nil { 79 | panic(err) 80 | } 81 | var apiURL = &url.URL{Path: path.String()} 82 | queryVals := make(url.Values) 83 | if paging.BeforeID != nil { 84 | queryVals.Set("before_id", *paging.BeforeID) 85 | } 86 | if paging.Limit != nil { 87 | queryVals.Set("limit", *paging.Limit) 88 | } 89 | apiURL.RawQuery = queryVals.Encode() 90 | return &iterApplicationSession{ 91 | client: c, 92 | n: -1, 93 | nextPage: apiURL, 94 | } 95 | } 96 | 97 | // iter allows the caller to iterate through a list of values while 98 | // automatically fetching new pages worth of values from the API. 99 | type iterApplicationSession struct { 100 | client *Client 101 | n int 102 | items []ngrok.ApplicationSession 103 | err error 104 | 105 | nextPage *url.URL 106 | } 107 | 108 | // Next returns true if there is another value available in the iterator. If it 109 | // returs true it also advances the iterator to that next available item. 110 | func (it *iterApplicationSession) Next(ctx context.Context) bool { 111 | // no more if there is an error 112 | if it.err != nil { 113 | return false 114 | } 115 | 116 | // advance the iterator 117 | it.n += 1 118 | 119 | // is there an available item? 120 | if it.n < len(it.items) { 121 | return true 122 | } 123 | 124 | // no more items, do we have a next page? 125 | if it.nextPage == nil { 126 | return false 127 | } 128 | 129 | // fetch the next page 130 | var resp ngrok.ApplicationSessionList 131 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 132 | if err != nil { 133 | it.err = err 134 | return false 135 | } 136 | 137 | // parse the next page URI as soon as we get it and store it 138 | // so we can use it on the next fetch 139 | if resp.NextPageURI != nil { 140 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 141 | if it.err != nil { 142 | return false 143 | } 144 | } else { 145 | it.nextPage = nil 146 | } 147 | 148 | // page with zero items means there are no more 149 | if len(resp.ApplicationSessions) == 0 { 150 | return false 151 | } 152 | 153 | it.n = -1 154 | it.items = resp.ApplicationSessions 155 | return it.Next(ctx) 156 | } 157 | 158 | // Item() returns the ApplicationSession currently 159 | // pointed to by the iterator. 160 | func (it *iterApplicationSession) Item() *ngrok.ApplicationSession { 161 | return &it.items[it.n] 162 | } 163 | 164 | // If Next() returned false because an error was encountered while fetching the 165 | // next value Err() will return that error. A caller should always check Err() 166 | // after Next() returns false. 167 | func (it *iterApplicationSession) Err() error { 168 | return it.err 169 | } 170 | -------------------------------------------------------------------------------- /application_users/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package application_users 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Get an application user by ID. 24 | // 25 | // https://ngrok.com/docs/api#api-application-users-get 26 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.ApplicationUser, error) { 27 | arg := &ngrok.Item{ID: id} 28 | 29 | var res ngrok.ApplicationUser 30 | var path bytes.Buffer 31 | if err := template.Must(template.New("get_path").Parse("/app/users/{{ .ID }}")).Execute(&path, arg); err != nil { 32 | panic(err) 33 | } 34 | arg.ID = "" 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | 41 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | // Delete an application user by ID. 48 | // 49 | // https://ngrok.com/docs/api#api-application-users-delete 50 | func (c *Client) Delete(ctx context.Context, id string) error { 51 | arg := &ngrok.Item{ID: id} 52 | 53 | var path bytes.Buffer 54 | if err := template.Must(template.New("delete_path").Parse("/app/users/{{ .ID }}")).Execute(&path, arg); err != nil { 55 | panic(err) 56 | } 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | // List all application users for this account. 71 | // 72 | // https://ngrok.com/docs/api#api-application-users-list 73 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.ApplicationUser] { 74 | if paging == nil { 75 | paging = new(ngrok.Paging) 76 | } 77 | var path bytes.Buffer 78 | if err := template.Must(template.New("list_path").Parse("/app/users")).Execute(&path, paging); err != nil { 79 | panic(err) 80 | } 81 | var apiURL = &url.URL{Path: path.String()} 82 | queryVals := make(url.Values) 83 | if paging.BeforeID != nil { 84 | queryVals.Set("before_id", *paging.BeforeID) 85 | } 86 | if paging.Limit != nil { 87 | queryVals.Set("limit", *paging.Limit) 88 | } 89 | apiURL.RawQuery = queryVals.Encode() 90 | return &iterApplicationUser{ 91 | client: c, 92 | n: -1, 93 | nextPage: apiURL, 94 | } 95 | } 96 | 97 | // iter allows the caller to iterate through a list of values while 98 | // automatically fetching new pages worth of values from the API. 99 | type iterApplicationUser struct { 100 | client *Client 101 | n int 102 | items []ngrok.ApplicationUser 103 | err error 104 | 105 | nextPage *url.URL 106 | } 107 | 108 | // Next returns true if there is another value available in the iterator. If it 109 | // returs true it also advances the iterator to that next available item. 110 | func (it *iterApplicationUser) Next(ctx context.Context) bool { 111 | // no more if there is an error 112 | if it.err != nil { 113 | return false 114 | } 115 | 116 | // advance the iterator 117 | it.n += 1 118 | 119 | // is there an available item? 120 | if it.n < len(it.items) { 121 | return true 122 | } 123 | 124 | // no more items, do we have a next page? 125 | if it.nextPage == nil { 126 | return false 127 | } 128 | 129 | // fetch the next page 130 | var resp ngrok.ApplicationUserList 131 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 132 | if err != nil { 133 | it.err = err 134 | return false 135 | } 136 | 137 | // parse the next page URI as soon as we get it and store it 138 | // so we can use it on the next fetch 139 | if resp.NextPageURI != nil { 140 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 141 | if it.err != nil { 142 | return false 143 | } 144 | } else { 145 | it.nextPage = nil 146 | } 147 | 148 | // page with zero items means there are no more 149 | if len(resp.ApplicationUsers) == 0 { 150 | return false 151 | } 152 | 153 | it.n = -1 154 | it.items = resp.ApplicationUsers 155 | return it.Next(ctx) 156 | } 157 | 158 | // Item() returns the ApplicationUser currently 159 | // pointed to by the iterator. 160 | func (it *iterApplicationUser) Item() *ngrok.ApplicationUser { 161 | return &it.items[it.n] 162 | } 163 | 164 | // If Next() returned false because an error was encountered while fetching the 165 | // next value Err() will return that error. A caller should always check Err() 166 | // after Next() returns false. 167 | func (it *iterApplicationUser) Err() error { 168 | return it.err 169 | } 170 | -------------------------------------------------------------------------------- /backends/http_response/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package http_response 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Create(ctx context.Context, arg *ngrok.HTTPResponseBackendCreate) (*ngrok.HTTPResponseBackend, error) { 24 | if arg == nil { 25 | arg = new(ngrok.HTTPResponseBackendCreate) 26 | } 27 | var res ngrok.HTTPResponseBackend 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("create_path").Parse("/backends/http_response")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | var ( 33 | apiURL = &url.URL{Path: path.String()} 34 | bodyArg interface{} 35 | ) 36 | apiURL.Path = path.String() 37 | bodyArg = arg 38 | 39 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 40 | return nil, err 41 | } 42 | return &res, nil 43 | } 44 | 45 | func (c *Client) Delete(ctx context.Context, id string) error { 46 | arg := &ngrok.Item{ID: id} 47 | 48 | var path bytes.Buffer 49 | if err := template.Must(template.New("delete_path").Parse("/backends/http_response/{{ .ID }}")).Execute(&path, arg); err != nil { 50 | panic(err) 51 | } 52 | arg.ID = "" 53 | var ( 54 | apiURL = &url.URL{Path: path.String()} 55 | bodyArg interface{} 56 | ) 57 | apiURL.Path = path.String() 58 | 59 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 60 | return err 61 | } 62 | return nil 63 | } 64 | 65 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.HTTPResponseBackend, error) { 66 | arg := &ngrok.Item{ID: id} 67 | 68 | var res ngrok.HTTPResponseBackend 69 | var path bytes.Buffer 70 | if err := template.Must(template.New("get_path").Parse("/backends/http_response/{{ .ID }}")).Execute(&path, arg); err != nil { 71 | panic(err) 72 | } 73 | arg.ID = "" 74 | var ( 75 | apiURL = &url.URL{Path: path.String()} 76 | bodyArg interface{} 77 | ) 78 | apiURL.Path = path.String() 79 | 80 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 81 | return nil, err 82 | } 83 | return &res, nil 84 | } 85 | 86 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.HTTPResponseBackend] { 87 | if paging == nil { 88 | paging = new(ngrok.Paging) 89 | } 90 | var path bytes.Buffer 91 | if err := template.Must(template.New("list_path").Parse("/backends/http_response")).Execute(&path, paging); err != nil { 92 | panic(err) 93 | } 94 | var apiURL = &url.URL{Path: path.String()} 95 | queryVals := make(url.Values) 96 | if paging.BeforeID != nil { 97 | queryVals.Set("before_id", *paging.BeforeID) 98 | } 99 | if paging.Limit != nil { 100 | queryVals.Set("limit", *paging.Limit) 101 | } 102 | apiURL.RawQuery = queryVals.Encode() 103 | return &iterHTTPResponseBackend{ 104 | client: c, 105 | n: -1, 106 | nextPage: apiURL, 107 | } 108 | } 109 | 110 | // iter allows the caller to iterate through a list of values while 111 | // automatically fetching new pages worth of values from the API. 112 | type iterHTTPResponseBackend struct { 113 | client *Client 114 | n int 115 | items []ngrok.HTTPResponseBackend 116 | err error 117 | 118 | nextPage *url.URL 119 | } 120 | 121 | // Next returns true if there is another value available in the iterator. If it 122 | // returs true it also advances the iterator to that next available item. 123 | func (it *iterHTTPResponseBackend) Next(ctx context.Context) bool { 124 | // no more if there is an error 125 | if it.err != nil { 126 | return false 127 | } 128 | 129 | // advance the iterator 130 | it.n += 1 131 | 132 | // is there an available item? 133 | if it.n < len(it.items) { 134 | return true 135 | } 136 | 137 | // no more items, do we have a next page? 138 | if it.nextPage == nil { 139 | return false 140 | } 141 | 142 | // fetch the next page 143 | var resp ngrok.HTTPResponseBackendList 144 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 145 | if err != nil { 146 | it.err = err 147 | return false 148 | } 149 | 150 | // parse the next page URI as soon as we get it and store it 151 | // so we can use it on the next fetch 152 | if resp.NextPageURI != nil { 153 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 154 | if it.err != nil { 155 | return false 156 | } 157 | } else { 158 | it.nextPage = nil 159 | } 160 | 161 | // page with zero items means there are no more 162 | if len(resp.Backends) == 0 { 163 | return false 164 | } 165 | 166 | it.n = -1 167 | it.items = resp.Backends 168 | return it.Next(ctx) 169 | } 170 | 171 | // Item() returns the HTTPResponseBackend currently 172 | // pointed to by the iterator. 173 | func (it *iterHTTPResponseBackend) Item() *ngrok.HTTPResponseBackend { 174 | return &it.items[it.n] 175 | } 176 | 177 | // If Next() returned false because an error was encountered while fetching the 178 | // next value Err() will return that error. A caller should always check Err() 179 | // after Next() returns false. 180 | func (it *iterHTTPResponseBackend) Err() error { 181 | return it.err 182 | } 183 | 184 | func (c *Client) Update(ctx context.Context, arg *ngrok.HTTPResponseBackendUpdate) (*ngrok.HTTPResponseBackend, error) { 185 | if arg == nil { 186 | arg = new(ngrok.HTTPResponseBackendUpdate) 187 | } 188 | var res ngrok.HTTPResponseBackend 189 | var path bytes.Buffer 190 | if err := template.Must(template.New("update_path").Parse("/backends/http_response/{{ .ID }}")).Execute(&path, arg); err != nil { 191 | panic(err) 192 | } 193 | arg.ID = "" 194 | var ( 195 | apiURL = &url.URL{Path: path.String()} 196 | bodyArg interface{} 197 | ) 198 | apiURL.Path = path.String() 199 | bodyArg = arg 200 | 201 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 202 | return nil, err 203 | } 204 | return &res, nil 205 | } 206 | -------------------------------------------------------------------------------- /backends/static_address/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package static_address 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // A static backend sends traffic to a TCP address (hostname and port) that 16 | // is reachable on the public internet. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // Create a new static backend 27 | // 28 | // https://ngrok.com/docs/api#api-static-backends-create 29 | func (c *Client) Create(ctx context.Context, arg *ngrok.StaticBackendCreate) (*ngrok.StaticBackend, error) { 30 | if arg == nil { 31 | arg = new(ngrok.StaticBackendCreate) 32 | } 33 | var res ngrok.StaticBackend 34 | var path bytes.Buffer 35 | if err := template.Must(template.New("create_path").Parse("/backends/static")).Execute(&path, arg); err != nil { 36 | panic(err) 37 | } 38 | var ( 39 | apiURL = &url.URL{Path: path.String()} 40 | bodyArg interface{} 41 | ) 42 | apiURL.Path = path.String() 43 | bodyArg = arg 44 | 45 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 46 | return nil, err 47 | } 48 | return &res, nil 49 | } 50 | 51 | // Delete a static backend by ID. 52 | // 53 | // https://ngrok.com/docs/api#api-static-backends-delete 54 | func (c *Client) Delete(ctx context.Context, id string) error { 55 | arg := &ngrok.Item{ID: id} 56 | 57 | var path bytes.Buffer 58 | if err := template.Must(template.New("delete_path").Parse("/backends/static/{{ .ID }}")).Execute(&path, arg); err != nil { 59 | panic(err) 60 | } 61 | arg.ID = "" 62 | var ( 63 | apiURL = &url.URL{Path: path.String()} 64 | bodyArg interface{} 65 | ) 66 | apiURL.Path = path.String() 67 | 68 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 69 | return err 70 | } 71 | return nil 72 | } 73 | 74 | // Get detailed information about a static backend by ID 75 | // 76 | // https://ngrok.com/docs/api#api-static-backends-get 77 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.StaticBackend, error) { 78 | arg := &ngrok.Item{ID: id} 79 | 80 | var res ngrok.StaticBackend 81 | var path bytes.Buffer 82 | if err := template.Must(template.New("get_path").Parse("/backends/static/{{ .ID }}")).Execute(&path, arg); err != nil { 83 | panic(err) 84 | } 85 | arg.ID = "" 86 | var ( 87 | apiURL = &url.URL{Path: path.String()} 88 | bodyArg interface{} 89 | ) 90 | apiURL.Path = path.String() 91 | 92 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 93 | return nil, err 94 | } 95 | return &res, nil 96 | } 97 | 98 | // List all static backends on this account 99 | // 100 | // https://ngrok.com/docs/api#api-static-backends-list 101 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.StaticBackend] { 102 | if paging == nil { 103 | paging = new(ngrok.Paging) 104 | } 105 | var path bytes.Buffer 106 | if err := template.Must(template.New("list_path").Parse("/backends/static")).Execute(&path, paging); err != nil { 107 | panic(err) 108 | } 109 | var apiURL = &url.URL{Path: path.String()} 110 | queryVals := make(url.Values) 111 | if paging.BeforeID != nil { 112 | queryVals.Set("before_id", *paging.BeforeID) 113 | } 114 | if paging.Limit != nil { 115 | queryVals.Set("limit", *paging.Limit) 116 | } 117 | apiURL.RawQuery = queryVals.Encode() 118 | return &iterStaticBackend{ 119 | client: c, 120 | n: -1, 121 | nextPage: apiURL, 122 | } 123 | } 124 | 125 | // iter allows the caller to iterate through a list of values while 126 | // automatically fetching new pages worth of values from the API. 127 | type iterStaticBackend struct { 128 | client *Client 129 | n int 130 | items []ngrok.StaticBackend 131 | err error 132 | 133 | nextPage *url.URL 134 | } 135 | 136 | // Next returns true if there is another value available in the iterator. If it 137 | // returs true it also advances the iterator to that next available item. 138 | func (it *iterStaticBackend) Next(ctx context.Context) bool { 139 | // no more if there is an error 140 | if it.err != nil { 141 | return false 142 | } 143 | 144 | // advance the iterator 145 | it.n += 1 146 | 147 | // is there an available item? 148 | if it.n < len(it.items) { 149 | return true 150 | } 151 | 152 | // no more items, do we have a next page? 153 | if it.nextPage == nil { 154 | return false 155 | } 156 | 157 | // fetch the next page 158 | var resp ngrok.StaticBackendList 159 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 160 | if err != nil { 161 | it.err = err 162 | return false 163 | } 164 | 165 | // parse the next page URI as soon as we get it and store it 166 | // so we can use it on the next fetch 167 | if resp.NextPageURI != nil { 168 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 169 | if it.err != nil { 170 | return false 171 | } 172 | } else { 173 | it.nextPage = nil 174 | } 175 | 176 | // page with zero items means there are no more 177 | if len(resp.Backends) == 0 { 178 | return false 179 | } 180 | 181 | it.n = -1 182 | it.items = resp.Backends 183 | return it.Next(ctx) 184 | } 185 | 186 | // Item() returns the StaticBackend currently 187 | // pointed to by the iterator. 188 | func (it *iterStaticBackend) Item() *ngrok.StaticBackend { 189 | return &it.items[it.n] 190 | } 191 | 192 | // If Next() returned false because an error was encountered while fetching the 193 | // next value Err() will return that error. A caller should always check Err() 194 | // after Next() returns false. 195 | func (it *iterStaticBackend) Err() error { 196 | return it.err 197 | } 198 | 199 | // Update static backend by ID 200 | // 201 | // https://ngrok.com/docs/api#api-static-backends-update 202 | func (c *Client) Update(ctx context.Context, arg *ngrok.StaticBackendUpdate) (*ngrok.StaticBackend, error) { 203 | if arg == nil { 204 | arg = new(ngrok.StaticBackendUpdate) 205 | } 206 | var res ngrok.StaticBackend 207 | var path bytes.Buffer 208 | if err := template.Must(template.New("update_path").Parse("/backends/static/{{ .ID }}")).Execute(&path, arg); err != nil { 209 | panic(err) 210 | } 211 | arg.ID = "" 212 | var ( 213 | apiURL = &url.URL{Path: path.String()} 214 | bodyArg interface{} 215 | ) 216 | apiURL.Path = path.String() 217 | bodyArg = arg 218 | 219 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 220 | return nil, err 221 | } 222 | return &res, nil 223 | } 224 | -------------------------------------------------------------------------------- /backends/tunnel_group/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tunnel_group 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // A Tunnel Group Backend balances traffic among all online tunnels that match 16 | // a label selector. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // Create a new TunnelGroup backend 27 | // 28 | // https://ngrok.com/docs/api#api-tunnel-group-backends-create 29 | func (c *Client) Create(ctx context.Context, arg *ngrok.TunnelGroupBackendCreate) (*ngrok.TunnelGroupBackend, error) { 30 | if arg == nil { 31 | arg = new(ngrok.TunnelGroupBackendCreate) 32 | } 33 | var res ngrok.TunnelGroupBackend 34 | var path bytes.Buffer 35 | if err := template.Must(template.New("create_path").Parse("/backends/tunnel_group")).Execute(&path, arg); err != nil { 36 | panic(err) 37 | } 38 | var ( 39 | apiURL = &url.URL{Path: path.String()} 40 | bodyArg interface{} 41 | ) 42 | apiURL.Path = path.String() 43 | bodyArg = arg 44 | 45 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 46 | return nil, err 47 | } 48 | return &res, nil 49 | } 50 | 51 | // Delete a TunnelGroup backend by ID. 52 | // 53 | // https://ngrok.com/docs/api#api-tunnel-group-backends-delete 54 | func (c *Client) Delete(ctx context.Context, id string) error { 55 | arg := &ngrok.Item{ID: id} 56 | 57 | var path bytes.Buffer 58 | if err := template.Must(template.New("delete_path").Parse("/backends/tunnel_group/{{ .ID }}")).Execute(&path, arg); err != nil { 59 | panic(err) 60 | } 61 | arg.ID = "" 62 | var ( 63 | apiURL = &url.URL{Path: path.String()} 64 | bodyArg interface{} 65 | ) 66 | apiURL.Path = path.String() 67 | 68 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 69 | return err 70 | } 71 | return nil 72 | } 73 | 74 | // Get detailed information about a TunnelGroup backend by ID 75 | // 76 | // https://ngrok.com/docs/api#api-tunnel-group-backends-get 77 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.TunnelGroupBackend, error) { 78 | arg := &ngrok.Item{ID: id} 79 | 80 | var res ngrok.TunnelGroupBackend 81 | var path bytes.Buffer 82 | if err := template.Must(template.New("get_path").Parse("/backends/tunnel_group/{{ .ID }}")).Execute(&path, arg); err != nil { 83 | panic(err) 84 | } 85 | arg.ID = "" 86 | var ( 87 | apiURL = &url.URL{Path: path.String()} 88 | bodyArg interface{} 89 | ) 90 | apiURL.Path = path.String() 91 | 92 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 93 | return nil, err 94 | } 95 | return &res, nil 96 | } 97 | 98 | // List all TunnelGroup backends on this account 99 | // 100 | // https://ngrok.com/docs/api#api-tunnel-group-backends-list 101 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.TunnelGroupBackend] { 102 | if paging == nil { 103 | paging = new(ngrok.Paging) 104 | } 105 | var path bytes.Buffer 106 | if err := template.Must(template.New("list_path").Parse("/backends/tunnel_group")).Execute(&path, paging); err != nil { 107 | panic(err) 108 | } 109 | var apiURL = &url.URL{Path: path.String()} 110 | queryVals := make(url.Values) 111 | if paging.BeforeID != nil { 112 | queryVals.Set("before_id", *paging.BeforeID) 113 | } 114 | if paging.Limit != nil { 115 | queryVals.Set("limit", *paging.Limit) 116 | } 117 | apiURL.RawQuery = queryVals.Encode() 118 | return &iterTunnelGroupBackend{ 119 | client: c, 120 | n: -1, 121 | nextPage: apiURL, 122 | } 123 | } 124 | 125 | // iter allows the caller to iterate through a list of values while 126 | // automatically fetching new pages worth of values from the API. 127 | type iterTunnelGroupBackend struct { 128 | client *Client 129 | n int 130 | items []ngrok.TunnelGroupBackend 131 | err error 132 | 133 | nextPage *url.URL 134 | } 135 | 136 | // Next returns true if there is another value available in the iterator. If it 137 | // returs true it also advances the iterator to that next available item. 138 | func (it *iterTunnelGroupBackend) Next(ctx context.Context) bool { 139 | // no more if there is an error 140 | if it.err != nil { 141 | return false 142 | } 143 | 144 | // advance the iterator 145 | it.n += 1 146 | 147 | // is there an available item? 148 | if it.n < len(it.items) { 149 | return true 150 | } 151 | 152 | // no more items, do we have a next page? 153 | if it.nextPage == nil { 154 | return false 155 | } 156 | 157 | // fetch the next page 158 | var resp ngrok.TunnelGroupBackendList 159 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 160 | if err != nil { 161 | it.err = err 162 | return false 163 | } 164 | 165 | // parse the next page URI as soon as we get it and store it 166 | // so we can use it on the next fetch 167 | if resp.NextPageURI != nil { 168 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 169 | if it.err != nil { 170 | return false 171 | } 172 | } else { 173 | it.nextPage = nil 174 | } 175 | 176 | // page with zero items means there are no more 177 | if len(resp.Backends) == 0 { 178 | return false 179 | } 180 | 181 | it.n = -1 182 | it.items = resp.Backends 183 | return it.Next(ctx) 184 | } 185 | 186 | // Item() returns the TunnelGroupBackend currently 187 | // pointed to by the iterator. 188 | func (it *iterTunnelGroupBackend) Item() *ngrok.TunnelGroupBackend { 189 | return &it.items[it.n] 190 | } 191 | 192 | // If Next() returned false because an error was encountered while fetching the 193 | // next value Err() will return that error. A caller should always check Err() 194 | // after Next() returns false. 195 | func (it *iterTunnelGroupBackend) Err() error { 196 | return it.err 197 | } 198 | 199 | // Update TunnelGroup backend by ID 200 | // 201 | // https://ngrok.com/docs/api#api-tunnel-group-backends-update 202 | func (c *Client) Update(ctx context.Context, arg *ngrok.TunnelGroupBackendUpdate) (*ngrok.TunnelGroupBackend, error) { 203 | if arg == nil { 204 | arg = new(ngrok.TunnelGroupBackendUpdate) 205 | } 206 | var res ngrok.TunnelGroupBackend 207 | var path bytes.Buffer 208 | if err := template.Must(template.New("update_path").Parse("/backends/tunnel_group/{{ .ID }}")).Execute(&path, arg); err != nil { 209 | panic(err) 210 | } 211 | arg.ID = "" 212 | var ( 213 | apiURL = &url.URL{Path: path.String()} 214 | bodyArg interface{} 215 | ) 216 | apiURL.Path = path.String() 217 | bodyArg = arg 218 | 219 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 220 | return nil, err 221 | } 222 | return &res, nil 223 | } 224 | -------------------------------------------------------------------------------- /backends/weighted/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package weighted 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // A Weighted Backend balances traffic among the referenced backends. Traffic 16 | // is assigned proportionally to each based on its weight. The percentage of 17 | // traffic is calculated by dividing a backend's weight by the sum of all 18 | // weights. 19 | 20 | type Client struct { 21 | apiClient *api.Client 22 | } 23 | 24 | func NewClient(cfg *ngrok.ClientConfig) *Client { 25 | return &Client{apiClient: api.NewClient(cfg)} 26 | } 27 | 28 | // Create a new Weighted backend 29 | // 30 | // https://ngrok.com/docs/api#api-weighted-backends-create 31 | func (c *Client) Create(ctx context.Context, arg *ngrok.WeightedBackendCreate) (*ngrok.WeightedBackend, error) { 32 | if arg == nil { 33 | arg = new(ngrok.WeightedBackendCreate) 34 | } 35 | var res ngrok.WeightedBackend 36 | var path bytes.Buffer 37 | if err := template.Must(template.New("create_path").Parse("/backends/weighted")).Execute(&path, arg); err != nil { 38 | panic(err) 39 | } 40 | var ( 41 | apiURL = &url.URL{Path: path.String()} 42 | bodyArg interface{} 43 | ) 44 | apiURL.Path = path.String() 45 | bodyArg = arg 46 | 47 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 48 | return nil, err 49 | } 50 | return &res, nil 51 | } 52 | 53 | // Delete a Weighted backend by ID. 54 | // 55 | // https://ngrok.com/docs/api#api-weighted-backends-delete 56 | func (c *Client) Delete(ctx context.Context, id string) error { 57 | arg := &ngrok.Item{ID: id} 58 | 59 | var path bytes.Buffer 60 | if err := template.Must(template.New("delete_path").Parse("/backends/weighted/{{ .ID }}")).Execute(&path, arg); err != nil { 61 | panic(err) 62 | } 63 | arg.ID = "" 64 | var ( 65 | apiURL = &url.URL{Path: path.String()} 66 | bodyArg interface{} 67 | ) 68 | apiURL.Path = path.String() 69 | 70 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 71 | return err 72 | } 73 | return nil 74 | } 75 | 76 | // Get detailed information about a Weighted backend by ID 77 | // 78 | // https://ngrok.com/docs/api#api-weighted-backends-get 79 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.WeightedBackend, error) { 80 | arg := &ngrok.Item{ID: id} 81 | 82 | var res ngrok.WeightedBackend 83 | var path bytes.Buffer 84 | if err := template.Must(template.New("get_path").Parse("/backends/weighted/{{ .ID }}")).Execute(&path, arg); err != nil { 85 | panic(err) 86 | } 87 | arg.ID = "" 88 | var ( 89 | apiURL = &url.URL{Path: path.String()} 90 | bodyArg interface{} 91 | ) 92 | apiURL.Path = path.String() 93 | 94 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 95 | return nil, err 96 | } 97 | return &res, nil 98 | } 99 | 100 | // List all Weighted backends on this account 101 | // 102 | // https://ngrok.com/docs/api#api-weighted-backends-list 103 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.WeightedBackend] { 104 | if paging == nil { 105 | paging = new(ngrok.Paging) 106 | } 107 | var path bytes.Buffer 108 | if err := template.Must(template.New("list_path").Parse("/backends/weighted")).Execute(&path, paging); err != nil { 109 | panic(err) 110 | } 111 | var apiURL = &url.URL{Path: path.String()} 112 | queryVals := make(url.Values) 113 | if paging.BeforeID != nil { 114 | queryVals.Set("before_id", *paging.BeforeID) 115 | } 116 | if paging.Limit != nil { 117 | queryVals.Set("limit", *paging.Limit) 118 | } 119 | apiURL.RawQuery = queryVals.Encode() 120 | return &iterWeightedBackend{ 121 | client: c, 122 | n: -1, 123 | nextPage: apiURL, 124 | } 125 | } 126 | 127 | // iter allows the caller to iterate through a list of values while 128 | // automatically fetching new pages worth of values from the API. 129 | type iterWeightedBackend struct { 130 | client *Client 131 | n int 132 | items []ngrok.WeightedBackend 133 | err error 134 | 135 | nextPage *url.URL 136 | } 137 | 138 | // Next returns true if there is another value available in the iterator. If it 139 | // returs true it also advances the iterator to that next available item. 140 | func (it *iterWeightedBackend) Next(ctx context.Context) bool { 141 | // no more if there is an error 142 | if it.err != nil { 143 | return false 144 | } 145 | 146 | // advance the iterator 147 | it.n += 1 148 | 149 | // is there an available item? 150 | if it.n < len(it.items) { 151 | return true 152 | } 153 | 154 | // no more items, do we have a next page? 155 | if it.nextPage == nil { 156 | return false 157 | } 158 | 159 | // fetch the next page 160 | var resp ngrok.WeightedBackendList 161 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 162 | if err != nil { 163 | it.err = err 164 | return false 165 | } 166 | 167 | // parse the next page URI as soon as we get it and store it 168 | // so we can use it on the next fetch 169 | if resp.NextPageURI != nil { 170 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 171 | if it.err != nil { 172 | return false 173 | } 174 | } else { 175 | it.nextPage = nil 176 | } 177 | 178 | // page with zero items means there are no more 179 | if len(resp.Backends) == 0 { 180 | return false 181 | } 182 | 183 | it.n = -1 184 | it.items = resp.Backends 185 | return it.Next(ctx) 186 | } 187 | 188 | // Item() returns the WeightedBackend currently 189 | // pointed to by the iterator. 190 | func (it *iterWeightedBackend) Item() *ngrok.WeightedBackend { 191 | return &it.items[it.n] 192 | } 193 | 194 | // If Next() returned false because an error was encountered while fetching the 195 | // next value Err() will return that error. A caller should always check Err() 196 | // after Next() returns false. 197 | func (it *iterWeightedBackend) Err() error { 198 | return it.err 199 | } 200 | 201 | // Update Weighted backend by ID 202 | // 203 | // https://ngrok.com/docs/api#api-weighted-backends-update 204 | func (c *Client) Update(ctx context.Context, arg *ngrok.WeightedBackendUpdate) (*ngrok.WeightedBackend, error) { 205 | if arg == nil { 206 | arg = new(ngrok.WeightedBackendUpdate) 207 | } 208 | var res ngrok.WeightedBackend 209 | var path bytes.Buffer 210 | if err := template.Must(template.New("update_path").Parse("/backends/weighted/{{ .ID }}")).Execute(&path, arg); err != nil { 211 | panic(err) 212 | } 213 | arg.ID = "" 214 | var ( 215 | apiURL = &url.URL{Path: path.String()} 216 | bodyArg interface{} 217 | ) 218 | apiURL.Path = path.String() 219 | bodyArg = arg 220 | 221 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 222 | return nil, err 223 | } 224 | return &res, nil 225 | } 226 | -------------------------------------------------------------------------------- /bot_users/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package bot_users 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create a new bot user 24 | // 25 | // https://ngrok.com/docs/api#api-bot-users-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.BotUserCreate) (*ngrok.BotUser, error) { 27 | if arg == nil { 28 | arg = new(ngrok.BotUserCreate) 29 | } 30 | var res ngrok.BotUser 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/bot_users")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Delete a bot user by ID 49 | // 50 | // https://ngrok.com/docs/api#api-bot-users-delete 51 | func (c *Client) Delete(ctx context.Context, id string) error { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var path bytes.Buffer 55 | if err := template.Must(template.New("delete_path").Parse("/bot_users/{{ .ID }}")).Execute(&path, arg); err != nil { 56 | panic(err) 57 | } 58 | arg.ID = "" 59 | var ( 60 | apiURL = &url.URL{Path: path.String()} 61 | bodyArg interface{} 62 | ) 63 | apiURL.Path = path.String() 64 | 65 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 66 | return err 67 | } 68 | return nil 69 | } 70 | 71 | // Get the details of a Bot User by ID. 72 | // 73 | // https://ngrok.com/docs/api#api-bot-users-get 74 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.BotUser, error) { 75 | arg := &ngrok.Item{ID: id} 76 | 77 | var res ngrok.BotUser 78 | var path bytes.Buffer 79 | if err := template.Must(template.New("get_path").Parse("/bot_users/{{ .ID }}")).Execute(&path, arg); err != nil { 80 | panic(err) 81 | } 82 | arg.ID = "" 83 | var ( 84 | apiURL = &url.URL{Path: path.String()} 85 | bodyArg interface{} 86 | ) 87 | apiURL.Path = path.String() 88 | 89 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 90 | return nil, err 91 | } 92 | return &res, nil 93 | } 94 | 95 | // List all bot users in this account. 96 | // 97 | // https://ngrok.com/docs/api#api-bot-users-list 98 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.BotUser] { 99 | if paging == nil { 100 | paging = new(ngrok.Paging) 101 | } 102 | var path bytes.Buffer 103 | if err := template.Must(template.New("list_path").Parse("/bot_users")).Execute(&path, paging); err != nil { 104 | panic(err) 105 | } 106 | var apiURL = &url.URL{Path: path.String()} 107 | queryVals := make(url.Values) 108 | if paging.BeforeID != nil { 109 | queryVals.Set("before_id", *paging.BeforeID) 110 | } 111 | if paging.Limit != nil { 112 | queryVals.Set("limit", *paging.Limit) 113 | } 114 | apiURL.RawQuery = queryVals.Encode() 115 | return &iterBotUser{ 116 | client: c, 117 | n: -1, 118 | nextPage: apiURL, 119 | } 120 | } 121 | 122 | // iter allows the caller to iterate through a list of values while 123 | // automatically fetching new pages worth of values from the API. 124 | type iterBotUser struct { 125 | client *Client 126 | n int 127 | items []ngrok.BotUser 128 | err error 129 | 130 | nextPage *url.URL 131 | } 132 | 133 | // Next returns true if there is another value available in the iterator. If it 134 | // returs true it also advances the iterator to that next available item. 135 | func (it *iterBotUser) Next(ctx context.Context) bool { 136 | // no more if there is an error 137 | if it.err != nil { 138 | return false 139 | } 140 | 141 | // advance the iterator 142 | it.n += 1 143 | 144 | // is there an available item? 145 | if it.n < len(it.items) { 146 | return true 147 | } 148 | 149 | // no more items, do we have a next page? 150 | if it.nextPage == nil { 151 | return false 152 | } 153 | 154 | // fetch the next page 155 | var resp ngrok.BotUserList 156 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 157 | if err != nil { 158 | it.err = err 159 | return false 160 | } 161 | 162 | // parse the next page URI as soon as we get it and store it 163 | // so we can use it on the next fetch 164 | if resp.NextPageURI != nil { 165 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 166 | if it.err != nil { 167 | return false 168 | } 169 | } else { 170 | it.nextPage = nil 171 | } 172 | 173 | // page with zero items means there are no more 174 | if len(resp.BotUsers) == 0 { 175 | return false 176 | } 177 | 178 | it.n = -1 179 | it.items = resp.BotUsers 180 | return it.Next(ctx) 181 | } 182 | 183 | // Item() returns the BotUser currently 184 | // pointed to by the iterator. 185 | func (it *iterBotUser) Item() *ngrok.BotUser { 186 | return &it.items[it.n] 187 | } 188 | 189 | // If Next() returned false because an error was encountered while fetching the 190 | // next value Err() will return that error. A caller should always check Err() 191 | // after Next() returns false. 192 | func (it *iterBotUser) Err() error { 193 | return it.err 194 | } 195 | 196 | // Update attributes of a bot user by ID. 197 | // 198 | // https://ngrok.com/docs/api#api-bot-users-update 199 | func (c *Client) Update(ctx context.Context, arg *ngrok.BotUserUpdate) (*ngrok.BotUser, error) { 200 | if arg == nil { 201 | arg = new(ngrok.BotUserUpdate) 202 | } 203 | var res ngrok.BotUser 204 | var path bytes.Buffer 205 | if err := template.Must(template.New("update_path").Parse("/bot_users/{{ .ID }}")).Execute(&path, arg); err != nil { 206 | panic(err) 207 | } 208 | arg.ID = "" 209 | var ( 210 | apiURL = &url.URL{Path: path.String()} 211 | bodyArg interface{} 212 | ) 213 | apiURL.Path = path.String() 214 | bodyArg = arg 215 | 216 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 217 | return nil, err 218 | } 219 | return &res, nil 220 | } 221 | -------------------------------------------------------------------------------- /client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "encoding/json" 9 | "fmt" 10 | "io" 11 | "net/http" 12 | "net/url" 13 | "runtime" 14 | ) 15 | 16 | const ( 17 | apiVersion = "2" 18 | ) 19 | 20 | var ( 21 | defaultUserAgent = "ngrok-api-go/" + _version + "/" + runtime.Version() 22 | ) 23 | 24 | // BaseClient is a generic client for the ngrok API capable of sending 25 | // arbitrary requests. 26 | type BaseClient struct { 27 | cfg *ClientConfig 28 | } 29 | 30 | // NewBaseClient constructs a new [BaseClient]. 31 | func NewBaseClient(cfg *ClientConfig) *BaseClient { 32 | return &BaseClient{cfg: cfg} 33 | } 34 | 35 | // Do sends a request to the ngrok API. 36 | // 37 | // The `reqBody` and `respBody` parameters will be automatically serialized 38 | // and deserialized. 39 | // 40 | // The `reqURL` may include only the `Path` component. The full URL will be 41 | // built from the `BaseURL` in the [ClientConfig]. 42 | func (c *BaseClient) Do(ctx context.Context, method string, reqURL *url.URL, reqBody interface{}, respBody interface{}) error { 43 | req, err := c.buildRequest(ctx, method, reqURL, reqBody) 44 | if err != nil { 45 | return err 46 | } 47 | resp, err := c.cfg.HTTPClient.Do(req) 48 | if err != nil { 49 | return err 50 | } 51 | if err = c.readResponse(resp, respBody); err != nil { 52 | return err 53 | } 54 | return nil 55 | } 56 | 57 | func (c *BaseClient) buildRequest(ctx context.Context, method string, reqURL *url.URL, reqBody interface{}) (*http.Request, error) { 58 | body, err := c.buildRequestBody(reqBody) 59 | if err != nil { 60 | return nil, err 61 | } 62 | reqURLString := c.cfg.BaseURL.ResolveReference(reqURL).String() 63 | r, err := http.NewRequestWithContext(ctx, method, reqURLString, body) 64 | if err != nil { 65 | return nil, err 66 | } 67 | 68 | r.Header.Set("authorization", fmt.Sprintf("Bearer %s", c.cfg.APIKey)) 69 | r.Header.Set("user-agent", c.userAgent()) 70 | r.Header.Set("ngrok-version", apiVersion) 71 | if body != nil { 72 | r.Header.Set("content-type", "application/json") 73 | } 74 | return r, nil 75 | } 76 | 77 | func (c *BaseClient) buildRequestBody(reqBody interface{}) (io.Reader, error) { 78 | if reqBody == nil { 79 | return nil, nil 80 | } 81 | jsonBytes, err := json.Marshal(reqBody) 82 | if err != nil { 83 | return nil, err 84 | } 85 | return bytes.NewReader(jsonBytes), nil 86 | } 87 | 88 | func (c *BaseClient) readResponse(resp *http.Response, out interface{}) error { 89 | if resp.Body != nil { 90 | defer resp.Body.Close() 91 | } 92 | if resp.StatusCode >= http.StatusBadRequest { 93 | return c.readErrorResponse(resp) 94 | } 95 | return c.readResponseBody(resp, out) 96 | } 97 | 98 | // read an error response body 99 | func (c *BaseClient) readErrorResponse(resp *http.Response) error { 100 | var out Error 101 | err := c.readResponseBody(resp, &out) 102 | if err != nil { 103 | return err 104 | } 105 | return &out 106 | } 107 | 108 | // unmarshal a response body 109 | func (c *BaseClient) readResponseBody(resp *http.Response, out interface{}) error { 110 | if out == nil { 111 | return nil 112 | } 113 | bodyBytes, err := io.ReadAll(resp.Body) 114 | if err != nil { 115 | return c.buildUnmarshalError(resp, bodyBytes, err) 116 | } 117 | if err := json.Unmarshal(bodyBytes, out); err != nil { 118 | return c.buildUnmarshalError(resp, bodyBytes, err) 119 | } 120 | return nil 121 | } 122 | 123 | // if an error occurs while trying to read a response body, construct a new 124 | // error explaining the unmarshalling failure 125 | func (c *BaseClient) buildUnmarshalError(resp *http.Response, bodyBytes []byte, err error) error { 126 | return &Error{ 127 | Msg: fmt.Sprintf("failed to unmarshal response body: %s. body: %s", err, bodyBytes), 128 | StatusCode: int32(resp.StatusCode), 129 | Details: map[string]string{ 130 | "unmarshal_error": err.Error(), 131 | "invalid_body": string(bodyBytes), 132 | "operation_id": resp.Header.Get("ngrok-operation-id"), 133 | }, 134 | } 135 | } 136 | 137 | // Returns a user agent override if one was set on the client config. Otherwise, 138 | // returns the default user agent. 139 | func (c *BaseClient) userAgent() string { 140 | if c.cfg.UserAgent != nil { 141 | return *c.cfg.UserAgent 142 | } 143 | return defaultUserAgent 144 | } 145 | -------------------------------------------------------------------------------- /client_config.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import ( 6 | "net/http" 7 | "net/url" 8 | ) 9 | 10 | var ( 11 | defaultBaseURL, _ = url.Parse("https://api.ngrok.com") 12 | ) 13 | 14 | type ClientConfig struct { 15 | APIKey string 16 | BaseURL *url.URL 17 | HTTPClient *http.Client 18 | UserAgent *string 19 | } 20 | 21 | func NewClientConfig(apiKey string, opts ...ClientConfigOption) *ClientConfig { 22 | var configOpts clientConfigOpts 23 | configOpts.parseOptions(opts) 24 | return &ClientConfig{ 25 | APIKey: apiKey, 26 | BaseURL: configOpts.baseURL, 27 | HTTPClient: configOpts.httpClient, 28 | UserAgent: configOpts.userAgent, 29 | } 30 | } 31 | 32 | type clientConfigOpts struct { 33 | baseURL *url.URL 34 | httpClient *http.Client 35 | userAgent *string 36 | } 37 | 38 | type ClientConfigOption func(cc *clientConfigOpts) 39 | 40 | func (cc *clientConfigOpts) parseOptions(opts []ClientConfigOption) { 41 | for _, o := range opts { 42 | o(cc) 43 | } 44 | cc.setDefaults() 45 | } 46 | 47 | func (cc *clientConfigOpts) setDefaults() { 48 | if cc.httpClient == nil { 49 | cc.httpClient = http.DefaultClient 50 | } 51 | if cc.baseURL == nil { 52 | cc.baseURL = defaultBaseURL 53 | } 54 | } 55 | 56 | func WithBaseURL(baseURL string) ClientConfigOption { 57 | return func(cc *clientConfigOpts) { 58 | cc.baseURL, _ = url.Parse(baseURL) 59 | } 60 | } 61 | 62 | func WithHTTPClient(httpClient *http.Client) ClientConfigOption { 63 | return func(cc *clientConfigOpts) { 64 | cc.httpClient = httpClient 65 | } 66 | } 67 | 68 | func WithUserAgent(userAgent string) ClientConfigOption { 69 | return func(cc *clientConfigOpts) { 70 | cc.userAgent = &userAgent 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /client_test.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import ( 6 | "context" 7 | "net/url" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | ) 12 | 13 | func TestUserAgent(t *testing.T) { 14 | url := &url.URL{Path: "/test"} 15 | apiKey := "testKey" 16 | 17 | testUserAgent := func(cfg *ClientConfig, expected string) { 18 | client := NewBaseClient(cfg) 19 | req, err := client.buildRequest(context.TODO(), "GET", url, nil) 20 | assert.NoError(t, err) 21 | assert.Equal(t, expected, req.Header.Get("user-agent")) 22 | } 23 | 24 | testUserAgent(NewClientConfig(apiKey), defaultUserAgent) 25 | testUserAgent(NewClientConfig(apiKey, WithUserAgent("testAgent")), "testAgent") 26 | } 27 | -------------------------------------------------------------------------------- /edge_modules/https_edge_mutual_tls/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_mutual_tls 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeMutualTLSReplace) (*ngrok.EndpointMutualTLS, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeMutualTLSReplace) 26 | } 27 | var res ngrok.EndpointMutualTLS 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointMutualTLS, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointMutualTLS 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_backend/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_backend 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteBackendReplace) (*ngrok.EndpointBackend, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteBackendReplace) 26 | } 27 | var res ngrok.EndpointBackend 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointBackend, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointBackend 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_circuit_breaker/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_circuit_breaker 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteCircuitBreakerReplace) (*ngrok.EndpointCircuitBreaker, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteCircuitBreakerReplace) 26 | } 27 | var res ngrok.EndpointCircuitBreaker 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/circuit_breaker")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointCircuitBreaker, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointCircuitBreaker 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/circuit_breaker")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/circuit_breaker")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_compression/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_compression 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteCompressionReplace) (*ngrok.EndpointCompression, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteCompressionReplace) 26 | } 27 | var res ngrok.EndpointCompression 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/compression")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointCompression, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointCompression 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/compression")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/compression")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_ip_restriction/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_ip_restriction 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteIPRestrictionReplace) (*ngrok.EndpointIPPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteIPRestrictionReplace) 26 | } 27 | var res ngrok.EndpointIPPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointIPPolicy, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointIPPolicy 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_oauth/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_oauth 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteOAuthReplace) (*ngrok.EndpointOAuth, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteOAuthReplace) 26 | } 27 | var res ngrok.EndpointOAuth 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oauth")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointOAuth, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointOAuth 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oauth")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oauth")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_oidc/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_oidc 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteOIDCReplace) (*ngrok.EndpointOIDC, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteOIDCReplace) 26 | } 27 | var res ngrok.EndpointOIDC 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oidc")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointOIDC, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointOIDC 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oidc")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/oidc")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_request_headers/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_request_headers 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteRequestHeadersReplace) (*ngrok.EndpointRequestHeaders, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteRequestHeadersReplace) 26 | } 27 | var res ngrok.EndpointRequestHeaders 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/request_headers")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointRequestHeaders, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointRequestHeaders 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/request_headers")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/request_headers")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_response_headers/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_response_headers 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteResponseHeadersReplace) (*ngrok.EndpointResponseHeaders, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteResponseHeadersReplace) 26 | } 27 | var res ngrok.EndpointResponseHeaders 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/response_headers")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointResponseHeaders, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointResponseHeaders 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/response_headers")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/response_headers")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_saml/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_saml 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteSAMLReplace) (*ngrok.EndpointSAML, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteSAMLReplace) 26 | } 27 | var res ngrok.EndpointSAML 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/saml")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointSAML, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointSAML 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/saml")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/saml")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_traffic_policy/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_traffic_policy 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteTrafficPolicyReplace) (*ngrok.EndpointTrafficPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteTrafficPolicyReplace) 26 | } 27 | var res ngrok.EndpointTrafficPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointTrafficPolicy, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointTrafficPolicy 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_user_agent_filter/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_user_agent_filter 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteUserAgentFilterReplace) (*ngrok.EndpointUserAgentFilter, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteUserAgentFilterReplace) 26 | } 27 | var res ngrok.EndpointUserAgentFilter 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/user_agent_filter")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointUserAgentFilter, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointUserAgentFilter 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/user_agent_filter")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/user_agent_filter")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_webhook_verification/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_webhook_verification 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteWebhookVerificationReplace) (*ngrok.EndpointWebhookValidation, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteWebhookVerificationReplace) 26 | } 27 | var res ngrok.EndpointWebhookValidation 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/webhook_verification")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointWebhookValidation, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointWebhookValidation 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/webhook_verification")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/webhook_verification")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_route_websocket_tcp_converter/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_route_websocket_tcp_converter 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeRouteWebsocketTCPConverterReplace) (*ngrok.EndpointWebsocketTCPConverter, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeRouteWebsocketTCPConverterReplace) 26 | } 27 | var res ngrok.EndpointWebsocketTCPConverter 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/websocket_tcp_converter")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | arg.ID = "" 34 | var ( 35 | apiURL = &url.URL{Path: path.String()} 36 | bodyArg interface{} 37 | ) 38 | apiURL.Path = path.String() 39 | bodyArg = arg.Module 40 | 41 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 42 | return nil, err 43 | } 44 | return &res, nil 45 | } 46 | 47 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.EndpointWebsocketTCPConverter, error) { 48 | if arg == nil { 49 | arg = new(ngrok.EdgeRouteItem) 50 | } 51 | var res ngrok.EndpointWebsocketTCPConverter 52 | var path bytes.Buffer 53 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/websocket_tcp_converter")).Execute(&path, arg); err != nil { 54 | panic(err) 55 | } 56 | arg.EdgeID = "" 57 | arg.ID = "" 58 | var ( 59 | apiURL = &url.URL{Path: path.String()} 60 | bodyArg interface{} 61 | ) 62 | apiURL.Path = path.String() 63 | 64 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 65 | return nil, err 66 | } 67 | return &res, nil 68 | } 69 | 70 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 71 | if arg == nil { 72 | arg = new(ngrok.EdgeRouteItem) 73 | } 74 | var path bytes.Buffer 75 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}/websocket_tcp_converter")).Execute(&path, arg); err != nil { 76 | panic(err) 77 | } 78 | arg.EdgeID = "" 79 | arg.ID = "" 80 | var ( 81 | apiURL = &url.URL{Path: path.String()} 82 | bodyArg interface{} 83 | ) 84 | apiURL.Path = path.String() 85 | 86 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 87 | return err 88 | } 89 | return nil 90 | } 91 | -------------------------------------------------------------------------------- /edge_modules/https_edge_tls_termination/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_edge_tls_termination 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeTLSTerminationAtEdgeReplace) (*ngrok.EndpointTLSTermination, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeTLSTerminationAtEdgeReplace) 26 | } 27 | var res ngrok.EndpointTLSTermination 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/https/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointTLSTermination, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointTLSTermination 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tcp_edge_backend/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tcp_edge_backend 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeBackendReplace) (*ngrok.EndpointBackend, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeBackendReplace) 26 | } 27 | var res ngrok.EndpointBackend 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tcp/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointBackend, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointBackend 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tcp/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tcp/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tcp_edge_ip_restriction/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tcp_edge_ip_restriction 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeIPRestrictionReplace) (*ngrok.EndpointIPPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeIPRestrictionReplace) 26 | } 27 | var res ngrok.EndpointIPPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tcp/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointIPPolicy, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointIPPolicy 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tcp/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tcp/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tcp_edge_traffic_policy/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tcp_edge_traffic_policy 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeTrafficPolicyReplace) (*ngrok.EndpointTrafficPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeTrafficPolicyReplace) 26 | } 27 | var res ngrok.EndpointTrafficPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tcp/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointTrafficPolicy, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointTrafficPolicy 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tcp/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tcp/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tls_edge_backend/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_edge_backend 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeBackendReplace) (*ngrok.EndpointBackend, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeBackendReplace) 26 | } 27 | var res ngrok.EndpointBackend 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tls/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointBackend, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointBackend 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}/backend")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tls_edge_ip_restriction/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_edge_ip_restriction 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeIPRestrictionReplace) (*ngrok.EndpointIPPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeIPRestrictionReplace) 26 | } 27 | var res ngrok.EndpointIPPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tls/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointIPPolicy, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointIPPolicy 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}/ip_restriction")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tls_edge_mutual_tls/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_edge_mutual_tls 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeMutualTLSReplace) (*ngrok.EndpointMutualTLS, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeMutualTLSReplace) 26 | } 27 | var res ngrok.EndpointMutualTLS 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tls/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointMutualTLS, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointMutualTLS 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}/mutual_tls")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tls_edge_tls_termination/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_edge_tls_termination 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeTLSTerminationReplace) (*ngrok.EndpointTLSTermination, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeTLSTerminationReplace) 26 | } 27 | var res ngrok.EndpointTLSTermination 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tls/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointTLSTermination, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointTLSTermination 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}/tls_termination")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edge_modules/tls_edge_traffic_policy/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_edge_traffic_policy 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | func (c *Client) Replace(ctx context.Context, arg *ngrok.EdgeTrafficPolicyReplace) (*ngrok.EndpointTrafficPolicy, error) { 24 | if arg == nil { 25 | arg = new(ngrok.EdgeTrafficPolicyReplace) 26 | } 27 | var res ngrok.EndpointTrafficPolicy 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("replace_path").Parse("/edges/tls/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.ID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg.Module 39 | 40 | if err := c.apiClient.Do(ctx, "PUT", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EndpointTrafficPolicy, error) { 47 | arg := &ngrok.Item{ID: id} 48 | 49 | var res ngrok.EndpointTrafficPolicy 50 | var path bytes.Buffer 51 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 52 | panic(err) 53 | } 54 | arg.ID = "" 55 | var ( 56 | apiURL = &url.URL{Path: path.String()} 57 | bodyArg interface{} 58 | ) 59 | apiURL.Path = path.String() 60 | 61 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 62 | return nil, err 63 | } 64 | return &res, nil 65 | } 66 | 67 | func (c *Client) Delete(ctx context.Context, id string) error { 68 | arg := &ngrok.Item{ID: id} 69 | 70 | var path bytes.Buffer 71 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}/traffic_policy")).Execute(&path, arg); err != nil { 72 | panic(err) 73 | } 74 | arg.ID = "" 75 | var ( 76 | apiURL = &url.URL{Path: path.String()} 77 | bodyArg interface{} 78 | ) 79 | apiURL.Path = path.String() 80 | 81 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 82 | return err 83 | } 84 | return nil 85 | } 86 | -------------------------------------------------------------------------------- /edges/https/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create an HTTPS Edge 24 | // 25 | // https://ngrok.com/docs/api#api-edges-https-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.HTTPSEdgeCreate) (*ngrok.HTTPSEdge, error) { 27 | if arg == nil { 28 | arg = new(ngrok.HTTPSEdgeCreate) 29 | } 30 | var res ngrok.HTTPSEdge 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/edges/https")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Get an HTTPS Edge by ID 49 | // 50 | // https://ngrok.com/docs/api#api-edges-https-get 51 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.HTTPSEdge, error) { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var res ngrok.HTTPSEdge 55 | var path bytes.Buffer 56 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .ID }}")).Execute(&path, arg); err != nil { 57 | panic(err) 58 | } 59 | arg.ID = "" 60 | var ( 61 | apiURL = &url.URL{Path: path.String()} 62 | bodyArg interface{} 63 | ) 64 | apiURL.Path = path.String() 65 | 66 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 67 | return nil, err 68 | } 69 | return &res, nil 70 | } 71 | 72 | // Returns a list of all HTTPS Edges on this account 73 | // 74 | // https://ngrok.com/docs/api#api-edges-https-list 75 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.HTTPSEdge] { 76 | if paging == nil { 77 | paging = new(ngrok.Paging) 78 | } 79 | var path bytes.Buffer 80 | if err := template.Must(template.New("list_path").Parse("/edges/https")).Execute(&path, paging); err != nil { 81 | panic(err) 82 | } 83 | var apiURL = &url.URL{Path: path.String()} 84 | queryVals := make(url.Values) 85 | if paging.BeforeID != nil { 86 | queryVals.Set("before_id", *paging.BeforeID) 87 | } 88 | if paging.Limit != nil { 89 | queryVals.Set("limit", *paging.Limit) 90 | } 91 | apiURL.RawQuery = queryVals.Encode() 92 | return &iterHTTPSEdge{ 93 | client: c, 94 | n: -1, 95 | nextPage: apiURL, 96 | } 97 | } 98 | 99 | // iter allows the caller to iterate through a list of values while 100 | // automatically fetching new pages worth of values from the API. 101 | type iterHTTPSEdge struct { 102 | client *Client 103 | n int 104 | items []ngrok.HTTPSEdge 105 | err error 106 | 107 | nextPage *url.URL 108 | } 109 | 110 | // Next returns true if there is another value available in the iterator. If it 111 | // returs true it also advances the iterator to that next available item. 112 | func (it *iterHTTPSEdge) Next(ctx context.Context) bool { 113 | // no more if there is an error 114 | if it.err != nil { 115 | return false 116 | } 117 | 118 | // advance the iterator 119 | it.n += 1 120 | 121 | // is there an available item? 122 | if it.n < len(it.items) { 123 | return true 124 | } 125 | 126 | // no more items, do we have a next page? 127 | if it.nextPage == nil { 128 | return false 129 | } 130 | 131 | // fetch the next page 132 | var resp ngrok.HTTPSEdgeList 133 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 134 | if err != nil { 135 | it.err = err 136 | return false 137 | } 138 | 139 | // parse the next page URI as soon as we get it and store it 140 | // so we can use it on the next fetch 141 | if resp.NextPageURI != nil { 142 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 143 | if it.err != nil { 144 | return false 145 | } 146 | } else { 147 | it.nextPage = nil 148 | } 149 | 150 | // page with zero items means there are no more 151 | if len(resp.HTTPSEdges) == 0 { 152 | return false 153 | } 154 | 155 | it.n = -1 156 | it.items = resp.HTTPSEdges 157 | return it.Next(ctx) 158 | } 159 | 160 | // Item() returns the HTTPSEdge currently 161 | // pointed to by the iterator. 162 | func (it *iterHTTPSEdge) Item() *ngrok.HTTPSEdge { 163 | return &it.items[it.n] 164 | } 165 | 166 | // If Next() returned false because an error was encountered while fetching the 167 | // next value Err() will return that error. A caller should always check Err() 168 | // after Next() returns false. 169 | func (it *iterHTTPSEdge) Err() error { 170 | return it.err 171 | } 172 | 173 | // Updates an HTTPS Edge by ID. If a module is not specified in the update, it will 174 | // not be modified. However, each module configuration that is specified will 175 | // completely replace the existing value. There is no way to delete an existing 176 | // module via this API, instead use the delete module API. 177 | // 178 | // https://ngrok.com/docs/api#api-edges-https-update 179 | func (c *Client) Update(ctx context.Context, arg *ngrok.HTTPSEdgeUpdate) (*ngrok.HTTPSEdge, error) { 180 | if arg == nil { 181 | arg = new(ngrok.HTTPSEdgeUpdate) 182 | } 183 | var res ngrok.HTTPSEdge 184 | var path bytes.Buffer 185 | if err := template.Must(template.New("update_path").Parse("/edges/https/{{ .ID }}")).Execute(&path, arg); err != nil { 186 | panic(err) 187 | } 188 | arg.ID = "" 189 | var ( 190 | apiURL = &url.URL{Path: path.String()} 191 | bodyArg interface{} 192 | ) 193 | apiURL.Path = path.String() 194 | bodyArg = arg 195 | 196 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 197 | return nil, err 198 | } 199 | return &res, nil 200 | } 201 | 202 | // Delete an HTTPS Edge by ID 203 | // 204 | // https://ngrok.com/docs/api#api-edges-https-delete 205 | func (c *Client) Delete(ctx context.Context, id string) error { 206 | arg := &ngrok.Item{ID: id} 207 | 208 | var path bytes.Buffer 209 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .ID }}")).Execute(&path, arg); err != nil { 210 | panic(err) 211 | } 212 | arg.ID = "" 213 | var ( 214 | apiURL = &url.URL{Path: path.String()} 215 | bodyArg interface{} 216 | ) 217 | apiURL.Path = path.String() 218 | 219 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 220 | return err 221 | } 222 | return nil 223 | } 224 | -------------------------------------------------------------------------------- /edges/https_routes/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package https_routes 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create an HTTPS Edge Route 24 | // 25 | // https://ngrok.com/docs/api#api-edges-https-routes-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.HTTPSEdgeRouteCreate) (*ngrok.HTTPSEdgeRoute, error) { 27 | var res ngrok.HTTPSEdgeRoute 28 | var path bytes.Buffer 29 | if err := template.Must(template.New("create_path").Parse("/edges/https/{{ .EdgeID }}/routes")).Execute(&path, arg); err != nil { 30 | panic(err) 31 | } 32 | arg.EdgeID = "" 33 | var ( 34 | apiURL = &url.URL{Path: path.String()} 35 | bodyArg interface{} 36 | ) 37 | apiURL.Path = path.String() 38 | bodyArg = arg 39 | 40 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 41 | return nil, err 42 | } 43 | return &res, nil 44 | } 45 | 46 | // Get an HTTPS Edge Route by ID 47 | // 48 | // https://ngrok.com/docs/api#api-edges-https-routes-get 49 | func (c *Client) Get(ctx context.Context, arg *ngrok.EdgeRouteItem) (*ngrok.HTTPSEdgeRoute, error) { 50 | if arg == nil { 51 | arg = new(ngrok.EdgeRouteItem) 52 | } 53 | var res ngrok.HTTPSEdgeRoute 54 | var path bytes.Buffer 55 | if err := template.Must(template.New("get_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}")).Execute(&path, arg); err != nil { 56 | panic(err) 57 | } 58 | arg.EdgeID = "" 59 | arg.ID = "" 60 | var ( 61 | apiURL = &url.URL{Path: path.String()} 62 | bodyArg interface{} 63 | ) 64 | apiURL.Path = path.String() 65 | 66 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 67 | return nil, err 68 | } 69 | return &res, nil 70 | } 71 | 72 | // Updates an HTTPS Edge Route by ID. If a module is not specified in the update, 73 | // it will not be modified. However, each module configuration that is specified 74 | // will completely replace the existing value. There is no way to delete an 75 | // existing module via this API, instead use the delete module API. 76 | // 77 | // https://ngrok.com/docs/api#api-edges-https-routes-update 78 | func (c *Client) Update(ctx context.Context, arg *ngrok.HTTPSEdgeRouteUpdate) (*ngrok.HTTPSEdgeRoute, error) { 79 | if arg == nil { 80 | arg = new(ngrok.HTTPSEdgeRouteUpdate) 81 | } 82 | var res ngrok.HTTPSEdgeRoute 83 | var path bytes.Buffer 84 | if err := template.Must(template.New("update_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}")).Execute(&path, arg); err != nil { 85 | panic(err) 86 | } 87 | arg.EdgeID = "" 88 | arg.ID = "" 89 | var ( 90 | apiURL = &url.URL{Path: path.String()} 91 | bodyArg interface{} 92 | ) 93 | apiURL.Path = path.String() 94 | bodyArg = arg 95 | 96 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 97 | return nil, err 98 | } 99 | return &res, nil 100 | } 101 | 102 | // Delete an HTTPS Edge Route by ID 103 | // 104 | // https://ngrok.com/docs/api#api-edges-https-routes-delete 105 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EdgeRouteItem) error { 106 | if arg == nil { 107 | arg = new(ngrok.EdgeRouteItem) 108 | } 109 | var path bytes.Buffer 110 | if err := template.Must(template.New("delete_path").Parse("/edges/https/{{ .EdgeID }}/routes/{{ .ID }}")).Execute(&path, arg); err != nil { 111 | panic(err) 112 | } 113 | arg.EdgeID = "" 114 | arg.ID = "" 115 | var ( 116 | apiURL = &url.URL{Path: path.String()} 117 | bodyArg interface{} 118 | ) 119 | apiURL.Path = path.String() 120 | 121 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 122 | return err 123 | } 124 | return nil 125 | } 126 | -------------------------------------------------------------------------------- /edges/tcp/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tcp 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create a TCP Edge 24 | // 25 | // https://ngrok.com/docs/api#api-edges-tcp-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.TCPEdgeCreate) (*ngrok.TCPEdge, error) { 27 | if arg == nil { 28 | arg = new(ngrok.TCPEdgeCreate) 29 | } 30 | var res ngrok.TCPEdge 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/edges/tcp")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Get a TCP Edge by ID 49 | // 50 | // https://ngrok.com/docs/api#api-edges-tcp-get 51 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.TCPEdge, error) { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var res ngrok.TCPEdge 55 | var path bytes.Buffer 56 | if err := template.Must(template.New("get_path").Parse("/edges/tcp/{{ .ID }}")).Execute(&path, arg); err != nil { 57 | panic(err) 58 | } 59 | arg.ID = "" 60 | var ( 61 | apiURL = &url.URL{Path: path.String()} 62 | bodyArg interface{} 63 | ) 64 | apiURL.Path = path.String() 65 | 66 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 67 | return nil, err 68 | } 69 | return &res, nil 70 | } 71 | 72 | // Returns a list of all TCP Edges on this account 73 | // 74 | // https://ngrok.com/docs/api#api-edges-tcp-list 75 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.TCPEdge] { 76 | if paging == nil { 77 | paging = new(ngrok.Paging) 78 | } 79 | var path bytes.Buffer 80 | if err := template.Must(template.New("list_path").Parse("/edges/tcp")).Execute(&path, paging); err != nil { 81 | panic(err) 82 | } 83 | var apiURL = &url.URL{Path: path.String()} 84 | queryVals := make(url.Values) 85 | if paging.BeforeID != nil { 86 | queryVals.Set("before_id", *paging.BeforeID) 87 | } 88 | if paging.Limit != nil { 89 | queryVals.Set("limit", *paging.Limit) 90 | } 91 | apiURL.RawQuery = queryVals.Encode() 92 | return &iterTCPEdge{ 93 | client: c, 94 | n: -1, 95 | nextPage: apiURL, 96 | } 97 | } 98 | 99 | // iter allows the caller to iterate through a list of values while 100 | // automatically fetching new pages worth of values from the API. 101 | type iterTCPEdge struct { 102 | client *Client 103 | n int 104 | items []ngrok.TCPEdge 105 | err error 106 | 107 | nextPage *url.URL 108 | } 109 | 110 | // Next returns true if there is another value available in the iterator. If it 111 | // returs true it also advances the iterator to that next available item. 112 | func (it *iterTCPEdge) Next(ctx context.Context) bool { 113 | // no more if there is an error 114 | if it.err != nil { 115 | return false 116 | } 117 | 118 | // advance the iterator 119 | it.n += 1 120 | 121 | // is there an available item? 122 | if it.n < len(it.items) { 123 | return true 124 | } 125 | 126 | // no more items, do we have a next page? 127 | if it.nextPage == nil { 128 | return false 129 | } 130 | 131 | // fetch the next page 132 | var resp ngrok.TCPEdgeList 133 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 134 | if err != nil { 135 | it.err = err 136 | return false 137 | } 138 | 139 | // parse the next page URI as soon as we get it and store it 140 | // so we can use it on the next fetch 141 | if resp.NextPageURI != nil { 142 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 143 | if it.err != nil { 144 | return false 145 | } 146 | } else { 147 | it.nextPage = nil 148 | } 149 | 150 | // page with zero items means there are no more 151 | if len(resp.TCPEdges) == 0 { 152 | return false 153 | } 154 | 155 | it.n = -1 156 | it.items = resp.TCPEdges 157 | return it.Next(ctx) 158 | } 159 | 160 | // Item() returns the TCPEdge currently 161 | // pointed to by the iterator. 162 | func (it *iterTCPEdge) Item() *ngrok.TCPEdge { 163 | return &it.items[it.n] 164 | } 165 | 166 | // If Next() returned false because an error was encountered while fetching the 167 | // next value Err() will return that error. A caller should always check Err() 168 | // after Next() returns false. 169 | func (it *iterTCPEdge) Err() error { 170 | return it.err 171 | } 172 | 173 | // Updates a TCP Edge by ID. If a module is not specified in the update, it will 174 | // not be modified. However, each module configuration that is specified will 175 | // completely replace the existing value. There is no way to delete an existing 176 | // module via this API, instead use the delete module API. 177 | // 178 | // https://ngrok.com/docs/api#api-edges-tcp-update 179 | func (c *Client) Update(ctx context.Context, arg *ngrok.TCPEdgeUpdate) (*ngrok.TCPEdge, error) { 180 | if arg == nil { 181 | arg = new(ngrok.TCPEdgeUpdate) 182 | } 183 | var res ngrok.TCPEdge 184 | var path bytes.Buffer 185 | if err := template.Must(template.New("update_path").Parse("/edges/tcp/{{ .ID }}")).Execute(&path, arg); err != nil { 186 | panic(err) 187 | } 188 | arg.ID = "" 189 | var ( 190 | apiURL = &url.URL{Path: path.String()} 191 | bodyArg interface{} 192 | ) 193 | apiURL.Path = path.String() 194 | bodyArg = arg 195 | 196 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 197 | return nil, err 198 | } 199 | return &res, nil 200 | } 201 | 202 | // Delete a TCP Edge by ID 203 | // 204 | // https://ngrok.com/docs/api#api-edges-tcp-delete 205 | func (c *Client) Delete(ctx context.Context, id string) error { 206 | arg := &ngrok.Item{ID: id} 207 | 208 | var path bytes.Buffer 209 | if err := template.Must(template.New("delete_path").Parse("/edges/tcp/{{ .ID }}")).Execute(&path, arg); err != nil { 210 | panic(err) 211 | } 212 | arg.ID = "" 213 | var ( 214 | apiURL = &url.URL{Path: path.String()} 215 | bodyArg interface{} 216 | ) 217 | apiURL.Path = path.String() 218 | 219 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 220 | return err 221 | } 222 | return nil 223 | } 224 | -------------------------------------------------------------------------------- /edges/tls/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create a TLS Edge 24 | // 25 | // https://ngrok.com/docs/api#api-edges-tls-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.TLSEdgeCreate) (*ngrok.TLSEdge, error) { 27 | if arg == nil { 28 | arg = new(ngrok.TLSEdgeCreate) 29 | } 30 | var res ngrok.TLSEdge 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/edges/tls")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Get a TLS Edge by ID 49 | // 50 | // https://ngrok.com/docs/api#api-edges-tls-get 51 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.TLSEdge, error) { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var res ngrok.TLSEdge 55 | var path bytes.Buffer 56 | if err := template.Must(template.New("get_path").Parse("/edges/tls/{{ .ID }}")).Execute(&path, arg); err != nil { 57 | panic(err) 58 | } 59 | arg.ID = "" 60 | var ( 61 | apiURL = &url.URL{Path: path.String()} 62 | bodyArg interface{} 63 | ) 64 | apiURL.Path = path.String() 65 | 66 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 67 | return nil, err 68 | } 69 | return &res, nil 70 | } 71 | 72 | // Returns a list of all TLS Edges on this account 73 | // 74 | // https://ngrok.com/docs/api#api-edges-tls-list 75 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.TLSEdge] { 76 | if paging == nil { 77 | paging = new(ngrok.Paging) 78 | } 79 | var path bytes.Buffer 80 | if err := template.Must(template.New("list_path").Parse("/edges/tls")).Execute(&path, paging); err != nil { 81 | panic(err) 82 | } 83 | var apiURL = &url.URL{Path: path.String()} 84 | queryVals := make(url.Values) 85 | if paging.BeforeID != nil { 86 | queryVals.Set("before_id", *paging.BeforeID) 87 | } 88 | if paging.Limit != nil { 89 | queryVals.Set("limit", *paging.Limit) 90 | } 91 | apiURL.RawQuery = queryVals.Encode() 92 | return &iterTLSEdge{ 93 | client: c, 94 | n: -1, 95 | nextPage: apiURL, 96 | } 97 | } 98 | 99 | // iter allows the caller to iterate through a list of values while 100 | // automatically fetching new pages worth of values from the API. 101 | type iterTLSEdge struct { 102 | client *Client 103 | n int 104 | items []ngrok.TLSEdge 105 | err error 106 | 107 | nextPage *url.URL 108 | } 109 | 110 | // Next returns true if there is another value available in the iterator. If it 111 | // returs true it also advances the iterator to that next available item. 112 | func (it *iterTLSEdge) Next(ctx context.Context) bool { 113 | // no more if there is an error 114 | if it.err != nil { 115 | return false 116 | } 117 | 118 | // advance the iterator 119 | it.n += 1 120 | 121 | // is there an available item? 122 | if it.n < len(it.items) { 123 | return true 124 | } 125 | 126 | // no more items, do we have a next page? 127 | if it.nextPage == nil { 128 | return false 129 | } 130 | 131 | // fetch the next page 132 | var resp ngrok.TLSEdgeList 133 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 134 | if err != nil { 135 | it.err = err 136 | return false 137 | } 138 | 139 | // parse the next page URI as soon as we get it and store it 140 | // so we can use it on the next fetch 141 | if resp.NextPageURI != nil { 142 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 143 | if it.err != nil { 144 | return false 145 | } 146 | } else { 147 | it.nextPage = nil 148 | } 149 | 150 | // page with zero items means there are no more 151 | if len(resp.TLSEdges) == 0 { 152 | return false 153 | } 154 | 155 | it.n = -1 156 | it.items = resp.TLSEdges 157 | return it.Next(ctx) 158 | } 159 | 160 | // Item() returns the TLSEdge currently 161 | // pointed to by the iterator. 162 | func (it *iterTLSEdge) Item() *ngrok.TLSEdge { 163 | return &it.items[it.n] 164 | } 165 | 166 | // If Next() returned false because an error was encountered while fetching the 167 | // next value Err() will return that error. A caller should always check Err() 168 | // after Next() returns false. 169 | func (it *iterTLSEdge) Err() error { 170 | return it.err 171 | } 172 | 173 | // Updates a TLS Edge by ID. If a module is not specified in the update, it will 174 | // not be modified. However, each module configuration that is specified will 175 | // completely replace the existing value. There is no way to delete an existing 176 | // module via this API, instead use the delete module API. 177 | // 178 | // https://ngrok.com/docs/api#api-edges-tls-update 179 | func (c *Client) Update(ctx context.Context, arg *ngrok.TLSEdgeUpdate) (*ngrok.TLSEdge, error) { 180 | if arg == nil { 181 | arg = new(ngrok.TLSEdgeUpdate) 182 | } 183 | var res ngrok.TLSEdge 184 | var path bytes.Buffer 185 | if err := template.Must(template.New("update_path").Parse("/edges/tls/{{ .ID }}")).Execute(&path, arg); err != nil { 186 | panic(err) 187 | } 188 | arg.ID = "" 189 | var ( 190 | apiURL = &url.URL{Path: path.String()} 191 | bodyArg interface{} 192 | ) 193 | apiURL.Path = path.String() 194 | bodyArg = arg 195 | 196 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 197 | return nil, err 198 | } 199 | return &res, nil 200 | } 201 | 202 | // Delete a TLS Edge by ID 203 | // 204 | // https://ngrok.com/docs/api#api-edges-tls-delete 205 | func (c *Client) Delete(ctx context.Context, id string) error { 206 | arg := &ngrok.Item{ID: id} 207 | 208 | var path bytes.Buffer 209 | if err := template.Must(template.New("delete_path").Parse("/edges/tls/{{ .ID }}")).Execute(&path, arg); err != nil { 210 | panic(err) 211 | } 212 | arg.ID = "" 213 | var ( 214 | apiURL = &url.URL{Path: path.String()} 215 | bodyArg interface{} 216 | ) 217 | apiURL.Path = path.String() 218 | 219 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 220 | return err 221 | } 222 | return nil 223 | } 224 | -------------------------------------------------------------------------------- /endpoints/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package endpoints 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // Endpoints provides an API for querying the endpoint objects 16 | // which define what tunnel or edge is used to serve a hostport. 17 | // Only active endpoints associated with a tunnel or backend are returned. 18 | 19 | type Client struct { 20 | apiClient *api.Client 21 | } 22 | 23 | func NewClient(cfg *ngrok.ClientConfig) *Client { 24 | return &Client{apiClient: api.NewClient(cfg)} 25 | } 26 | 27 | // Create an endpoint, currently available only for cloud endpoints 28 | // 29 | // https://ngrok.com/docs/api#api-endpoints-create 30 | func (c *Client) Create(ctx context.Context, arg *ngrok.EndpointCreate) (*ngrok.Endpoint, error) { 31 | var res ngrok.Endpoint 32 | var path bytes.Buffer 33 | if err := template.Must(template.New("create_path").Parse("/endpoints")).Execute(&path, arg); err != nil { 34 | panic(err) 35 | } 36 | var ( 37 | apiURL = &url.URL{Path: path.String()} 38 | bodyArg interface{} 39 | ) 40 | apiURL.Path = path.String() 41 | bodyArg = arg 42 | 43 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 44 | return nil, err 45 | } 46 | return &res, nil 47 | } 48 | 49 | // List all active endpoints on the account 50 | // 51 | // https://ngrok.com/docs/api#api-endpoints-list 52 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.Endpoint] { 53 | if paging == nil { 54 | paging = new(ngrok.Paging) 55 | } 56 | var path bytes.Buffer 57 | if err := template.Must(template.New("list_path").Parse("/endpoints")).Execute(&path, paging); err != nil { 58 | panic(err) 59 | } 60 | var apiURL = &url.URL{Path: path.String()} 61 | queryVals := make(url.Values) 62 | if paging.BeforeID != nil { 63 | queryVals.Set("before_id", *paging.BeforeID) 64 | } 65 | if paging.Limit != nil { 66 | queryVals.Set("limit", *paging.Limit) 67 | } 68 | apiURL.RawQuery = queryVals.Encode() 69 | return &iterEndpoint{ 70 | client: c, 71 | n: -1, 72 | nextPage: apiURL, 73 | } 74 | } 75 | 76 | // iter allows the caller to iterate through a list of values while 77 | // automatically fetching new pages worth of values from the API. 78 | type iterEndpoint struct { 79 | client *Client 80 | n int 81 | items []ngrok.Endpoint 82 | err error 83 | 84 | nextPage *url.URL 85 | } 86 | 87 | // Next returns true if there is another value available in the iterator. If it 88 | // returs true it also advances the iterator to that next available item. 89 | func (it *iterEndpoint) Next(ctx context.Context) bool { 90 | // no more if there is an error 91 | if it.err != nil { 92 | return false 93 | } 94 | 95 | // advance the iterator 96 | it.n += 1 97 | 98 | // is there an available item? 99 | if it.n < len(it.items) { 100 | return true 101 | } 102 | 103 | // no more items, do we have a next page? 104 | if it.nextPage == nil { 105 | return false 106 | } 107 | 108 | // fetch the next page 109 | var resp ngrok.EndpointList 110 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 111 | if err != nil { 112 | it.err = err 113 | return false 114 | } 115 | 116 | // parse the next page URI as soon as we get it and store it 117 | // so we can use it on the next fetch 118 | if resp.NextPageURI != nil { 119 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 120 | if it.err != nil { 121 | return false 122 | } 123 | } else { 124 | it.nextPage = nil 125 | } 126 | 127 | // page with zero items means there are no more 128 | if len(resp.Endpoints) == 0 { 129 | return false 130 | } 131 | 132 | it.n = -1 133 | it.items = resp.Endpoints 134 | return it.Next(ctx) 135 | } 136 | 137 | // Item() returns the Endpoint currently 138 | // pointed to by the iterator. 139 | func (it *iterEndpoint) Item() *ngrok.Endpoint { 140 | return &it.items[it.n] 141 | } 142 | 143 | // If Next() returned false because an error was encountered while fetching the 144 | // next value Err() will return that error. A caller should always check Err() 145 | // after Next() returns false. 146 | func (it *iterEndpoint) Err() error { 147 | return it.err 148 | } 149 | 150 | // Get the status of an endpoint by ID 151 | // 152 | // https://ngrok.com/docs/api#api-endpoints-get 153 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.Endpoint, error) { 154 | arg := &ngrok.Item{ID: id} 155 | 156 | var res ngrok.Endpoint 157 | var path bytes.Buffer 158 | if err := template.Must(template.New("get_path").Parse("/endpoints/{{ .ID }}")).Execute(&path, arg); err != nil { 159 | panic(err) 160 | } 161 | arg.ID = "" 162 | var ( 163 | apiURL = &url.URL{Path: path.String()} 164 | bodyArg interface{} 165 | ) 166 | apiURL.Path = path.String() 167 | 168 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 169 | return nil, err 170 | } 171 | return &res, nil 172 | } 173 | 174 | // Update an Endpoint by ID, currently available only for cloud endpoints 175 | // 176 | // https://ngrok.com/docs/api#api-endpoints-update 177 | func (c *Client) Update(ctx context.Context, arg *ngrok.EndpointUpdate) (*ngrok.Endpoint, error) { 178 | if arg == nil { 179 | arg = new(ngrok.EndpointUpdate) 180 | } 181 | var res ngrok.Endpoint 182 | var path bytes.Buffer 183 | if err := template.Must(template.New("update_path").Parse("/endpoints/{{ .ID }}")).Execute(&path, arg); err != nil { 184 | panic(err) 185 | } 186 | arg.ID = "" 187 | var ( 188 | apiURL = &url.URL{Path: path.String()} 189 | bodyArg interface{} 190 | ) 191 | apiURL.Path = path.String() 192 | bodyArg = arg 193 | 194 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 195 | return nil, err 196 | } 197 | return &res, nil 198 | } 199 | 200 | // Delete an Endpoint by ID, currently available only for cloud endpoints 201 | // 202 | // https://ngrok.com/docs/api#api-endpoints-delete 203 | func (c *Client) Delete(ctx context.Context, id string) error { 204 | arg := &ngrok.Item{ID: id} 205 | 206 | var path bytes.Buffer 207 | if err := template.Must(template.New("delete_path").Parse("/endpoints/{{ .ID }}")).Execute(&path, arg); err != nil { 208 | panic(err) 209 | } 210 | arg.ID = "" 211 | var ( 212 | apiURL = &url.URL{Path: path.String()} 213 | bodyArg interface{} 214 | ) 215 | apiURL.Path = path.String() 216 | 217 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 218 | return err 219 | } 220 | return nil 221 | } 222 | -------------------------------------------------------------------------------- /error.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import ( 6 | "fmt" 7 | "net/http" 8 | ) 9 | 10 | // Returns true if the error is a not found response from the ngrok API. 11 | func IsNotFound(err error) bool { 12 | if ee, ok := err.(*Error); ok { 13 | return int(ee.StatusCode) == http.StatusNotFound 14 | } 15 | return false 16 | } 17 | 18 | // Returns true if the given error is caused by any of the specified ngrok error codes. 19 | // All ngrok error codes are documented at https://ngrok.com/docs/errors 20 | func IsErrorCode(err error, codes ...int) bool { 21 | if ee, ok := err.(*Error); ok { 22 | for _, code := range codes { 23 | if ee.ErrorCode == fmt.Sprintf("ERR_NGROK_%d", code) { 24 | return true 25 | } 26 | } 27 | } 28 | return false 29 | } 30 | 31 | func (e *Error) Error() string { 32 | msg := fmt.Sprintf("HTTP %d: %s", e.StatusCode, e.Msg) 33 | if e.ErrorCode != "" { 34 | msg += fmt.Sprintf(" [%s]", e.ErrorCode) 35 | } 36 | if e.OperationID() != "" { 37 | msg += fmt.Sprintf("\n\nOperation ID: %s", e.OperationID()) 38 | } 39 | return msg 40 | } 41 | 42 | // OperationID returns the unique trace ID assigned by ngrok to this API 43 | // request. 44 | func (e *Error) OperationID() string { 45 | return e.Details["operation_id"] 46 | } 47 | -------------------------------------------------------------------------------- /event_destinations/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package event_destinations 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create a new Event Destination. It will not apply to anything until it is 24 | // associated with an Event Subscription. 25 | // 26 | // https://ngrok.com/docs/api#api-event-destinations-create 27 | func (c *Client) Create(ctx context.Context, arg *ngrok.EventDestinationCreate) (*ngrok.EventDestination, error) { 28 | if arg == nil { 29 | arg = new(ngrok.EventDestinationCreate) 30 | } 31 | var res ngrok.EventDestination 32 | var path bytes.Buffer 33 | if err := template.Must(template.New("create_path").Parse("/event_destinations")).Execute(&path, arg); err != nil { 34 | panic(err) 35 | } 36 | var ( 37 | apiURL = &url.URL{Path: path.String()} 38 | bodyArg interface{} 39 | ) 40 | apiURL.Path = path.String() 41 | bodyArg = arg 42 | 43 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 44 | return nil, err 45 | } 46 | return &res, nil 47 | } 48 | 49 | // Delete an Event Destination. If the Event Destination is still referenced by an 50 | // Event Subscription. 51 | // 52 | // https://ngrok.com/docs/api#api-event-destinations-delete 53 | func (c *Client) Delete(ctx context.Context, id string) error { 54 | arg := &ngrok.Item{ID: id} 55 | 56 | var path bytes.Buffer 57 | if err := template.Must(template.New("delete_path").Parse("/event_destinations/{{ .ID }}")).Execute(&path, arg); err != nil { 58 | panic(err) 59 | } 60 | arg.ID = "" 61 | var ( 62 | apiURL = &url.URL{Path: path.String()} 63 | bodyArg interface{} 64 | ) 65 | apiURL.Path = path.String() 66 | 67 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 68 | return err 69 | } 70 | return nil 71 | } 72 | 73 | // Get detailed information about an Event Destination by ID. 74 | // 75 | // https://ngrok.com/docs/api#api-event-destinations-get 76 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EventDestination, error) { 77 | arg := &ngrok.Item{ID: id} 78 | 79 | var res ngrok.EventDestination 80 | var path bytes.Buffer 81 | if err := template.Must(template.New("get_path").Parse("/event_destinations/{{ .ID }}")).Execute(&path, arg); err != nil { 82 | panic(err) 83 | } 84 | arg.ID = "" 85 | var ( 86 | apiURL = &url.URL{Path: path.String()} 87 | bodyArg interface{} 88 | ) 89 | apiURL.Path = path.String() 90 | 91 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 92 | return nil, err 93 | } 94 | return &res, nil 95 | } 96 | 97 | // List all Event Destinations on this account. 98 | // 99 | // https://ngrok.com/docs/api#api-event-destinations-list 100 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.EventDestination] { 101 | if paging == nil { 102 | paging = new(ngrok.Paging) 103 | } 104 | var path bytes.Buffer 105 | if err := template.Must(template.New("list_path").Parse("/event_destinations")).Execute(&path, paging); err != nil { 106 | panic(err) 107 | } 108 | var apiURL = &url.URL{Path: path.String()} 109 | queryVals := make(url.Values) 110 | if paging.BeforeID != nil { 111 | queryVals.Set("before_id", *paging.BeforeID) 112 | } 113 | if paging.Limit != nil { 114 | queryVals.Set("limit", *paging.Limit) 115 | } 116 | apiURL.RawQuery = queryVals.Encode() 117 | return &iterEventDestination{ 118 | client: c, 119 | n: -1, 120 | nextPage: apiURL, 121 | } 122 | } 123 | 124 | // iter allows the caller to iterate through a list of values while 125 | // automatically fetching new pages worth of values from the API. 126 | type iterEventDestination struct { 127 | client *Client 128 | n int 129 | items []ngrok.EventDestination 130 | err error 131 | 132 | nextPage *url.URL 133 | } 134 | 135 | // Next returns true if there is another value available in the iterator. If it 136 | // returs true it also advances the iterator to that next available item. 137 | func (it *iterEventDestination) Next(ctx context.Context) bool { 138 | // no more if there is an error 139 | if it.err != nil { 140 | return false 141 | } 142 | 143 | // advance the iterator 144 | it.n += 1 145 | 146 | // is there an available item? 147 | if it.n < len(it.items) { 148 | return true 149 | } 150 | 151 | // no more items, do we have a next page? 152 | if it.nextPage == nil { 153 | return false 154 | } 155 | 156 | // fetch the next page 157 | var resp ngrok.EventDestinationList 158 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 159 | if err != nil { 160 | it.err = err 161 | return false 162 | } 163 | 164 | // parse the next page URI as soon as we get it and store it 165 | // so we can use it on the next fetch 166 | if resp.NextPageURI != nil { 167 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 168 | if it.err != nil { 169 | return false 170 | } 171 | } else { 172 | it.nextPage = nil 173 | } 174 | 175 | // page with zero items means there are no more 176 | if len(resp.EventDestinations) == 0 { 177 | return false 178 | } 179 | 180 | it.n = -1 181 | it.items = resp.EventDestinations 182 | return it.Next(ctx) 183 | } 184 | 185 | // Item() returns the EventDestination currently 186 | // pointed to by the iterator. 187 | func (it *iterEventDestination) Item() *ngrok.EventDestination { 188 | return &it.items[it.n] 189 | } 190 | 191 | // If Next() returned false because an error was encountered while fetching the 192 | // next value Err() will return that error. A caller should always check Err() 193 | // after Next() returns false. 194 | func (it *iterEventDestination) Err() error { 195 | return it.err 196 | } 197 | 198 | // Update attributes of an Event Destination. 199 | // 200 | // https://ngrok.com/docs/api#api-event-destinations-update 201 | func (c *Client) Update(ctx context.Context, arg *ngrok.EventDestinationUpdate) (*ngrok.EventDestination, error) { 202 | if arg == nil { 203 | arg = new(ngrok.EventDestinationUpdate) 204 | } 205 | var res ngrok.EventDestination 206 | var path bytes.Buffer 207 | if err := template.Must(template.New("update_path").Parse("/event_destinations/{{ .ID }}")).Execute(&path, arg); err != nil { 208 | panic(err) 209 | } 210 | arg.ID = "" 211 | var ( 212 | apiURL = &url.URL{Path: path.String()} 213 | bodyArg interface{} 214 | ) 215 | apiURL.Path = path.String() 216 | bodyArg = arg 217 | 218 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 219 | return nil, err 220 | } 221 | return &res, nil 222 | } 223 | -------------------------------------------------------------------------------- /event_sources/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package event_sources 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Add an additional type for which this event subscription will trigger 24 | // 25 | // https://ngrok.com/docs/api#api-event-sources-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.EventSourceCreate) (*ngrok.EventSource, error) { 27 | if arg == nil { 28 | arg = new(ngrok.EventSourceCreate) 29 | } 30 | var res ngrok.EventSource 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/event_subscriptions/{{ .SubscriptionID }}/sources")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | arg.SubscriptionID = "" 36 | var ( 37 | apiURL = &url.URL{Path: path.String()} 38 | bodyArg interface{} 39 | ) 40 | apiURL.Path = path.String() 41 | bodyArg = arg 42 | 43 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 44 | return nil, err 45 | } 46 | return &res, nil 47 | } 48 | 49 | // Remove a type for which this event subscription will trigger 50 | // 51 | // https://ngrok.com/docs/api#api-event-sources-delete 52 | func (c *Client) Delete(ctx context.Context, arg *ngrok.EventSourceItem) error { 53 | if arg == nil { 54 | arg = new(ngrok.EventSourceItem) 55 | } 56 | var path bytes.Buffer 57 | if err := template.Must(template.New("delete_path").Parse("/event_subscriptions/{{ .SubscriptionID }}/sources/{{ .Type }}")).Execute(&path, arg); err != nil { 58 | panic(err) 59 | } 60 | arg.SubscriptionID = "" 61 | arg.Type = "" 62 | var ( 63 | apiURL = &url.URL{Path: path.String()} 64 | bodyArg interface{} 65 | ) 66 | apiURL.Path = path.String() 67 | 68 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 69 | return err 70 | } 71 | return nil 72 | } 73 | 74 | // Get the details for a given type that triggers for the given event subscription 75 | // 76 | // https://ngrok.com/docs/api#api-event-sources-get 77 | func (c *Client) Get(ctx context.Context, arg *ngrok.EventSourceItem) (*ngrok.EventSource, error) { 78 | if arg == nil { 79 | arg = new(ngrok.EventSourceItem) 80 | } 81 | var res ngrok.EventSource 82 | var path bytes.Buffer 83 | if err := template.Must(template.New("get_path").Parse("/event_subscriptions/{{ .SubscriptionID }}/sources/{{ .Type }}")).Execute(&path, arg); err != nil { 84 | panic(err) 85 | } 86 | arg.SubscriptionID = "" 87 | arg.Type = "" 88 | var ( 89 | apiURL = &url.URL{Path: path.String()} 90 | bodyArg interface{} 91 | ) 92 | apiURL.Path = path.String() 93 | 94 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 95 | return nil, err 96 | } 97 | return &res, nil 98 | } 99 | 100 | // List the types for which this event subscription will trigger 101 | // 102 | // https://ngrok.com/docs/api#api-event-sources-list 103 | func (c *Client) List(ctx context.Context, subscriptionId string) (*ngrok.EventSourceList, error) { 104 | arg := &ngrok.EventSourcePaging{SubscriptionID: subscriptionId} 105 | 106 | var res ngrok.EventSourceList 107 | var path bytes.Buffer 108 | if err := template.Must(template.New("list_path").Parse("/event_subscriptions/{{ .SubscriptionID }}/sources")).Execute(&path, arg); err != nil { 109 | panic(err) 110 | } 111 | arg.SubscriptionID = "" 112 | var ( 113 | apiURL = &url.URL{Path: path.String()} 114 | bodyArg interface{} 115 | ) 116 | apiURL.Path = path.String() 117 | 118 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 119 | return nil, err 120 | } 121 | return &res, nil 122 | } 123 | 124 | // Update the type for which this event subscription will trigger 125 | // 126 | // https://ngrok.com/docs/api#api-event-sources-update 127 | func (c *Client) Update(ctx context.Context, arg *ngrok.EventSourceUpdate) (*ngrok.EventSource, error) { 128 | if arg == nil { 129 | arg = new(ngrok.EventSourceUpdate) 130 | } 131 | var res ngrok.EventSource 132 | var path bytes.Buffer 133 | if err := template.Must(template.New("update_path").Parse("/event_subscriptions/{{ .SubscriptionID }}/sources/{{ .Type }}")).Execute(&path, arg); err != nil { 134 | panic(err) 135 | } 136 | arg.SubscriptionID = "" 137 | arg.Type = "" 138 | var ( 139 | apiURL = &url.URL{Path: path.String()} 140 | bodyArg interface{} 141 | ) 142 | apiURL.Path = path.String() 143 | bodyArg = arg 144 | 145 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 146 | return nil, err 147 | } 148 | return &res, nil 149 | } 150 | -------------------------------------------------------------------------------- /event_subscriptions/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package event_subscriptions 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | type Client struct { 16 | apiClient *api.Client 17 | } 18 | 19 | func NewClient(cfg *ngrok.ClientConfig) *Client { 20 | return &Client{apiClient: api.NewClient(cfg)} 21 | } 22 | 23 | // Create an Event Subscription. 24 | // 25 | // https://ngrok.com/docs/api#api-event-subscriptions-create 26 | func (c *Client) Create(ctx context.Context, arg *ngrok.EventSubscriptionCreate) (*ngrok.EventSubscription, error) { 27 | if arg == nil { 28 | arg = new(ngrok.EventSubscriptionCreate) 29 | } 30 | var res ngrok.EventSubscription 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/event_subscriptions")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Delete an Event Subscription. 49 | // 50 | // https://ngrok.com/docs/api#api-event-subscriptions-delete 51 | func (c *Client) Delete(ctx context.Context, id string) error { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var path bytes.Buffer 55 | if err := template.Must(template.New("delete_path").Parse("/event_subscriptions/{{ .ID }}")).Execute(&path, arg); err != nil { 56 | panic(err) 57 | } 58 | arg.ID = "" 59 | var ( 60 | apiURL = &url.URL{Path: path.String()} 61 | bodyArg interface{} 62 | ) 63 | apiURL.Path = path.String() 64 | 65 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 66 | return err 67 | } 68 | return nil 69 | } 70 | 71 | // Get an Event Subscription by ID. 72 | // 73 | // https://ngrok.com/docs/api#api-event-subscriptions-get 74 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.EventSubscription, error) { 75 | arg := &ngrok.Item{ID: id} 76 | 77 | var res ngrok.EventSubscription 78 | var path bytes.Buffer 79 | if err := template.Must(template.New("get_path").Parse("/event_subscriptions/{{ .ID }}")).Execute(&path, arg); err != nil { 80 | panic(err) 81 | } 82 | arg.ID = "" 83 | var ( 84 | apiURL = &url.URL{Path: path.String()} 85 | bodyArg interface{} 86 | ) 87 | apiURL.Path = path.String() 88 | 89 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 90 | return nil, err 91 | } 92 | return &res, nil 93 | } 94 | 95 | // List this Account's Event Subscriptions. 96 | // 97 | // https://ngrok.com/docs/api#api-event-subscriptions-list 98 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.EventSubscription] { 99 | if paging == nil { 100 | paging = new(ngrok.Paging) 101 | } 102 | var path bytes.Buffer 103 | if err := template.Must(template.New("list_path").Parse("/event_subscriptions")).Execute(&path, paging); err != nil { 104 | panic(err) 105 | } 106 | var apiURL = &url.URL{Path: path.String()} 107 | queryVals := make(url.Values) 108 | if paging.BeforeID != nil { 109 | queryVals.Set("before_id", *paging.BeforeID) 110 | } 111 | if paging.Limit != nil { 112 | queryVals.Set("limit", *paging.Limit) 113 | } 114 | apiURL.RawQuery = queryVals.Encode() 115 | return &iterEventSubscription{ 116 | client: c, 117 | n: -1, 118 | nextPage: apiURL, 119 | } 120 | } 121 | 122 | // iter allows the caller to iterate through a list of values while 123 | // automatically fetching new pages worth of values from the API. 124 | type iterEventSubscription struct { 125 | client *Client 126 | n int 127 | items []ngrok.EventSubscription 128 | err error 129 | 130 | nextPage *url.URL 131 | } 132 | 133 | // Next returns true if there is another value available in the iterator. If it 134 | // returs true it also advances the iterator to that next available item. 135 | func (it *iterEventSubscription) Next(ctx context.Context) bool { 136 | // no more if there is an error 137 | if it.err != nil { 138 | return false 139 | } 140 | 141 | // advance the iterator 142 | it.n += 1 143 | 144 | // is there an available item? 145 | if it.n < len(it.items) { 146 | return true 147 | } 148 | 149 | // no more items, do we have a next page? 150 | if it.nextPage == nil { 151 | return false 152 | } 153 | 154 | // fetch the next page 155 | var resp ngrok.EventSubscriptionList 156 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 157 | if err != nil { 158 | it.err = err 159 | return false 160 | } 161 | 162 | // parse the next page URI as soon as we get it and store it 163 | // so we can use it on the next fetch 164 | if resp.NextPageURI != nil { 165 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 166 | if it.err != nil { 167 | return false 168 | } 169 | } else { 170 | it.nextPage = nil 171 | } 172 | 173 | // page with zero items means there are no more 174 | if len(resp.EventSubscriptions) == 0 { 175 | return false 176 | } 177 | 178 | it.n = -1 179 | it.items = resp.EventSubscriptions 180 | return it.Next(ctx) 181 | } 182 | 183 | // Item() returns the EventSubscription currently 184 | // pointed to by the iterator. 185 | func (it *iterEventSubscription) Item() *ngrok.EventSubscription { 186 | return &it.items[it.n] 187 | } 188 | 189 | // If Next() returned false because an error was encountered while fetching the 190 | // next value Err() will return that error. A caller should always check Err() 191 | // after Next() returns false. 192 | func (it *iterEventSubscription) Err() error { 193 | return it.err 194 | } 195 | 196 | // Update an Event Subscription. 197 | // 198 | // https://ngrok.com/docs/api#api-event-subscriptions-update 199 | func (c *Client) Update(ctx context.Context, arg *ngrok.EventSubscriptionUpdate) (*ngrok.EventSubscription, error) { 200 | if arg == nil { 201 | arg = new(ngrok.EventSubscriptionUpdate) 202 | } 203 | var res ngrok.EventSubscription 204 | var path bytes.Buffer 205 | if err := template.Must(template.New("update_path").Parse("/event_subscriptions/{{ .ID }}")).Execute(&path, arg); err != nil { 206 | panic(err) 207 | } 208 | arg.ID = "" 209 | var ( 210 | apiURL = &url.URL{Path: path.String()} 211 | bodyArg interface{} 212 | ) 213 | apiURL.Path = path.String() 214 | bodyArg = arg 215 | 216 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 217 | return nil, err 218 | } 219 | return &res, nil 220 | } 221 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | module github.com/ngrok/ngrok-api-go/v7 4 | 5 | go 1.18 6 | 7 | require github.com/stretchr/testify v1.10.0 8 | 9 | require ( 10 | github.com/davecgh/go-spew v1.1.1 // indirect 11 | github.com/pmezard/go-difflib v1.0.0 // indirect 12 | gopkg.in/yaml.v3 v3.0.1 // indirect 13 | ) 14 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 2 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= 6 | github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 7 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 9 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 10 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 11 | -------------------------------------------------------------------------------- /integration_test.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok_test 4 | 5 | import ( 6 | "context" 7 | "net/http" 8 | "os" 9 | "testing" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/ip_policies" 13 | "github.com/stretchr/testify/require" 14 | ) 15 | 16 | var mocksEnabled = os.Getenv("TEST_NO_MOCK") != "true" 17 | 18 | func TestIPPolicy(t *testing.T) { 19 | var opts []ngrok.ClientConfigOption 20 | 21 | var mock mockTransport 22 | if mocksEnabled { 23 | opts = append(opts, ngrok.WithHTTPClient(&http.Client{ 24 | Transport: &mock, 25 | })) 26 | } else if os.Getenv("TEST_DEBUG") == "true" { 27 | // dump requests and responses to stdout 28 | opts = append(opts, ngrok.WithHTTPClient(&http.Client{ 29 | Transport: &debugTransport{ 30 | rt: http.DefaultTransport, 31 | out: os.Stderr, 32 | }, 33 | })) 34 | } 35 | 36 | ctx := context.Background() 37 | clientConfig := ngrok.NewClientConfig(os.Getenv("NGROK_API_KEY"), opts...) 38 | policies := ip_policies.NewClient(clientConfig) 39 | 40 | // test policy creation 41 | mock.SetResponse(201, `{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":""}`) 42 | createInstance, err := policies.Create(ctx, &ngrok.IPPolicyCreate{ 43 | Description: "ngrok-api-go tests", 44 | }) 45 | require.NoError(t, err) 46 | 47 | // test get 48 | mock.SetResponse(200, `{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":""}`) 49 | getInstance, err := policies.Get(ctx, createInstance.ID) 50 | require.NoError(t, err) 51 | require.Equal(t, createInstance, getInstance) 52 | 53 | // test update 54 | mock.SetResponse(200, `{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":"{\"device-id\": \"malamute-12\"}"}`) 55 | metadata := `{"device-id": "malamute-12"}` 56 | updatedInstance, err := policies.Update(ctx, &ngrok.IPPolicyUpdate{ 57 | ID: createInstance.ID, 58 | Metadata: ngrok.String(metadata), 59 | }) 60 | require.NoError(t, err) 61 | require.Equal(t, updatedInstance.Metadata, metadata) 62 | 63 | // test get after update 64 | mock.SetResponse(200, `{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":"{\"device-id\": \"malamute-12\"}"}`) 65 | getAfterUpdateInstance, err := policies.Get(ctx, createInstance.ID) 66 | require.NoError(t, err) 67 | require.Equal(t, updatedInstance, getAfterUpdateInstance) 68 | 69 | mock.SetResponse(200, `{"ip_policies":[{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":"{\"device-id\": \"malamute-12\"}"},{"id":"ipp_1qXI4T0q6cgkoOVvqSEjU7LiWIr","uri":"https://api.ngrok.com/ip_policies/ipp_1qXI4T0q6cgkoOVvqSEjU7LiWIr","created_at":"2021-03-31T19:35:16Z","description":"martin demo","metadata":""}],"uri":"https://api.ngrok.com/ip_policies","next_page_uri":null}`) 70 | iter := policies.List(nil) 71 | var iterPolicies []*ngrok.IPPolicy 72 | for iter.Next(ctx) { 73 | iterPolicies = append(iterPolicies, iter.Item()) 74 | } 75 | require.NoError(t, iter.Err()) 76 | require.Contains(t, iterPolicies, updatedInstance) 77 | 78 | // test delete 79 | mock.SetResponse(204, "") 80 | err = policies.Delete(ctx, createInstance.ID) 81 | require.NoError(t, err) 82 | 83 | // test 404 84 | mock.SetResponse(404, `{"status_code":404,"msg":"Resource not found","details":{"operation_id":"op_1sbMfWvXaRA26gTJoBPIgyPD8MF"}}`) 85 | _, err = policies.Get(ctx, createInstance.ID) 86 | require.True(t, ngrok.IsNotFound(err)) 87 | } 88 | 89 | func TestIPPoliciesListMultiplePages(t *testing.T) { 90 | if !mocksEnabled { 91 | t.Skip("skipping test in live mode") 92 | } 93 | 94 | var opts []ngrok.ClientConfigOption 95 | var mock mockTransport 96 | opts = append(opts, ngrok.WithHTTPClient(&http.Client{ 97 | Transport: &mock, 98 | })) 99 | 100 | ctx := context.Background() 101 | clientConfig := ngrok.NewClientConfig(os.Getenv("NGROK_API_KEY"), opts...) 102 | policies := ip_policies.NewClient(clientConfig) 103 | 104 | mock.SetResponse(200, `{"ip_policies":[{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDC","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDC","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests","metadata":"{\"device-id\": \"malamute-12\"}"},{"id":"ipp_1qXI4T0q6cgkoOVvqSEjU7LiWIr","uri":"https://api.ngrok.com/ip_policies/ipp_1qXI4T0q6cgkoOVvqSEjU7LiWIr","created_at":"2021-03-31T19:35:16Z","description":"martin demo","metadata":""}],"uri":"https://api.ngrok.com/ip_policies","next_page_uri":"https://api.ngrok.com/ip_policies?limit=2&before_id=ipp_1qXI4T0q6cgkoOVvqSEjU7LiWIr"}`) 105 | mock.SetResponse(200, `{"ip_policies":[{"id":"ipp_1sbMfZquosZtu5mZPgA91UDFaDD","uri":"https://api.ngrok.com/ip_policies/ipp_1sbMfZquosZtu5mZPgA91UDFaDD","created_at":"2021-05-16T03:48:59Z","description":"ngrok-api-go tests 2","metadata":"{\"device-id\": \"malamute-12\"}"}],"uri":"https://api.ngrok.com/ip_policies","next_page_uri":null}`) 106 | iter := policies.List(nil) 107 | var iterPolicies []*ngrok.IPPolicy 108 | for iter.Next(ctx) { 109 | iterPolicies = append(iterPolicies, iter.Item()) 110 | } 111 | require.NoError(t, iter.Err()) 112 | require.Len(t, iterPolicies, 3) 113 | } 114 | -------------------------------------------------------------------------------- /internal/api/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package api 4 | 5 | import "github.com/ngrok/ngrok-api-go/v7" 6 | 7 | type Client = ngrok.BaseClient 8 | 9 | func NewClient(cfg *ngrok.ClientConfig) *Client { 10 | return ngrok.NewBaseClient(cfg) 11 | } 12 | -------------------------------------------------------------------------------- /internal/api/client_test.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package api 4 | 5 | // Dummy file to satisfy our code generation pipeline 6 | -------------------------------------------------------------------------------- /internal/api/version.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package api 4 | 5 | // Dummy file to satisfy our code generation pipeline 6 | -------------------------------------------------------------------------------- /ip_policy_rules/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ip_policy_rules 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // IP Policy Rules are the IPv4 or IPv6 CIDRs entries that 16 | // make up an IP Policy. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // Create a new IP policy rule attached to an IP Policy. 27 | // 28 | // https://ngrok.com/docs/api#api-ip-policy-rules-create 29 | func (c *Client) Create(ctx context.Context, arg *ngrok.IPPolicyRuleCreate) (*ngrok.IPPolicyRule, error) { 30 | var res ngrok.IPPolicyRule 31 | var path bytes.Buffer 32 | if err := template.Must(template.New("create_path").Parse("/ip_policy_rules")).Execute(&path, arg); err != nil { 33 | panic(err) 34 | } 35 | var ( 36 | apiURL = &url.URL{Path: path.String()} 37 | bodyArg interface{} 38 | ) 39 | apiURL.Path = path.String() 40 | bodyArg = arg 41 | 42 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 43 | return nil, err 44 | } 45 | return &res, nil 46 | } 47 | 48 | // Delete an IP policy rule. 49 | // 50 | // https://ngrok.com/docs/api#api-ip-policy-rules-delete 51 | func (c *Client) Delete(ctx context.Context, id string) error { 52 | arg := &ngrok.Item{ID: id} 53 | 54 | var path bytes.Buffer 55 | if err := template.Must(template.New("delete_path").Parse("/ip_policy_rules/{{ .ID }}")).Execute(&path, arg); err != nil { 56 | panic(err) 57 | } 58 | arg.ID = "" 59 | var ( 60 | apiURL = &url.URL{Path: path.String()} 61 | bodyArg interface{} 62 | ) 63 | apiURL.Path = path.String() 64 | 65 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 66 | return err 67 | } 68 | return nil 69 | } 70 | 71 | // Get detailed information about an IP policy rule by ID. 72 | // 73 | // https://ngrok.com/docs/api#api-ip-policy-rules-get 74 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.IPPolicyRule, error) { 75 | arg := &ngrok.Item{ID: id} 76 | 77 | var res ngrok.IPPolicyRule 78 | var path bytes.Buffer 79 | if err := template.Must(template.New("get_path").Parse("/ip_policy_rules/{{ .ID }}")).Execute(&path, arg); err != nil { 80 | panic(err) 81 | } 82 | arg.ID = "" 83 | var ( 84 | apiURL = &url.URL{Path: path.String()} 85 | bodyArg interface{} 86 | ) 87 | apiURL.Path = path.String() 88 | 89 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 90 | return nil, err 91 | } 92 | return &res, nil 93 | } 94 | 95 | // List all IP policy rules on this account 96 | // 97 | // https://ngrok.com/docs/api#api-ip-policy-rules-list 98 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.IPPolicyRule] { 99 | if paging == nil { 100 | paging = new(ngrok.Paging) 101 | } 102 | var path bytes.Buffer 103 | if err := template.Must(template.New("list_path").Parse("/ip_policy_rules")).Execute(&path, paging); err != nil { 104 | panic(err) 105 | } 106 | var apiURL = &url.URL{Path: path.String()} 107 | queryVals := make(url.Values) 108 | if paging.BeforeID != nil { 109 | queryVals.Set("before_id", *paging.BeforeID) 110 | } 111 | if paging.Limit != nil { 112 | queryVals.Set("limit", *paging.Limit) 113 | } 114 | apiURL.RawQuery = queryVals.Encode() 115 | return &iterIPPolicyRule{ 116 | client: c, 117 | n: -1, 118 | nextPage: apiURL, 119 | } 120 | } 121 | 122 | // iter allows the caller to iterate through a list of values while 123 | // automatically fetching new pages worth of values from the API. 124 | type iterIPPolicyRule struct { 125 | client *Client 126 | n int 127 | items []ngrok.IPPolicyRule 128 | err error 129 | 130 | nextPage *url.URL 131 | } 132 | 133 | // Next returns true if there is another value available in the iterator. If it 134 | // returs true it also advances the iterator to that next available item. 135 | func (it *iterIPPolicyRule) Next(ctx context.Context) bool { 136 | // no more if there is an error 137 | if it.err != nil { 138 | return false 139 | } 140 | 141 | // advance the iterator 142 | it.n += 1 143 | 144 | // is there an available item? 145 | if it.n < len(it.items) { 146 | return true 147 | } 148 | 149 | // no more items, do we have a next page? 150 | if it.nextPage == nil { 151 | return false 152 | } 153 | 154 | // fetch the next page 155 | var resp ngrok.IPPolicyRuleList 156 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 157 | if err != nil { 158 | it.err = err 159 | return false 160 | } 161 | 162 | // parse the next page URI as soon as we get it and store it 163 | // so we can use it on the next fetch 164 | if resp.NextPageURI != nil { 165 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 166 | if it.err != nil { 167 | return false 168 | } 169 | } else { 170 | it.nextPage = nil 171 | } 172 | 173 | // page with zero items means there are no more 174 | if len(resp.IPPolicyRules) == 0 { 175 | return false 176 | } 177 | 178 | it.n = -1 179 | it.items = resp.IPPolicyRules 180 | return it.Next(ctx) 181 | } 182 | 183 | // Item() returns the IPPolicyRule currently 184 | // pointed to by the iterator. 185 | func (it *iterIPPolicyRule) Item() *ngrok.IPPolicyRule { 186 | return &it.items[it.n] 187 | } 188 | 189 | // If Next() returned false because an error was encountered while fetching the 190 | // next value Err() will return that error. A caller should always check Err() 191 | // after Next() returns false. 192 | func (it *iterIPPolicyRule) Err() error { 193 | return it.err 194 | } 195 | 196 | // Update attributes of an IP policy rule by ID 197 | // 198 | // https://ngrok.com/docs/api#api-ip-policy-rules-update 199 | func (c *Client) Update(ctx context.Context, arg *ngrok.IPPolicyRuleUpdate) (*ngrok.IPPolicyRule, error) { 200 | if arg == nil { 201 | arg = new(ngrok.IPPolicyRuleUpdate) 202 | } 203 | var res ngrok.IPPolicyRule 204 | var path bytes.Buffer 205 | if err := template.Must(template.New("update_path").Parse("/ip_policy_rules/{{ .ID }}")).Execute(&path, arg); err != nil { 206 | panic(err) 207 | } 208 | arg.ID = "" 209 | var ( 210 | apiURL = &url.URL{Path: path.String()} 211 | bodyArg interface{} 212 | ) 213 | apiURL.Path = path.String() 214 | bodyArg = arg 215 | 216 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 217 | return nil, err 218 | } 219 | return &res, nil 220 | } 221 | -------------------------------------------------------------------------------- /iter.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import ( 6 | "context" 7 | ) 8 | 9 | type Iter[T any] interface { 10 | Next(context.Context) bool 11 | Item() T 12 | Err() error 13 | } 14 | -------------------------------------------------------------------------------- /reserved_addrs/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package reserved_addrs 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // Reserved Addresses are TCP addresses that can be used to listen for traffic. 16 | // TCP address hostnames and ports are assigned by ngrok, they cannot be 17 | // chosen. 18 | 19 | type Client struct { 20 | apiClient *api.Client 21 | } 22 | 23 | func NewClient(cfg *ngrok.ClientConfig) *Client { 24 | return &Client{apiClient: api.NewClient(cfg)} 25 | } 26 | 27 | // Create a new reserved address. 28 | // 29 | // https://ngrok.com/docs/api#api-reserved-addrs-create 30 | func (c *Client) Create(ctx context.Context, arg *ngrok.ReservedAddrCreate) (*ngrok.ReservedAddr, error) { 31 | if arg == nil { 32 | arg = new(ngrok.ReservedAddrCreate) 33 | } 34 | var res ngrok.ReservedAddr 35 | var path bytes.Buffer 36 | if err := template.Must(template.New("create_path").Parse("/reserved_addrs")).Execute(&path, arg); err != nil { 37 | panic(err) 38 | } 39 | var ( 40 | apiURL = &url.URL{Path: path.String()} 41 | bodyArg interface{} 42 | ) 43 | apiURL.Path = path.String() 44 | bodyArg = arg 45 | 46 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 47 | return nil, err 48 | } 49 | return &res, nil 50 | } 51 | 52 | // Delete a reserved address. 53 | // 54 | // https://ngrok.com/docs/api#api-reserved-addrs-delete 55 | func (c *Client) Delete(ctx context.Context, id string) error { 56 | arg := &ngrok.Item{ID: id} 57 | 58 | var path bytes.Buffer 59 | if err := template.Must(template.New("delete_path").Parse("/reserved_addrs/{{ .ID }}")).Execute(&path, arg); err != nil { 60 | panic(err) 61 | } 62 | arg.ID = "" 63 | var ( 64 | apiURL = &url.URL{Path: path.String()} 65 | bodyArg interface{} 66 | ) 67 | apiURL.Path = path.String() 68 | 69 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 70 | return err 71 | } 72 | return nil 73 | } 74 | 75 | // Get the details of a reserved address. 76 | // 77 | // https://ngrok.com/docs/api#api-reserved-addrs-get 78 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.ReservedAddr, error) { 79 | arg := &ngrok.Item{ID: id} 80 | 81 | var res ngrok.ReservedAddr 82 | var path bytes.Buffer 83 | if err := template.Must(template.New("get_path").Parse("/reserved_addrs/{{ .ID }}")).Execute(&path, arg); err != nil { 84 | panic(err) 85 | } 86 | arg.ID = "" 87 | var ( 88 | apiURL = &url.URL{Path: path.String()} 89 | bodyArg interface{} 90 | ) 91 | apiURL.Path = path.String() 92 | 93 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 94 | return nil, err 95 | } 96 | return &res, nil 97 | } 98 | 99 | // List all reserved addresses on this account. 100 | // 101 | // https://ngrok.com/docs/api#api-reserved-addrs-list 102 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.ReservedAddr] { 103 | if paging == nil { 104 | paging = new(ngrok.Paging) 105 | } 106 | var path bytes.Buffer 107 | if err := template.Must(template.New("list_path").Parse("/reserved_addrs")).Execute(&path, paging); err != nil { 108 | panic(err) 109 | } 110 | var apiURL = &url.URL{Path: path.String()} 111 | queryVals := make(url.Values) 112 | if paging.BeforeID != nil { 113 | queryVals.Set("before_id", *paging.BeforeID) 114 | } 115 | if paging.Limit != nil { 116 | queryVals.Set("limit", *paging.Limit) 117 | } 118 | apiURL.RawQuery = queryVals.Encode() 119 | return &iterReservedAddr{ 120 | client: c, 121 | n: -1, 122 | nextPage: apiURL, 123 | } 124 | } 125 | 126 | // iter allows the caller to iterate through a list of values while 127 | // automatically fetching new pages worth of values from the API. 128 | type iterReservedAddr struct { 129 | client *Client 130 | n int 131 | items []ngrok.ReservedAddr 132 | err error 133 | 134 | nextPage *url.URL 135 | } 136 | 137 | // Next returns true if there is another value available in the iterator. If it 138 | // returs true it also advances the iterator to that next available item. 139 | func (it *iterReservedAddr) Next(ctx context.Context) bool { 140 | // no more if there is an error 141 | if it.err != nil { 142 | return false 143 | } 144 | 145 | // advance the iterator 146 | it.n += 1 147 | 148 | // is there an available item? 149 | if it.n < len(it.items) { 150 | return true 151 | } 152 | 153 | // no more items, do we have a next page? 154 | if it.nextPage == nil { 155 | return false 156 | } 157 | 158 | // fetch the next page 159 | var resp ngrok.ReservedAddrList 160 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 161 | if err != nil { 162 | it.err = err 163 | return false 164 | } 165 | 166 | // parse the next page URI as soon as we get it and store it 167 | // so we can use it on the next fetch 168 | if resp.NextPageURI != nil { 169 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 170 | if it.err != nil { 171 | return false 172 | } 173 | } else { 174 | it.nextPage = nil 175 | } 176 | 177 | // page with zero items means there are no more 178 | if len(resp.ReservedAddrs) == 0 { 179 | return false 180 | } 181 | 182 | it.n = -1 183 | it.items = resp.ReservedAddrs 184 | return it.Next(ctx) 185 | } 186 | 187 | // Item() returns the ReservedAddr currently 188 | // pointed to by the iterator. 189 | func (it *iterReservedAddr) Item() *ngrok.ReservedAddr { 190 | return &it.items[it.n] 191 | } 192 | 193 | // If Next() returned false because an error was encountered while fetching the 194 | // next value Err() will return that error. A caller should always check Err() 195 | // after Next() returns false. 196 | func (it *iterReservedAddr) Err() error { 197 | return it.err 198 | } 199 | 200 | // Update the attributes of a reserved address. 201 | // 202 | // https://ngrok.com/docs/api#api-reserved-addrs-update 203 | func (c *Client) Update(ctx context.Context, arg *ngrok.ReservedAddrUpdate) (*ngrok.ReservedAddr, error) { 204 | if arg == nil { 205 | arg = new(ngrok.ReservedAddrUpdate) 206 | } 207 | var res ngrok.ReservedAddr 208 | var path bytes.Buffer 209 | if err := template.Must(template.New("update_path").Parse("/reserved_addrs/{{ .ID }}")).Execute(&path, arg); err != nil { 210 | panic(err) 211 | } 212 | arg.ID = "" 213 | var ( 214 | apiURL = &url.URL{Path: path.String()} 215 | bodyArg interface{} 216 | ) 217 | apiURL.Path = path.String() 218 | bodyArg = arg 219 | 220 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 221 | return nil, err 222 | } 223 | return &res, nil 224 | } 225 | -------------------------------------------------------------------------------- /ssh_credentials/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ssh_credentials 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // SSH Credentials are SSH public keys that can be used to start SSH tunnels 16 | // via the ngrok SSH tunnel gateway. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // Create a new ssh_credential from an uploaded public SSH key. This ssh credential 27 | // can be used to start new tunnels via ngrok's SSH gateway. 28 | // 29 | // https://ngrok.com/docs/api#api-ssh-credentials-create 30 | func (c *Client) Create(ctx context.Context, arg *ngrok.SSHCredentialCreate) (*ngrok.SSHCredential, error) { 31 | var res ngrok.SSHCredential 32 | var path bytes.Buffer 33 | if err := template.Must(template.New("create_path").Parse("/ssh_credentials")).Execute(&path, arg); err != nil { 34 | panic(err) 35 | } 36 | var ( 37 | apiURL = &url.URL{Path: path.String()} 38 | bodyArg interface{} 39 | ) 40 | apiURL.Path = path.String() 41 | bodyArg = arg 42 | 43 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 44 | return nil, err 45 | } 46 | return &res, nil 47 | } 48 | 49 | // Delete an ssh_credential by ID 50 | // 51 | // https://ngrok.com/docs/api#api-ssh-credentials-delete 52 | func (c *Client) Delete(ctx context.Context, id string) error { 53 | arg := &ngrok.Item{ID: id} 54 | 55 | var path bytes.Buffer 56 | if err := template.Must(template.New("delete_path").Parse("/ssh_credentials/{{ .ID }}")).Execute(&path, arg); err != nil { 57 | panic(err) 58 | } 59 | arg.ID = "" 60 | var ( 61 | apiURL = &url.URL{Path: path.String()} 62 | bodyArg interface{} 63 | ) 64 | apiURL.Path = path.String() 65 | 66 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 67 | return err 68 | } 69 | return nil 70 | } 71 | 72 | // Get detailed information about an ssh_credential 73 | // 74 | // https://ngrok.com/docs/api#api-ssh-credentials-get 75 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.SSHCredential, error) { 76 | arg := &ngrok.Item{ID: id} 77 | 78 | var res ngrok.SSHCredential 79 | var path bytes.Buffer 80 | if err := template.Must(template.New("get_path").Parse("/ssh_credentials/{{ .ID }}")).Execute(&path, arg); err != nil { 81 | panic(err) 82 | } 83 | arg.ID = "" 84 | var ( 85 | apiURL = &url.URL{Path: path.String()} 86 | bodyArg interface{} 87 | ) 88 | apiURL.Path = path.String() 89 | 90 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 91 | return nil, err 92 | } 93 | return &res, nil 94 | } 95 | 96 | // List all ssh credentials on this account 97 | // 98 | // https://ngrok.com/docs/api#api-ssh-credentials-list 99 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.SSHCredential] { 100 | if paging == nil { 101 | paging = new(ngrok.Paging) 102 | } 103 | var path bytes.Buffer 104 | if err := template.Must(template.New("list_path").Parse("/ssh_credentials")).Execute(&path, paging); err != nil { 105 | panic(err) 106 | } 107 | var apiURL = &url.URL{Path: path.String()} 108 | queryVals := make(url.Values) 109 | if paging.BeforeID != nil { 110 | queryVals.Set("before_id", *paging.BeforeID) 111 | } 112 | if paging.Limit != nil { 113 | queryVals.Set("limit", *paging.Limit) 114 | } 115 | apiURL.RawQuery = queryVals.Encode() 116 | return &iterSSHCredential{ 117 | client: c, 118 | n: -1, 119 | nextPage: apiURL, 120 | } 121 | } 122 | 123 | // iter allows the caller to iterate through a list of values while 124 | // automatically fetching new pages worth of values from the API. 125 | type iterSSHCredential struct { 126 | client *Client 127 | n int 128 | items []ngrok.SSHCredential 129 | err error 130 | 131 | nextPage *url.URL 132 | } 133 | 134 | // Next returns true if there is another value available in the iterator. If it 135 | // returs true it also advances the iterator to that next available item. 136 | func (it *iterSSHCredential) Next(ctx context.Context) bool { 137 | // no more if there is an error 138 | if it.err != nil { 139 | return false 140 | } 141 | 142 | // advance the iterator 143 | it.n += 1 144 | 145 | // is there an available item? 146 | if it.n < len(it.items) { 147 | return true 148 | } 149 | 150 | // no more items, do we have a next page? 151 | if it.nextPage == nil { 152 | return false 153 | } 154 | 155 | // fetch the next page 156 | var resp ngrok.SSHCredentialList 157 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 158 | if err != nil { 159 | it.err = err 160 | return false 161 | } 162 | 163 | // parse the next page URI as soon as we get it and store it 164 | // so we can use it on the next fetch 165 | if resp.NextPageURI != nil { 166 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 167 | if it.err != nil { 168 | return false 169 | } 170 | } else { 171 | it.nextPage = nil 172 | } 173 | 174 | // page with zero items means there are no more 175 | if len(resp.SSHCredentials) == 0 { 176 | return false 177 | } 178 | 179 | it.n = -1 180 | it.items = resp.SSHCredentials 181 | return it.Next(ctx) 182 | } 183 | 184 | // Item() returns the SSHCredential currently 185 | // pointed to by the iterator. 186 | func (it *iterSSHCredential) Item() *ngrok.SSHCredential { 187 | return &it.items[it.n] 188 | } 189 | 190 | // If Next() returned false because an error was encountered while fetching the 191 | // next value Err() will return that error. A caller should always check Err() 192 | // after Next() returns false. 193 | func (it *iterSSHCredential) Err() error { 194 | return it.err 195 | } 196 | 197 | // Update attributes of an ssh_credential by ID 198 | // 199 | // https://ngrok.com/docs/api#api-ssh-credentials-update 200 | func (c *Client) Update(ctx context.Context, arg *ngrok.SSHCredentialUpdate) (*ngrok.SSHCredential, error) { 201 | if arg == nil { 202 | arg = new(ngrok.SSHCredentialUpdate) 203 | } 204 | var res ngrok.SSHCredential 205 | var path bytes.Buffer 206 | if err := template.Must(template.New("update_path").Parse("/ssh_credentials/{{ .ID }}")).Execute(&path, arg); err != nil { 207 | panic(err) 208 | } 209 | arg.ID = "" 210 | var ( 211 | apiURL = &url.URL{Path: path.String()} 212 | bodyArg interface{} 213 | ) 214 | apiURL.Path = path.String() 215 | bodyArg = arg 216 | 217 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 218 | return nil, err 219 | } 220 | return &res, nil 221 | } 222 | -------------------------------------------------------------------------------- /tls_certificates/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tls_certificates 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // TLS Certificates are pairs of x509 certificates and their matching private 16 | // key that can be used to terminate TLS traffic. TLS certificates are unused 17 | // until they are attached to a Domain. TLS Certificates may also be 18 | // provisioned by ngrok automatically for domains on which you have enabled 19 | // automated certificate provisioning. 20 | 21 | type Client struct { 22 | apiClient *api.Client 23 | } 24 | 25 | func NewClient(cfg *ngrok.ClientConfig) *Client { 26 | return &Client{apiClient: api.NewClient(cfg)} 27 | } 28 | 29 | // Upload a new TLS certificate 30 | // 31 | // https://ngrok.com/docs/api#api-tls-certificates-create 32 | func (c *Client) Create(ctx context.Context, arg *ngrok.TLSCertificateCreate) (*ngrok.TLSCertificate, error) { 33 | var res ngrok.TLSCertificate 34 | var path bytes.Buffer 35 | if err := template.Must(template.New("create_path").Parse("/tls_certificates")).Execute(&path, arg); err != nil { 36 | panic(err) 37 | } 38 | var ( 39 | apiURL = &url.URL{Path: path.String()} 40 | bodyArg interface{} 41 | ) 42 | apiURL.Path = path.String() 43 | bodyArg = arg 44 | 45 | if err := c.apiClient.Do(ctx, "POST", apiURL, bodyArg, &res); err != nil { 46 | return nil, err 47 | } 48 | return &res, nil 49 | } 50 | 51 | // Delete a TLS certificate 52 | // 53 | // https://ngrok.com/docs/api#api-tls-certificates-delete 54 | func (c *Client) Delete(ctx context.Context, id string) error { 55 | arg := &ngrok.Item{ID: id} 56 | 57 | var path bytes.Buffer 58 | if err := template.Must(template.New("delete_path").Parse("/tls_certificates/{{ .ID }}")).Execute(&path, arg); err != nil { 59 | panic(err) 60 | } 61 | arg.ID = "" 62 | var ( 63 | apiURL = &url.URL{Path: path.String()} 64 | bodyArg interface{} 65 | ) 66 | apiURL.Path = path.String() 67 | 68 | if err := c.apiClient.Do(ctx, "DELETE", apiURL, bodyArg, nil); err != nil { 69 | return err 70 | } 71 | return nil 72 | } 73 | 74 | // Get detailed information about a TLS certificate 75 | // 76 | // https://ngrok.com/docs/api#api-tls-certificates-get 77 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.TLSCertificate, error) { 78 | arg := &ngrok.Item{ID: id} 79 | 80 | var res ngrok.TLSCertificate 81 | var path bytes.Buffer 82 | if err := template.Must(template.New("get_path").Parse("/tls_certificates/{{ .ID }}")).Execute(&path, arg); err != nil { 83 | panic(err) 84 | } 85 | arg.ID = "" 86 | var ( 87 | apiURL = &url.URL{Path: path.String()} 88 | bodyArg interface{} 89 | ) 90 | apiURL.Path = path.String() 91 | 92 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 93 | return nil, err 94 | } 95 | return &res, nil 96 | } 97 | 98 | // List all TLS certificates on this account 99 | // 100 | // https://ngrok.com/docs/api#api-tls-certificates-list 101 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.TLSCertificate] { 102 | if paging == nil { 103 | paging = new(ngrok.Paging) 104 | } 105 | var path bytes.Buffer 106 | if err := template.Must(template.New("list_path").Parse("/tls_certificates")).Execute(&path, paging); err != nil { 107 | panic(err) 108 | } 109 | var apiURL = &url.URL{Path: path.String()} 110 | queryVals := make(url.Values) 111 | if paging.BeforeID != nil { 112 | queryVals.Set("before_id", *paging.BeforeID) 113 | } 114 | if paging.Limit != nil { 115 | queryVals.Set("limit", *paging.Limit) 116 | } 117 | apiURL.RawQuery = queryVals.Encode() 118 | return &iterTLSCertificate{ 119 | client: c, 120 | n: -1, 121 | nextPage: apiURL, 122 | } 123 | } 124 | 125 | // iter allows the caller to iterate through a list of values while 126 | // automatically fetching new pages worth of values from the API. 127 | type iterTLSCertificate struct { 128 | client *Client 129 | n int 130 | items []ngrok.TLSCertificate 131 | err error 132 | 133 | nextPage *url.URL 134 | } 135 | 136 | // Next returns true if there is another value available in the iterator. If it 137 | // returs true it also advances the iterator to that next available item. 138 | func (it *iterTLSCertificate) Next(ctx context.Context) bool { 139 | // no more if there is an error 140 | if it.err != nil { 141 | return false 142 | } 143 | 144 | // advance the iterator 145 | it.n += 1 146 | 147 | // is there an available item? 148 | if it.n < len(it.items) { 149 | return true 150 | } 151 | 152 | // no more items, do we have a next page? 153 | if it.nextPage == nil { 154 | return false 155 | } 156 | 157 | // fetch the next page 158 | var resp ngrok.TLSCertificateList 159 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 160 | if err != nil { 161 | it.err = err 162 | return false 163 | } 164 | 165 | // parse the next page URI as soon as we get it and store it 166 | // so we can use it on the next fetch 167 | if resp.NextPageURI != nil { 168 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 169 | if it.err != nil { 170 | return false 171 | } 172 | } else { 173 | it.nextPage = nil 174 | } 175 | 176 | // page with zero items means there are no more 177 | if len(resp.TLSCertificates) == 0 { 178 | return false 179 | } 180 | 181 | it.n = -1 182 | it.items = resp.TLSCertificates 183 | return it.Next(ctx) 184 | } 185 | 186 | // Item() returns the TLSCertificate currently 187 | // pointed to by the iterator. 188 | func (it *iterTLSCertificate) Item() *ngrok.TLSCertificate { 189 | return &it.items[it.n] 190 | } 191 | 192 | // If Next() returned false because an error was encountered while fetching the 193 | // next value Err() will return that error. A caller should always check Err() 194 | // after Next() returns false. 195 | func (it *iterTLSCertificate) Err() error { 196 | return it.err 197 | } 198 | 199 | // Update attributes of a TLS Certificate by ID 200 | // 201 | // https://ngrok.com/docs/api#api-tls-certificates-update 202 | func (c *Client) Update(ctx context.Context, arg *ngrok.TLSCertificateUpdate) (*ngrok.TLSCertificate, error) { 203 | if arg == nil { 204 | arg = new(ngrok.TLSCertificateUpdate) 205 | } 206 | var res ngrok.TLSCertificate 207 | var path bytes.Buffer 208 | if err := template.Must(template.New("update_path").Parse("/tls_certificates/{{ .ID }}")).Execute(&path, arg); err != nil { 209 | panic(err) 210 | } 211 | arg.ID = "" 212 | var ( 213 | apiURL = &url.URL{Path: path.String()} 214 | bodyArg interface{} 215 | ) 216 | apiURL.Path = path.String() 217 | bodyArg = arg 218 | 219 | if err := c.apiClient.Do(ctx, "PATCH", apiURL, bodyArg, &res); err != nil { 220 | return nil, err 221 | } 222 | return &res, nil 223 | } 224 | -------------------------------------------------------------------------------- /transports_test.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok_test 4 | 5 | import ( 6 | "bytes" 7 | "fmt" 8 | "io" 9 | "math/rand" 10 | "net/http" 11 | "net/http/httputil" 12 | ) 13 | 14 | type debugTransport struct { 15 | rt http.RoundTripper 16 | out io.Writer 17 | } 18 | 19 | func (t *debugTransport) RoundTrip(req *http.Request) (*http.Response, error) { 20 | // dump request 21 | rtid := rand.Int() 22 | fmt.Fprintf(t.out, "\n************** ROUND TRIP %x ********************\n", rtid) 23 | reqBytes, _ := httputil.DumpRequestOut(req, true) 24 | t.out.Write(reqBytes) 25 | fmt.Fprintln(t.out, "") 26 | 27 | // execute round trip 28 | resp, err := t.rt.RoundTrip(req) 29 | 30 | // dump response 31 | if err != nil { 32 | fmt.Fprintf(t.out, "RoundTrip error: %v\n", err) 33 | } else { 34 | respBytes, _ := httputil.DumpResponse(resp, true) 35 | t.out.Write(respBytes) 36 | fmt.Fprintln(t.out, "") 37 | } 38 | fmt.Fprintf(t.out, "\n************** END ROUND TRIP %x ********************\n", rtid) 39 | 40 | return resp, err 41 | } 42 | 43 | type mockTransport struct { 44 | mockResponse []*http.Response 45 | mockResponseError []error 46 | } 47 | 48 | func (s *mockTransport) SetResponse(statusCode int, body string) { 49 | s.mockResponse = append(s.mockResponse, &http.Response{ 50 | Status: http.StatusText(statusCode), 51 | StatusCode: statusCode, 52 | Proto: "HTTP/1.1", 53 | ProtoMajor: 1, 54 | ProtoMinor: 1, 55 | Header: http.Header{ 56 | "Content-Length": []string{fmt.Sprintf("%d", len(body))}, 57 | "Connection": []string{"close"}, 58 | }, 59 | ContentLength: int64(len(body)), 60 | Body: io.NopCloser(bytes.NewReader([]byte(body))), 61 | }) 62 | s.mockResponseError = append(s.mockResponseError, nil) 63 | } 64 | 65 | func (s *mockTransport) SetResponseError(err error) { 66 | s.mockResponse = append(s.mockResponse, nil) 67 | s.mockResponseError = append(s.mockResponseError, err) 68 | } 69 | 70 | func (t *mockTransport) RoundTrip(req *http.Request) (*http.Response, error) { 71 | resp := t.mockResponse[0] 72 | respErr := t.mockResponseError[0] 73 | t.mockResponse = t.mockResponse[1:] 74 | t.mockResponseError = t.mockResponseError[1:] 75 | return resp, respErr 76 | } 77 | -------------------------------------------------------------------------------- /tunnels/client.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package tunnels 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "net/url" 9 | "text/template" 10 | 11 | "github.com/ngrok/ngrok-api-go/v7" 12 | "github.com/ngrok/ngrok-api-go/v7/internal/api" 13 | ) 14 | 15 | // Tunnels provide endpoints to access services exposed by a running ngrok 16 | // agent tunnel session or an SSH reverse tunnel session. 17 | 18 | type Client struct { 19 | apiClient *api.Client 20 | } 21 | 22 | func NewClient(cfg *ngrok.ClientConfig) *Client { 23 | return &Client{apiClient: api.NewClient(cfg)} 24 | } 25 | 26 | // List all online tunnels currently running on the account. 27 | // 28 | // https://ngrok.com/docs/api#api-tunnels-list 29 | func (c *Client) List(paging *ngrok.Paging) ngrok.Iter[*ngrok.Tunnel] { 30 | if paging == nil { 31 | paging = new(ngrok.Paging) 32 | } 33 | var path bytes.Buffer 34 | if err := template.Must(template.New("list_path").Parse("/tunnels")).Execute(&path, paging); err != nil { 35 | panic(err) 36 | } 37 | var apiURL = &url.URL{Path: path.String()} 38 | queryVals := make(url.Values) 39 | if paging.BeforeID != nil { 40 | queryVals.Set("before_id", *paging.BeforeID) 41 | } 42 | if paging.Limit != nil { 43 | queryVals.Set("limit", *paging.Limit) 44 | } 45 | apiURL.RawQuery = queryVals.Encode() 46 | return &iterTunnel{ 47 | client: c, 48 | n: -1, 49 | nextPage: apiURL, 50 | } 51 | } 52 | 53 | // iter allows the caller to iterate through a list of values while 54 | // automatically fetching new pages worth of values from the API. 55 | type iterTunnel struct { 56 | client *Client 57 | n int 58 | items []ngrok.Tunnel 59 | err error 60 | 61 | nextPage *url.URL 62 | } 63 | 64 | // Next returns true if there is another value available in the iterator. If it 65 | // returs true it also advances the iterator to that next available item. 66 | func (it *iterTunnel) Next(ctx context.Context) bool { 67 | // no more if there is an error 68 | if it.err != nil { 69 | return false 70 | } 71 | 72 | // advance the iterator 73 | it.n += 1 74 | 75 | // is there an available item? 76 | if it.n < len(it.items) { 77 | return true 78 | } 79 | 80 | // no more items, do we have a next page? 81 | if it.nextPage == nil { 82 | return false 83 | } 84 | 85 | // fetch the next page 86 | var resp ngrok.TunnelList 87 | err := it.client.apiClient.Do(ctx, "GET", it.nextPage, nil, &resp) 88 | if err != nil { 89 | it.err = err 90 | return false 91 | } 92 | 93 | // parse the next page URI as soon as we get it and store it 94 | // so we can use it on the next fetch 95 | if resp.NextPageURI != nil { 96 | it.nextPage, it.err = url.Parse(*resp.NextPageURI) 97 | if it.err != nil { 98 | return false 99 | } 100 | } else { 101 | it.nextPage = nil 102 | } 103 | 104 | // page with zero items means there are no more 105 | if len(resp.Tunnels) == 0 { 106 | return false 107 | } 108 | 109 | it.n = -1 110 | it.items = resp.Tunnels 111 | return it.Next(ctx) 112 | } 113 | 114 | // Item() returns the Tunnel currently 115 | // pointed to by the iterator. 116 | func (it *iterTunnel) Item() *ngrok.Tunnel { 117 | return &it.items[it.n] 118 | } 119 | 120 | // If Next() returned false because an error was encountered while fetching the 121 | // next value Err() will return that error. A caller should always check Err() 122 | // after Next() returns false. 123 | func (it *iterTunnel) Err() error { 124 | return it.err 125 | } 126 | 127 | // Get the status of a tunnel by ID 128 | // 129 | // https://ngrok.com/docs/api#api-tunnels-get 130 | func (c *Client) Get(ctx context.Context, id string) (*ngrok.Tunnel, error) { 131 | arg := &ngrok.Item{ID: id} 132 | 133 | var res ngrok.Tunnel 134 | var path bytes.Buffer 135 | if err := template.Must(template.New("get_path").Parse("/tunnels/{{ .ID }}")).Execute(&path, arg); err != nil { 136 | panic(err) 137 | } 138 | arg.ID = "" 139 | var ( 140 | apiURL = &url.URL{Path: path.String()} 141 | bodyArg interface{} 142 | ) 143 | apiURL.Path = path.String() 144 | 145 | if err := c.apiClient.Do(ctx, "GET", apiURL, bodyArg, &res); err != nil { 146 | return nil, err 147 | } 148 | return &res, nil 149 | } 150 | -------------------------------------------------------------------------------- /type_helpers.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | func Bool(v bool) *bool { 6 | return &v 7 | } 8 | 9 | func String(s string) *string { 10 | return &s 11 | } 12 | 13 | func Uint32(v uint32) *uint32 { 14 | return &v 15 | } 16 | -------------------------------------------------------------------------------- /version.go: -------------------------------------------------------------------------------- 1 | // Code generated for API Clients. DO NOT EDIT. 2 | 3 | package ngrok 4 | 5 | import "runtime/debug" 6 | 7 | const modulePath = "github.com/ngrok/ngrok-api-go" 8 | 9 | var _version string 10 | 11 | func init() { 12 | if buildInfo, ok := debug.ReadBuildInfo(); ok { 13 | for _, dep := range buildInfo.Deps { 14 | if dep.Path == modulePath { 15 | _version = dep.Version 16 | } 17 | } 18 | } 19 | _version = "unknown" 20 | } 21 | --------------------------------------------------------------------------------