148 KiB
\ProviderAPI
All URIs are relative to https://api.hanzo.ai
| Method | HTTP request | Description |
|---|---|---|
| DeleteConnectionById | Delete /v1/connection/{id} | Forgets a connector: every custodied secret, then the row. |
| DeleteProviderGithubReposByRepoPages | Delete /v1/provider/github/repos/{repo}/pages | Deletes the repo's Pages site. |
| DeleteProviderSlackMessages | Delete /v1/provider/slack/messages | Takes back one of this app's messages: DELETE /v1/provider/slack/messages. |
| GetConnection | Get /v1/connection | Lists the caller's OWN connectors across every provider — the set `hanzo connector ls` prints. |
| GetConnectionByIdToken | Get /v1/connection/{id}/token | Hands the custodied access token to its owner — the ONE place custody exits. |
| GetConnectionProviders | Get /v1/connection/providers | Lists the USER-plane provider cards. |
| GetProvider | Get /v1/provider | Returns every registered integration provider together with THIS org's connection status for it — the catalog the console's Integrations page renders. |
| GetProviderByProvider | Get /v1/provider/{provider} | Returns ONE provider with this org's connection status — the same view list carries, for a single id. |
| GetProviderByProviderCallback | Get /v1/provider/{provider}/callback | OAuth return for any connector |
| GetProviderByProviderLogo | Get /v1/provider/{provider}/logo | Serves a connector's logo from the catalog. |
| GetProviderDiscordLink | Get /v1/provider/discord/link | Begin linking a Hanzo account from Discord |
| GetProviderDiscordLinkCallback | Get /v1/provider/discord/link/callback | Complete the Discord account link |
| GetProviderDiscordLinkDiscord | Get /v1/provider/discord/link/discord | Discord sign-in return leg |
| GetProviderGithubInstallations | Get /v1/provider/github/installations | Lists the GitHub accounts the caller may see the App installed on, each confirmed against the App's own list, plus where to add another. |
| GetProviderGithubRepos | Get /v1/provider/github/repos | Lists the GitHub repositories the caller may work on, most recently pushed first, searched and paged on the server. |
| GetProviderGithubReposByOwnerByRepoBranches | Get /v1/provider/github/repos/{owner}/{repo}/branches | Lists a repository's branches, the default first, with prefix search. |
| GetProviderGithubReposByRepoPages | Get /v1/provider/github/repos/{repo}/pages | Returns the repo's Pages status, live URL, custom domain and build source. |
| GetProviderGithubUser | Get /v1/provider/github/user | Reports whether the caller has connected their own GitHub account in the org they act in, and as whom. |
| GetProviderGithubUserCallback | Get /v1/provider/github/user/callback | Is where GitHub returns the person. |
| GetProviderGitlabProjects | Get /v1/provider/gitlab/projects | Lists the projects the org's GitLab connection can reach — membership projects, most recently active first. |
| GetProviderGoogleUser | Get /v1/provider/google/user | Reports whether the caller has connected their own Google account in the org they act in, and as whom. |
| GetProviderGoogleUserCallback | Get /v1/provider/google/user/callback | Is where Google returns the person. |
| GetProviderSlackChannels | Get /v1/provider/slack/channels | Lists Slack conversations for the caller's connected workspace. |
| GetProviderSlackFile | Get /v1/provider/slack/file | Read one Slack file's bytes. |
| GetProviderSlackInstall | Get /v1/provider/slack/install | Install the Hanzo app into a Slack workspace |
| GetProviderSlackLink | Get /v1/provider/slack/link | Begin linking a Hanzo account from Slack |
| GetProviderSlackLinkCallback | Get /v1/provider/slack/link/callback | Complete the Slack account link |
| GetProviderSlackLinkSlack | Get /v1/provider/slack/link/slack | Slack sign-in return leg |
| GetProviderSlackMessages | Get /v1/provider/slack/messages | Reads recent messages from a named Slack channel such as #hanzo-gtm. |
| GetProviderTeamsLink | Get /v1/provider/teams/link | Begin linking a Hanzo account from Teams |
| GetProviderTeamsLinkAad | Get /v1/provider/teams/link/aad | Microsoft sign-in return leg |
| GetProviderTeamsLinkCallback | Get /v1/provider/teams/link/callback | Complete the Teams account link |
| GetProviderTelegramLink | Get /v1/provider/telegram/link | Begin linking a Hanzo account from Telegram |
| GetProviderTelegramLinkAuth | Get /v1/provider/telegram/link/auth | Telegram Login Widget return leg |
| GetProviderTelegramLinkCallback | Get /v1/provider/telegram/link/callback | Complete the Telegram account link |
| GetProviderTwitterCallback | Get /v1/provider/twitter/callback | Completes an X consent that arrived on the twitter spelling of the callback. |
| GetProviderWhatsappGroups | Get /v1/provider/whatsapp/groups | Reads the invite link of a group this org's number owns. |
| GetProviderWhatsappWebhook | Get /v1/provider/whatsapp/webhook | WhatsApp Cloud API subscription challenge |
| PostConnectionByIdRefresh | Post /v1/connection/{id}/refresh | Forces a token rotation for a connected connector, ahead of the automatic rotation a token read would do inside the expiry window. |
| PostConnectionByProviderCredential | Post /v1/connection/{provider}/credential | Is the direct intake path: a customer-held token/setup-token (Verify) or an externally obtained OAuth bundle from the CLI's local PKCE (Adopt). |
| PostConnectionByProviderDevice | Post /v1/connection/{provider}/device | Begins a device sign-in and returns the code to show the user plus how to poll for completion. |
| PostConnectionByProviderDeviceByFlowPoll | Post /v1/connection/{provider}/device/{flow}/poll | Advances a device sign-in. |
| PostProviderByProviderChoose | Post /v1/provider/{provider}/choose | Answer the connect's account chooser |
| PostProviderByProviderConnect | Post /v1/provider/{provider}/connect | Acquires the org's credential for one provider. |
| PostProviderByProviderDisconnect | Post /v1/provider/{provider}/disconnect | Revokes (best-effort) and forgets an org's connection: it deletes every custodied KMS secret and the connection row. |
| PostProviderByProviderRun | Post /v1/provider/{provider}/run | Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned. |
| PostProviderByProviderVerify | Post /v1/provider/{provider}/verify | Re-checks a CONNECTED apikey connector's stored credential against the provider, live (`hanzo connector verify`). |
| PostProviderDiscordInteractions | Post /v1/provider/discord/interactions | Discord interactions endpoint |
| PostProviderForgeWebhook | Post /v1/provider/forge/webhook | Forge workflow_job webhook |
| PostProviderGithubFork | Post /v1/provider/github/fork | Forks a granted repository. |
| PostProviderGithubIssuesBackfill | Post /v1/provider/github/issues/backfill | Seeds the native todo with the EXISTING issues across the org's granted repos (default state=open); the webhook keeps them live thereafter. |
| PostProviderGithubReposByRepoPages | Post /v1/provider/github/repos/{repo}/pages | Creates the repo's Pages site and answers 201 Created with it. |
| PostProviderGithubReposByRepoPagesBuilds | Post /v1/provider/github/repos/{repo}/pages/builds | Requests a Pages rebuild and returns the queued build's status. |
| PostProviderGithubReposImport | Post /v1/provider/github/repos/import | Imports the selected (or all) granted repos into git.hanzo.ai. |
| PostProviderGithubSearch | Post /v1/provider/github/search | Finds repositories on GitHub. |
| PostProviderGithubUserComplete | Post /v1/provider/github/user/complete | Finishes connecting the caller's GitHub account: it takes the authorization the callback parked, trades it for the person's token, and seals it. |
| PostProviderGithubUserConnect | Post /v1/provider/github/user/connect | Begins connecting the caller's own GitHub account: it answers the App's authorization page, carrying a state signed for this org and this person. |
| PostProviderGithubUserDisconnect | Post /v1/provider/github/user/disconnect | Forgets the caller's GitHub connection in this org: the token is revoked at GitHub, and the sealed secrets and the row go. |
| PostProviderGithubWebhook | Post /v1/provider/github/webhook | GitHub App webhook |
| PostProviderGoogleUserComplete | Post /v1/provider/google/user/complete | Finishes connecting the caller's Google account: it takes the authorization the callback parked, trades it for the person's tokens, and seals them. |
| PostProviderGoogleUserConnect | Post /v1/provider/google/user/connect | Begins connecting the caller's own Google account: it answers Google's consent page, asking offline access to send mail as them, carrying a state signed for this org and this person. |
| PostProviderGoogleUserDisconnect | Post /v1/provider/google/user/disconnect | Forgets the caller's Google connection in this org: the grant is revoked at Google, and the sealed secrets and the row go. |
| PostProviderLinearClaim | Post /v1/provider/linear/claim | Binds the caller's Linear organization to the org and seals the webhook secret. |
| PostProviderLinearComments | Post /v1/provider/linear/comments | Posts a comment on a Linear issue with the caller's own key, so it carries their name. |
| PostProviderLinearIssuesBackfill | Post /v1/provider/linear/issues/backfill | Seeds the native todo with the EXISTING Linear issues the caller's key can see (default state=open); the webhook keeps them live thereafter. |
| PostProviderLinearWebhook | Post /v1/provider/linear/webhook | Linear webhook |
| PostProviderOpenrouterWebhook | Post /v1/provider/openrouter/webhook | Receive OpenRouter Broadcast traces as usage rows |
| PostProviderSlackCommands | Post /v1/provider/slack/commands | Slack slash command webhook |
| PostProviderSlackEvents | Post /v1/provider/slack/events | Slack Events API webhook |
| PostProviderSlackJoin | Post /v1/provider/slack/join | Joins every public channel in the caller org's workspace. |
| PostProviderSlackMessages | Post /v1/provider/slack/messages | Posts as Hanzo to the caller's connected Slack workspace. |
| PostProviderSlackReactions | Post /v1/provider/slack/reactions | Adds an emoji reaction: POST /v1/provider/slack/reactions. |
| PostProviderSlackSearch | Post /v1/provider/slack/search | Answers a workspace question: POST /v1/provider/slack/search. |
| PostProviderTeamsEvents | Post /v1/provider/teams/events | Microsoft Teams Bot Framework webhook |
| PostProviderTelegramConnect | Post /v1/provider/telegram/connect | Mints a short, single-use deep-link code bound to the caller's org and returns the t.me link the console navigates to. |
| PostProviderTelegramWebhook | Post /v1/provider/telegram/webhook | Telegram Bot API webhook |
| PostProviderWhatsappGroups | Post /v1/provider/whatsapp/groups | Creates a group on the org's WhatsApp number and returns its invite link. |
| PostProviderWhatsappWebhook | Post /v1/provider/whatsapp/webhook | WhatsApp Cloud API webhook |
| PutProviderGithubReposByRepoPages | Put /v1/provider/github/repos/{repo}/pages | Sets or clears the custom domain (cname) and updates HTTPS enforcement, build type, or source. |
| PutProviderSlackMessages | Put /v1/provider/slack/messages | Rewrites one of this app's messages: PUT /v1/provider/slack/messages. |
DeleteConnectionById
ProviderDisconnectOut DeleteConnectionById(ctx, id).Execute()
Forgets a connector: every custodied secret, then the row.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
id := "openai:work" // string | ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.DeleteConnectionById(context.Background(), id).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.DeleteConnectionById``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `DeleteConnectionById`: ProviderDisconnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.DeleteConnectionById`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| id | string | ID is the connector id, provider + ":" + label ("openai:default") — the auth-profile-id shape. Another user's id is simply no row, so 404. |
Other Parameters
Other parameters are passed through a pointer to a apiDeleteConnectionByIdRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
DeleteProviderGithubReposByRepoPages
ProviderGithubPagesDisabledOut DeleteProviderGithubReposByRepoPages(ctx, repo).Execute()
Deletes the repo's Pages site.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
repo := "widgets" // string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.DeleteProviderGithubReposByRepoPages(context.Background(), repo).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.DeleteProviderGithubReposByRepoPages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `DeleteProviderGithubReposByRepoPages`: ProviderGithubPagesDisabledOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.DeleteProviderGithubReposByRepoPages`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| repo | string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing ".git" is stripped. |
Other Parameters
Other parameters are passed through a pointer to a apiDeleteProviderGithubReposByRepoPagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
ProviderGithubPagesDisabledOut
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
DeleteProviderSlackMessages
ProviderSlackDeleteMessageOut DeleteProviderSlackMessages(ctx).Channel(channel).Ts(ts).Execute()
Takes back one of this app's messages: DELETE /v1/provider/slack/messages.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
channel := "channel_example" // string | (optional)
ts := "ts_example" // string | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.DeleteProviderSlackMessages(context.Background()).Channel(channel).Ts(ts).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.DeleteProviderSlackMessages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `DeleteProviderSlackMessages`: ProviderSlackDeleteMessageOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.DeleteProviderSlackMessages`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiDeleteProviderSlackMessagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| channel | string | ||
| ts | string |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetConnection
ProviderConnectionsOut GetConnection(ctx).Execute()
Lists the caller's OWN connectors across every provider — the set hanzo connector ls prints.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetConnection(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetConnection``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetConnection`: ProviderConnectionsOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetConnection`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetConnectionRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetConnectionByIdToken
ProviderTokenOut GetConnectionByIdToken(ctx, id).Execute()
Hands the custodied access token to its owner — the ONE place custody exits.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
id := "openai:work" // string | ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetConnectionByIdToken(context.Background(), id).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetConnectionByIdToken``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetConnectionByIdToken`: ProviderTokenOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetConnectionByIdToken`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| id | string | ID is the connector id, provider + ":" + label ("openai:default") — the auth-profile-id shape. Another user's id is simply no row, so 404. |
Other Parameters
Other parameters are passed through a pointer to a apiGetConnectionByIdTokenRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetConnectionProviders
ProviderUserCatalogOut GetConnectionProviders(ctx).Execute()
Lists the USER-plane provider cards.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetConnectionProviders(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetConnectionProviders``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetConnectionProviders`: ProviderUserCatalogOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetConnectionProviders`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetConnectionProvidersRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProvider
ProviderListOut GetProvider(ctx).Execute()
Returns every registered integration provider together with THIS org's connection status for it — the catalog the console's Integrations page renders.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProvider(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProvider``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProvider`: ProviderListOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProvider`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderByProvider
ProviderProviderView GetProviderByProvider(ctx, provider).Execute()
Returns ONE provider with this org's connection status — the same view list carries, for a single id.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "slack" // string | Provider is the registry id of the connector — \"slack\", \"github\", \"cloudflare\". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderByProvider(context.Background(), provider).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderByProvider``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderByProvider`: ProviderProviderView
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderByProvider`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the registry id of the connector — "slack", "github", "cloudflare". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves. |
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderByProviderRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderByProviderCallback
GetProviderByProviderCallback(ctx, provider).Execute()
OAuth return for any connector
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "provider_example" // string |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderByProviderCallback(context.Background(), provider).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderByProviderCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string |
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderByProviderCallbackRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderByProviderLogo
GetProviderByProviderLogo(ctx, provider).Execute()
Serves a connector's logo from the catalog.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "provider_example" // string |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderByProviderLogo(context.Background(), provider).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderByProviderLogo``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string |
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderByProviderLogoRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderDiscordLink
GetProviderDiscordLink(ctx).Execute()
Begin linking a Hanzo account from Discord
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderDiscordLink(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderDiscordLink``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderDiscordLinkRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderDiscordLinkCallback
GetProviderDiscordLinkCallback(ctx).Execute()
Complete the Discord account link
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderDiscordLinkCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderDiscordLinkCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderDiscordLinkCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderDiscordLinkDiscord
GetProviderDiscordLinkDiscord(ctx).Execute()
Discord sign-in return leg
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderDiscordLinkDiscord(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderDiscordLinkDiscord``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderDiscordLinkDiscordRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubInstallations
ProviderGithubInstallationsOut GetProviderGithubInstallations(ctx).Execute()
Lists the GitHub accounts the caller may see the App installed on, each confirmed against the App's own list, plus where to add another.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGithubInstallations(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubInstallations``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGithubInstallations`: ProviderGithubInstallationsOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGithubInstallations`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubInstallationsRequest struct via the builder pattern
Return type
ProviderGithubInstallationsOut
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubRepos
ProviderGithubReposOut GetProviderGithubRepos(ctx).Q(q).Owner(owner).Limit(limit).After(after).Execute()
Lists the GitHub repositories the caller may work on, most recently pushed first, searched and paged on the server.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
q := "cloud" // string | Q keeps repositories whose owner/name contains it, case-insensitively. (optional)
owner := "owner_example" // string | Owner keeps one GitHub account's repositories — an org or a user login. (optional)
limit := int64(50) // int64 | Limit is the page size: 1 to 100, and 50 when absent or unreadable. (optional)
after := "after_example" // string | After is the `next` of the previous page. Absent starts at the most recently pushed. (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGithubRepos(context.Background()).Q(q).Owner(owner).Limit(limit).After(after).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubRepos``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGithubRepos`: ProviderGithubReposOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGithubRepos`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubReposRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| q | string | Q keeps repositories whose owner/name contains it, case-insensitively. | |
| owner | string | Owner keeps one GitHub account's repositories — an org or a user login. | |
| limit | int64 | Limit is the page size: 1 to 100, and 50 when absent or unreadable. | |
| after | string | After is the `next` of the previous page. Absent starts at the most recently pushed. |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubReposByOwnerByRepoBranches
ProviderGithubBranchesOut GetProviderGithubReposByOwnerByRepoBranches(ctx, owner, repo).Q(q).Limit(limit).After(after).Execute()
Lists a repository's branches, the default first, with prefix search.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
owner := "hanzoai" // string | Owner is the GitHub account that holds the repository.
repo := "cloud" // string | Repo is the repository's name within that account.
q := "feat/" // string | Q keeps branches whose name starts with it, matched by GitHub. (optional)
limit := int64(789) // int64 | Limit is the page size: 1 to 100, and 50 when absent or unreadable. (optional)
after := "after_example" // string | After is the `next` of the previous page. (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGithubReposByOwnerByRepoBranches(context.Background(), owner, repo).Q(q).Limit(limit).After(after).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubReposByOwnerByRepoBranches``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGithubReposByOwnerByRepoBranches`: ProviderGithubBranchesOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGithubReposByOwnerByRepoBranches`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| owner | string | Owner is the GitHub account that holds the repository. | |
| repo | string | Repo is the repository's name within that account. |
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubReposByOwnerByRepoBranchesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
q | string | Q keeps branches whose name starts with it, matched by GitHub. | limit | int64 | Limit is the page size: 1 to 100, and 50 when absent or unreadable. | after | string | After is the `next` of the previous page. |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubReposByRepoPages
ProviderGithubPagesView GetProviderGithubReposByRepoPages(ctx, repo).Execute()
Returns the repo's Pages status, live URL, custom domain and build source.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
repo := "widgets" // string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGithubReposByRepoPages(context.Background(), repo).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubReposByRepoPages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGithubReposByRepoPages`: ProviderGithubPagesView
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGithubReposByRepoPages`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| repo | string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing ".git" is stripped. |
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubReposByRepoPagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubUser
ProviderGithubUserOut GetProviderGithubUser(ctx).Execute()
Reports whether the caller has connected their own GitHub account in the org they act in, and as whom.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGithubUser(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGithubUser`: ProviderGithubUserOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGithubUser`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubUserRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGithubUserCallback
GetProviderGithubUserCallback(ctx).Execute()
Is where GitHub returns the person.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderGithubUserCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGithubUserCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGithubUserCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGitlabProjects
ProviderGitlabProjectsOut GetProviderGitlabProjects(ctx).Execute()
Lists the projects the org's GitLab connection can reach — membership projects, most recently active first.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGitlabProjects(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGitlabProjects``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGitlabProjects`: ProviderGitlabProjectsOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGitlabProjects`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGitlabProjectsRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGoogleUser
ProviderGoogleUserOut GetProviderGoogleUser(ctx).Execute()
Reports whether the caller has connected their own Google account in the org they act in, and as whom.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderGoogleUser(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGoogleUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderGoogleUser`: ProviderGoogleUserOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderGoogleUser`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGoogleUserRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderGoogleUserCallback
GetProviderGoogleUserCallback(ctx).Execute()
Is where Google returns the person.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderGoogleUserCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderGoogleUserCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderGoogleUserCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackChannels
ProviderSlackChannelsOut GetProviderSlackChannels(ctx).Types(types).Cursor(cursor).Execute()
Lists Slack conversations for the caller's connected workspace.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
types := "types_example" // string | Types selects public_channel, private_channel, im or mpim, comma-separated. Defaults to public_channel; each selected type requires its own read scope. (optional)
cursor := "cursor_example" // string | Cursor continues the previous page's next_cursor. (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderSlackChannels(context.Background()).Types(types).Cursor(cursor).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackChannels``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderSlackChannels`: ProviderSlackChannelsOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderSlackChannels`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackChannelsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| types | string | Types selects public_channel, private_channel, im or mpim, comma-separated. Defaults to public_channel; each selected type requires its own read scope. | |
| cursor | string | Cursor continues the previous page's next_cursor. |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackFile
GetProviderSlackFile(ctx).Execute()
Read one Slack file's bytes.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderSlackFile(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackFile``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackFileRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackInstall
GetProviderSlackInstall(ctx).Execute()
Install the Hanzo app into a Slack workspace
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderSlackInstall(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackInstall``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackInstallRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackLink
GetProviderSlackLink(ctx).Execute()
Begin linking a Hanzo account from Slack
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderSlackLink(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackLink``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackLinkRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackLinkCallback
GetProviderSlackLinkCallback(ctx).Execute()
Complete the Slack account link
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderSlackLinkCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackLinkCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackLinkCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackLinkSlack
GetProviderSlackLinkSlack(ctx).Execute()
Slack sign-in return leg
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderSlackLinkSlack(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackLinkSlack``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackLinkSlackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderSlackMessages
ProviderSlackMessagesOut GetProviderSlackMessages(ctx).Channel(channel).Limit(limit).Cursor(cursor).ThreadTs(threadTs).Oldest(oldest).Latest(latest).Execute()
Reads recent messages from a named Slack channel such as #hanzo-gtm.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
channel := "channel_example" // string | Channel is a Slack channel ID, name (#hanzo-gtm), or Slack channel mention. (optional)
limit := int64(789) // int64 | Limit bounds the page to 1-100 messages; zero defaults to 15. (optional)
cursor := "cursor_example" // string | Cursor continues the previous page's next_cursor. (optional)
threadTs := "threadTs_example" // string | ThreadTS reads a thread via conversations.replies. Empty reads recent channel messages via conversations.history, which excludes thread replies. (optional)
oldest := "oldest_example" // string | Oldest filters to messages after this Slack timestamp (exclusive). (optional)
latest := "latest_example" // string | Latest filters to messages before this Slack timestamp (exclusive). (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderSlackMessages(context.Background()).Channel(channel).Limit(limit).Cursor(cursor).ThreadTs(threadTs).Oldest(oldest).Latest(latest).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderSlackMessages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderSlackMessages`: ProviderSlackMessagesOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderSlackMessages`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderSlackMessagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| channel | string | Channel is a Slack channel ID, name (#hanzo-gtm), or Slack channel mention. | |
| limit | int64 | Limit bounds the page to 1-100 messages; zero defaults to 15. | |
| cursor | string | Cursor continues the previous page's next_cursor. | |
| threadTs | string | ThreadTS reads a thread via conversations.replies. Empty reads recent channel messages via conversations.history, which excludes thread replies. | |
| oldest | string | Oldest filters to messages after this Slack timestamp (exclusive). | |
| latest | string | Latest filters to messages before this Slack timestamp (exclusive). |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTeamsLink
GetProviderTeamsLink(ctx).Execute()
Begin linking a Hanzo account from Teams
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTeamsLink(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTeamsLink``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTeamsLinkRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTeamsLinkAad
GetProviderTeamsLinkAad(ctx).Execute()
Microsoft sign-in return leg
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTeamsLinkAad(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTeamsLinkAad``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTeamsLinkAadRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTeamsLinkCallback
GetProviderTeamsLinkCallback(ctx).Execute()
Complete the Teams account link
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTeamsLinkCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTeamsLinkCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTeamsLinkCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTelegramLink
GetProviderTelegramLink(ctx).Execute()
Begin linking a Hanzo account from Telegram
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTelegramLink(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTelegramLink``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTelegramLinkRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTelegramLinkAuth
GetProviderTelegramLinkAuth(ctx).Execute()
Telegram Login Widget return leg
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTelegramLinkAuth(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTelegramLinkAuth``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTelegramLinkAuthRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTelegramLinkCallback
GetProviderTelegramLinkCallback(ctx).Execute()
Complete the Telegram account link
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTelegramLinkCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTelegramLinkCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTelegramLinkCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderTwitterCallback
GetProviderTwitterCallback(ctx).Execute()
Completes an X consent that arrived on the twitter spelling of the callback.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderTwitterCallback(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderTwitterCallback``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderTwitterCallbackRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderWhatsappGroups
ProviderWhatsappGroupOut GetProviderWhatsappGroups(ctx).Group(group).Execute()
Reads the invite link of a group this org's number owns.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
group := "group_example" // string | Group is the group id returned when the group was created. (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.GetProviderWhatsappGroups(context.Background()).Group(group).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderWhatsappGroups``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetProviderWhatsappGroups`: ProviderWhatsappGroupOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.GetProviderWhatsappGroups`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderWhatsappGroupsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| group | string | Group is the group id returned when the group was created. |
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
GetProviderWhatsappWebhook
GetProviderWhatsappWebhook(ctx).Execute()
WhatsApp Cloud API subscription challenge
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.GetProviderWhatsappWebhook(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.GetProviderWhatsappWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiGetProviderWhatsappWebhookRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostConnectionByIdRefresh
ProviderRefreshOut PostConnectionByIdRefresh(ctx, id).Execute()
Forces a token rotation for a connected connector, ahead of the automatic rotation a token read would do inside the expiry window.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
id := "openai:work" // string | ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostConnectionByIdRefresh(context.Background(), id).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostConnectionByIdRefresh``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostConnectionByIdRefresh`: ProviderRefreshOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostConnectionByIdRefresh`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| id | string | ID is the connector id, provider + ":" + label ("openai:default") — the auth-profile-id shape. Another user's id is simply no row, so 404. |
Other Parameters
Other parameters are passed through a pointer to a apiPostConnectionByIdRefreshRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostConnectionByProviderCredential
ProviderCredentialOut PostConnectionByProviderCredential(ctx, provider).ProviderCredentialIn(providerCredentialIn).Execute()
Is the direct intake path: a customer-held token/setup-token (Verify) or an externally obtained OAuth bundle from the CLI's local PKCE (Adopt).
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "openai" // string | Provider is the user-scoped provider's registry id, from the path.
providerCredentialIn := *openapiclient.NewProviderCredentialIn() // ProviderCredentialIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostConnectionByProviderCredential(context.Background(), provider).ProviderCredentialIn(providerCredentialIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostConnectionByProviderCredential``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostConnectionByProviderCredential`: ProviderCredentialOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostConnectionByProviderCredential`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the user-scoped provider's registry id, from the path. |
Other Parameters
Other parameters are passed through a pointer to a apiPostConnectionByProviderCredentialRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerCredentialIn | ProviderCredentialIn | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostConnectionByProviderDevice
ProviderDeviceStartOut PostConnectionByProviderDevice(ctx, provider).ProviderDeviceStartIn(providerDeviceStartIn).Execute()
Begins a device sign-in and returns the code to show the user plus how to poll for completion.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "openai" // string | Provider is the user-scoped provider's registry id, from the path.
providerDeviceStartIn := *openapiclient.NewProviderDeviceStartIn() // ProviderDeviceStartIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostConnectionByProviderDevice(context.Background(), provider).ProviderDeviceStartIn(providerDeviceStartIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostConnectionByProviderDevice``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostConnectionByProviderDevice`: ProviderDeviceStartOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostConnectionByProviderDevice`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the user-scoped provider's registry id, from the path. |
Other Parameters
Other parameters are passed through a pointer to a apiPostConnectionByProviderDeviceRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerDeviceStartIn | ProviderDeviceStartIn | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostConnectionByProviderDeviceByFlowPoll
ProviderDevicePollOut PostConnectionByProviderDeviceByFlowPoll(ctx, provider, flow).Execute()
Advances a device sign-in.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "openai" // string | Provider is the user-scoped provider's registry id, from the path.
flow := "g_7f2c" // string | Flow is the id deviceStartOut returned. Expired or another user's flow is indistinguishable from an unknown one: 404.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostConnectionByProviderDeviceByFlowPoll(context.Background(), provider, flow).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostConnectionByProviderDeviceByFlowPoll``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostConnectionByProviderDeviceByFlowPoll`: ProviderDevicePollOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostConnectionByProviderDeviceByFlowPoll`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the user-scoped provider's registry id, from the path. | |
| flow | string | Flow is the id deviceStartOut returned. Expired or another user's flow is indistinguishable from an unknown one: 404. |
Other Parameters
Other parameters are passed through a pointer to a apiPostConnectionByProviderDeviceByFlowPollRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderByProviderChoose
PostProviderByProviderChoose(ctx, provider).Execute()
Answer the connect's account chooser
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "provider_example" // string |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderByProviderChoose(context.Background(), provider).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderByProviderChoose``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderByProviderChooseRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderByProviderConnect
ProviderConnectOut PostProviderByProviderConnect(ctx, provider).ProviderConnectIn(providerConnectIn).Execute()
Acquires the org's credential for one provider.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "cloudflare" // string | Provider is the connector's registry id, from the :provider path segment.
providerConnectIn := *openapiclient.NewProviderConnectIn() // ProviderConnectIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderByProviderConnect(context.Background(), provider).ProviderConnectIn(providerConnectIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderByProviderConnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderByProviderConnect`: ProviderConnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderByProviderConnect`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the connector's registry id, from the :provider path segment. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderByProviderConnectRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerConnectIn | ProviderConnectIn | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderByProviderDisconnect
ProviderDisconnectOut PostProviderByProviderDisconnect(ctx, provider).ProviderDisconnectIn(providerDisconnectIn).Execute()
Revokes (best-effort) and forgets an org's connection: it deletes every custodied KMS secret and the connection row.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "github" // string | Provider is the connector's registry id, from the :provider path segment.
providerDisconnectIn := *openapiclient.NewProviderDisconnectIn() // ProviderDisconnectIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderByProviderDisconnect(context.Background(), provider).ProviderDisconnectIn(providerDisconnectIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderByProviderDisconnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderByProviderDisconnect`: ProviderDisconnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderByProviderDisconnect`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the connector's registry id, from the :provider path segment. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderByProviderDisconnectRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerDisconnectIn | ProviderDisconnectIn | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderByProviderRun
ProviderRunOut PostProviderByProviderRun(ctx, provider).ProviderRunIn(providerRunIn).Execute()
Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "bitly" // string | Provider is the connector, from the path.
providerRunIn := *openapiclient.NewProviderRunIn() // ProviderRunIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderByProviderRun(context.Background(), provider).ProviderRunIn(providerRunIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderByProviderRun``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderByProviderRun`: ProviderRunOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderByProviderRun`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the connector, from the path. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderByProviderRunRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerRunIn | ProviderRunIn | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderByProviderVerify
ProviderVerifyOut PostProviderByProviderVerify(ctx, provider).Execute()
Re-checks a CONNECTED apikey connector's stored credential against the provider, live (hanzo connector verify).
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
provider := "cloudflare" // string | Provider is the registry id of the connector — \"slack\", \"github\", \"cloudflare\". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderByProviderVerify(context.Background(), provider).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderByProviderVerify``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderByProviderVerify`: ProviderVerifyOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderByProviderVerify`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| provider | string | Provider is the registry id of the connector — "slack", "github", "cloudflare". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderByProviderVerifyRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderDiscordInteractions
PostProviderDiscordInteractions(ctx).Execute()
Discord interactions endpoint
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderDiscordInteractions(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderDiscordInteractions``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderDiscordInteractionsRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderForgeWebhook
ForgeLaunched PostProviderForgeWebhook(ctx).ForgeJob(forgeJob).Execute()
Forge workflow_job webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
forgeJob := *openapiclient.NewForgeJob() // ForgeJob | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderForgeWebhook(context.Background()).ForgeJob(forgeJob).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderForgeWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderForgeWebhook`: ForgeLaunched
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderForgeWebhook`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderForgeWebhookRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| forgeJob | ForgeJob |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubFork
ProviderGithubForkOut PostProviderGithubFork(ctx).ProviderGithubForkReq(providerGithubForkReq).Execute()
Forks a granted repository.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubForkReq := *openapiclient.NewProviderGithubForkReq() // ProviderGithubForkReq |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubFork(context.Background()).ProviderGithubForkReq(providerGithubForkReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubFork``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubFork`: ProviderGithubForkOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubFork`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubForkRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubForkReq | ProviderGithubForkReq |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubIssuesBackfill
ProviderGithubBackfillResult PostProviderGithubIssuesBackfill(ctx).ProviderGithubBackfillIn(providerGithubBackfillIn).Execute()
Seeds the native todo with the EXISTING issues across the org's granted repos (default state=open); the webhook keeps them live thereafter.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubBackfillIn := *openapiclient.NewProviderGithubBackfillIn() // ProviderGithubBackfillIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubIssuesBackfill(context.Background()).ProviderGithubBackfillIn(providerGithubBackfillIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubIssuesBackfill``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubIssuesBackfill`: ProviderGithubBackfillResult
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubIssuesBackfill`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubIssuesBackfillRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubBackfillIn | ProviderGithubBackfillIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubReposByRepoPages
ProviderGithubPagesView PostProviderGithubReposByRepoPages(ctx, repo).ProviderGithubPagesEnableReq(providerGithubPagesEnableReq).Execute()
Creates the repo's Pages site and answers 201 Created with it.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
repo := "widgets" // string | Repo is the repository, from the :repo path segment.
providerGithubPagesEnableReq := *openapiclient.NewProviderGithubPagesEnableReq() // ProviderGithubPagesEnableReq |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubReposByRepoPages(context.Background(), repo).ProviderGithubPagesEnableReq(providerGithubPagesEnableReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubReposByRepoPages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubReposByRepoPages`: ProviderGithubPagesView
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubReposByRepoPages`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| repo | string | Repo is the repository, from the :repo path segment. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubReposByRepoPagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerGithubPagesEnableReq | ProviderGithubPagesEnableReq | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubReposByRepoPagesBuilds
ProviderGithubPagesBuildOut PostProviderGithubReposByRepoPagesBuilds(ctx, repo).Execute()
Requests a Pages rebuild and returns the queued build's status.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
repo := "widgets" // string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubReposByRepoPagesBuilds(context.Background(), repo).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubReposByRepoPagesBuilds``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubReposByRepoPagesBuilds`: ProviderGithubPagesBuildOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubReposByRepoPagesBuilds`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| repo | string | Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing ".git" is stripped. |
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubReposByRepoPagesBuildsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubReposImport
ProviderGithubImportOut PostProviderGithubReposImport(ctx).ProviderGithubImportIn(providerGithubImportIn).Execute()
Imports the selected (or all) granted repos into git.hanzo.ai.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubImportIn := *openapiclient.NewProviderGithubImportIn() // ProviderGithubImportIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubReposImport(context.Background()).ProviderGithubImportIn(providerGithubImportIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubReposImport``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubReposImport`: ProviderGithubImportOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubReposImport`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubReposImportRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubImportIn | ProviderGithubImportIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubSearch
ProviderGithubSearchOut PostProviderGithubSearch(ctx).ProviderGithubSearchReq(providerGithubSearchReq).Execute()
Finds repositories on GitHub.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubSearchReq := *openapiclient.NewProviderGithubSearchReq() // ProviderGithubSearchReq |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubSearch(context.Background()).ProviderGithubSearchReq(providerGithubSearchReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubSearch``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubSearch`: ProviderGithubSearchOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubSearch`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubSearchRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubSearchReq | ProviderGithubSearchReq |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubUserComplete
ProviderGithubUserOut PostProviderGithubUserComplete(ctx).ProviderGithubUserCompleteIn(providerGithubUserCompleteIn).Execute()
Finishes connecting the caller's GitHub account: it takes the authorization the callback parked, trades it for the person's token, and seals it.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubUserCompleteIn := *openapiclient.NewProviderGithubUserCompleteIn() // ProviderGithubUserCompleteIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubUserComplete(context.Background()).ProviderGithubUserCompleteIn(providerGithubUserCompleteIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubUserComplete``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubUserComplete`: ProviderGithubUserOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubUserComplete`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubUserCompleteRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubUserCompleteIn | ProviderGithubUserCompleteIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubUserConnect
ProviderGithubUserConnectOut PostProviderGithubUserConnect(ctx).ProviderGithubUserConnectIn(providerGithubUserConnectIn).Execute()
Begins connecting the caller's own GitHub account: it answers the App's authorization page, carrying a state signed for this org and this person.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGithubUserConnectIn := *openapiclient.NewProviderGithubUserConnectIn() // ProviderGithubUserConnectIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubUserConnect(context.Background()).ProviderGithubUserConnectIn(providerGithubUserConnectIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubUserConnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubUserConnect`: ProviderGithubUserConnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubUserConnect`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubUserConnectRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGithubUserConnectIn | ProviderGithubUserConnectIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubUserDisconnect
ProviderGithubUserDisconnectOut PostProviderGithubUserDisconnect(ctx).Execute()
Forgets the caller's GitHub connection in this org: the token is revoked at GitHub, and the sealed secrets and the row go.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGithubUserDisconnect(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubUserDisconnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGithubUserDisconnect`: ProviderGithubUserDisconnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGithubUserDisconnect`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubUserDisconnectRequest struct via the builder pattern
Return type
ProviderGithubUserDisconnectOut
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGithubWebhook
PostProviderGithubWebhook(ctx).Execute()
GitHub App webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderGithubWebhook(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGithubWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGithubWebhookRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGoogleUserComplete
ProviderGoogleUserOut PostProviderGoogleUserComplete(ctx).ProviderGoogleUserCompleteIn(providerGoogleUserCompleteIn).Execute()
Finishes connecting the caller's Google account: it takes the authorization the callback parked, trades it for the person's tokens, and seals them.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGoogleUserCompleteIn := *openapiclient.NewProviderGoogleUserCompleteIn() // ProviderGoogleUserCompleteIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGoogleUserComplete(context.Background()).ProviderGoogleUserCompleteIn(providerGoogleUserCompleteIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGoogleUserComplete``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGoogleUserComplete`: ProviderGoogleUserOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGoogleUserComplete`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGoogleUserCompleteRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGoogleUserCompleteIn | ProviderGoogleUserCompleteIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGoogleUserConnect
ProviderGoogleUserConnectOut PostProviderGoogleUserConnect(ctx).ProviderGoogleUserConnectIn(providerGoogleUserConnectIn).Execute()
Begins connecting the caller's own Google account: it answers Google's consent page, asking offline access to send mail as them, carrying a state signed for this org and this person.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerGoogleUserConnectIn := *openapiclient.NewProviderGoogleUserConnectIn() // ProviderGoogleUserConnectIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGoogleUserConnect(context.Background()).ProviderGoogleUserConnectIn(providerGoogleUserConnectIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGoogleUserConnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGoogleUserConnect`: ProviderGoogleUserConnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGoogleUserConnect`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGoogleUserConnectRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerGoogleUserConnectIn | ProviderGoogleUserConnectIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderGoogleUserDisconnect
ProviderGoogleUserDisconnectOut PostProviderGoogleUserDisconnect(ctx).Execute()
Forgets the caller's Google connection in this org: the grant is revoked at Google, and the sealed secrets and the row go.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderGoogleUserDisconnect(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderGoogleUserDisconnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderGoogleUserDisconnect`: ProviderGoogleUserDisconnectOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderGoogleUserDisconnect`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderGoogleUserDisconnectRequest struct via the builder pattern
Return type
ProviderGoogleUserDisconnectOut
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderLinearClaim
ProviderLinearClaimOut PostProviderLinearClaim(ctx).ProviderLinearClaimIn(providerLinearClaimIn).Execute()
Binds the caller's Linear organization to the org and seals the webhook secret.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerLinearClaimIn := *openapiclient.NewProviderLinearClaimIn() // ProviderLinearClaimIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderLinearClaim(context.Background()).ProviderLinearClaimIn(providerLinearClaimIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderLinearClaim``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderLinearClaim`: ProviderLinearClaimOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderLinearClaim`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderLinearClaimRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerLinearClaimIn | ProviderLinearClaimIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderLinearComments
ProviderLinearCommentOut PostProviderLinearComments(ctx).ProviderLinearCommentIn(providerLinearCommentIn).Execute()
Posts a comment on a Linear issue with the caller's own key, so it carries their name.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerLinearCommentIn := *openapiclient.NewProviderLinearCommentIn() // ProviderLinearCommentIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderLinearComments(context.Background()).ProviderLinearCommentIn(providerLinearCommentIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderLinearComments``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderLinearComments`: ProviderLinearCommentOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderLinearComments`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderLinearCommentsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerLinearCommentIn | ProviderLinearCommentIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderLinearIssuesBackfill
ProviderLinearBackfillResult PostProviderLinearIssuesBackfill(ctx).ProviderLinearBackfillIn(providerLinearBackfillIn).Execute()
Seeds the native todo with the EXISTING Linear issues the caller's key can see (default state=open); the webhook keeps them live thereafter.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerLinearBackfillIn := *openapiclient.NewProviderLinearBackfillIn() // ProviderLinearBackfillIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderLinearIssuesBackfill(context.Background()).ProviderLinearBackfillIn(providerLinearBackfillIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderLinearIssuesBackfill``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderLinearIssuesBackfill`: ProviderLinearBackfillResult
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderLinearIssuesBackfill`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderLinearIssuesBackfillRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerLinearBackfillIn | ProviderLinearBackfillIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderLinearWebhook
PostProviderLinearWebhook(ctx).Execute()
Linear webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderLinearWebhook(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderLinearWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderLinearWebhookRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderOpenrouterWebhook
map[string]interface{} PostProviderOpenrouterWebhook(ctx).RequestBody(requestBody).Execute()
Receive OpenRouter Broadcast traces as usage rows
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
requestBody := map[string]interface{}{"key": interface{}(123)} // map[string]interface{} | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderOpenrouterWebhook(context.Background()).RequestBody(requestBody).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderOpenrouterWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderOpenrouterWebhook`: map[string]interface{}
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderOpenrouterWebhook`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderOpenrouterWebhookRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| requestBody | map[string]interface{} |
Return type
map[string]interface{}
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackCommands
PostProviderSlackCommands(ctx).Execute()
Slack slash command webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderSlackCommands(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackCommands``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackCommandsRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackEvents
PostProviderSlackEvents(ctx).Execute()
Slack Events API webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderSlackEvents(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackEvents``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackEventsRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackJoin
ProviderSlackJoinOut PostProviderSlackJoin(ctx).Execute()
Joins every public channel in the caller org's workspace.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderSlackJoin(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackJoin``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderSlackJoin`: ProviderSlackJoinOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderSlackJoin`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackJoinRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackMessages
ProviderSlackSendMessageOut PostProviderSlackMessages(ctx).ProviderSlackSendMessageIn(providerSlackSendMessageIn).Execute()
Posts as Hanzo to the caller's connected Slack workspace.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerSlackSendMessageIn := *openapiclient.NewProviderSlackSendMessageIn() // ProviderSlackSendMessageIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderSlackMessages(context.Background()).ProviderSlackSendMessageIn(providerSlackSendMessageIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackMessages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderSlackMessages`: ProviderSlackSendMessageOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderSlackMessages`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackMessagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerSlackSendMessageIn | ProviderSlackSendMessageIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackReactions
ProviderSlackReactOut PostProviderSlackReactions(ctx).ProviderSlackReactIn(providerSlackReactIn).Execute()
Adds an emoji reaction: POST /v1/provider/slack/reactions.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerSlackReactIn := *openapiclient.NewProviderSlackReactIn() // ProviderSlackReactIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderSlackReactions(context.Background()).ProviderSlackReactIn(providerSlackReactIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackReactions``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderSlackReactions`: ProviderSlackReactOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderSlackReactions`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackReactionsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerSlackReactIn | ProviderSlackReactIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderSlackSearch
ProviderSlackSearchOut PostProviderSlackSearch(ctx).ProviderSlackSearchIn(providerSlackSearchIn).Execute()
Answers a workspace question: POST /v1/provider/slack/search.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerSlackSearchIn := *openapiclient.NewProviderSlackSearchIn() // ProviderSlackSearchIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderSlackSearch(context.Background()).ProviderSlackSearchIn(providerSlackSearchIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderSlackSearch``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderSlackSearch`: ProviderSlackSearchOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderSlackSearch`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderSlackSearchRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerSlackSearchIn | ProviderSlackSearchIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderTeamsEvents
PostProviderTeamsEvents(ctx).Execute()
Microsoft Teams Bot Framework webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderTeamsEvents(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderTeamsEvents``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderTeamsEventsRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderTelegramConnect
ProviderAuthorizeOut PostProviderTelegramConnect(ctx).Execute()
Mints a short, single-use deep-link code bound to the caller's org and returns the t.me link the console navigates to.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderTelegramConnect(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderTelegramConnect``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderTelegramConnect`: ProviderAuthorizeOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderTelegramConnect`: %v\n", resp)
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderTelegramConnectRequest struct via the builder pattern
Return type
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderTelegramWebhook
PostProviderTelegramWebhook(ctx).Execute()
Telegram Bot API webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderTelegramWebhook(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderTelegramWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderTelegramWebhookRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderWhatsappGroups
ProviderWhatsappGroupOut PostProviderWhatsappGroups(ctx).ProviderWhatsappGroupIn(providerWhatsappGroupIn).Execute()
Creates a group on the org's WhatsApp number and returns its invite link.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerWhatsappGroupIn := *openapiclient.NewProviderWhatsappGroupIn() // ProviderWhatsappGroupIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PostProviderWhatsappGroups(context.Background()).ProviderWhatsappGroupIn(providerWhatsappGroupIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderWhatsappGroups``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PostProviderWhatsappGroups`: ProviderWhatsappGroupOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PostProviderWhatsappGroups`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderWhatsappGroupsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerWhatsappGroupIn | ProviderWhatsappGroupIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PostProviderWhatsappWebhook
PostProviderWhatsappWebhook(ctx).Execute()
WhatsApp Cloud API webhook
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
r, err := apiClient.ProviderAPI.PostProviderWhatsappWebhook(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PostProviderWhatsappWebhook``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
Path Parameters
This endpoint does not need any parameter.
Other Parameters
Other parameters are passed through a pointer to a apiPostProviderWhatsappWebhookRequest struct via the builder pattern
Return type
(empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PutProviderGithubReposByRepoPages
ProviderGithubPagesUpdatedOut PutProviderGithubReposByRepoPages(ctx, repo).ProviderGithubPagesUpdateReq(providerGithubPagesUpdateReq).Execute()
Sets or clears the custom domain (cname) and updates HTTPS enforcement, build type, or source.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
repo := "widgets" // string | Repo is the repository, from the :repo path segment.
providerGithubPagesUpdateReq := *openapiclient.NewProviderGithubPagesUpdateReq() // ProviderGithubPagesUpdateReq |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PutProviderGithubReposByRepoPages(context.Background(), repo).ProviderGithubPagesUpdateReq(providerGithubPagesUpdateReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PutProviderGithubReposByRepoPages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PutProviderGithubReposByRepoPages`: ProviderGithubPagesUpdatedOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PutProviderGithubReposByRepoPages`: %v\n", resp)
}
Path Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| ctx | context.Context | context for authentication, logging, cancellation, deadlines, tracing, etc. | |
| repo | string | Repo is the repository, from the :repo path segment. |
Other Parameters
Other parameters are passed through a pointer to a apiPutProviderGithubReposByRepoPagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|
providerGithubPagesUpdateReq | ProviderGithubPagesUpdateReq | |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PutProviderSlackMessages
ProviderSlackUpdateMessageOut PutProviderSlackMessages(ctx).ProviderSlackUpdateMessageIn(providerSlackUpdateMessageIn).Execute()
Rewrites one of this app's messages: PUT /v1/provider/slack/messages.
Example
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/hanzoai/go-sdk/v8"
)
func main() {
providerSlackUpdateMessageIn := *openapiclient.NewProviderSlackUpdateMessageIn() // ProviderSlackUpdateMessageIn |
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.ProviderAPI.PutProviderSlackMessages(context.Background()).ProviderSlackUpdateMessageIn(providerSlackUpdateMessageIn).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `ProviderAPI.PutProviderSlackMessages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `PutProviderSlackMessages`: ProviderSlackUpdateMessageOut
fmt.Fprintf(os.Stdout, "Response from `ProviderAPI.PutProviderSlackMessages`: %v\n", resp)
}
Path Parameters
Other Parameters
Other parameters are passed through a pointer to a apiPutProviderSlackMessagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| providerSlackUpdateMessageIn | ProviderSlackUpdateMessageIn |
Return type
Authorization
HTTP request headers
- Content-Type: application/json
- Accept: application/json, application/problem+json
[Back to top] [Back to API list] [Back to Model list] [Back to README]