Files
sdk/api_provider.go

8906 lines
335 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
Hanzo Cloud API
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
API version: v1
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package hanzoai
import (
"bytes"
"context"
"io"
"net/http"
"net/url"
"strings"
)
// ProviderAPIService ProviderAPI service
type ProviderAPIService service
type ProviderAPIDeleteConnectionByIdRequest struct {
ctx context.Context
ApiService *ProviderAPIService
id string
}
func (r ProviderAPIDeleteConnectionByIdRequest) Execute() (*ProviderDisconnectOut, *http.Response, error) {
return r.ApiService.DeleteConnectionByIdExecute(r)
}
/*
DeleteConnectionById Forgets a connector: every custodied secret, then the row.
Forgets a connector: every custodied secret, then the row.
Idempotent — dropping a never-connected id still answers {disconnected:true}
(disconnect() parity). No provider Revoke: none of the user-plane providers
exposes a revoke endpoint.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
@return ProviderAPIDeleteConnectionByIdRequest
*/
func (a *ProviderAPIService) DeleteConnectionById(ctx context.Context, id string) ProviderAPIDeleteConnectionByIdRequest {
return ProviderAPIDeleteConnectionByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ProviderDisconnectOut
func (a *ProviderAPIService) DeleteConnectionByIdExecute(r ProviderAPIDeleteConnectionByIdRequest) (*ProviderDisconnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderDisconnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteConnectionById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIDeleteProviderGithubReposByRepoPagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
repo string
}
func (r ProviderAPIDeleteProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesDisabledOut, *http.Response, error) {
return r.ApiService.DeleteProviderGithubReposByRepoPagesExecute(r)
}
/*
DeleteProviderGithubReposByRepoPages Deletes the repo's Pages site.
Deletes the repo's Pages site. 404 when there is none, so a
caller can tell "turned it off" from "there was nothing on".
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param repo 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.
@return ProviderAPIDeleteProviderGithubReposByRepoPagesRequest
*/
func (a *ProviderAPIService) DeleteProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIDeleteProviderGithubReposByRepoPagesRequest {
return ProviderAPIDeleteProviderGithubReposByRepoPagesRequest{
ApiService: a,
ctx: ctx,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubPagesDisabledOut
func (a *ProviderAPIService) DeleteProviderGithubReposByRepoPagesExecute(r ProviderAPIDeleteProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesDisabledOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubPagesDisabledOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteProviderGithubReposByRepoPages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIDeleteProviderSlackMessagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
channel *string
ts *string
}
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Channel(channel string) ProviderAPIDeleteProviderSlackMessagesRequest {
r.channel = &channel
return r
}
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Ts(ts string) ProviderAPIDeleteProviderSlackMessagesRequest {
r.ts = &ts
return r
}
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Execute() (*ProviderSlackDeleteMessageOut, *http.Response, error) {
return r.ApiService.DeleteProviderSlackMessagesExecute(r)
}
/*
DeleteProviderSlackMessages Takes back one of this app's messages: DELETE /v1/provider/slack/messages.
Takes back one of this app's messages:
DELETE /v1/provider/slack/messages.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIDeleteProviderSlackMessagesRequest
*/
func (a *ProviderAPIService) DeleteProviderSlackMessages(ctx context.Context) ProviderAPIDeleteProviderSlackMessagesRequest {
return ProviderAPIDeleteProviderSlackMessagesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackDeleteMessageOut
func (a *ProviderAPIService) DeleteProviderSlackMessagesExecute(r ProviderAPIDeleteProviderSlackMessagesRequest) (*ProviderSlackDeleteMessageOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackDeleteMessageOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteProviderSlackMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/messages"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.channel != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "channel", r.channel, "form", "")
}
if r.ts != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ts", r.ts, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetConnectionRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetConnectionRequest) Execute() (*ProviderConnectionsOut, *http.Response, error) {
return r.ApiService.GetConnectionExecute(r)
}
/*
GetConnection Lists the caller's OWN connectors across every provider — the set `hanzo connector ls` prints.
Lists the caller's OWN connectors across every provider — the set
`hanzo connector ls` prints. Rows are keyed (org,user), so this can never
surface another user's connector, and no secret is in the view.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetConnectionRequest
*/
func (a *ProviderAPIService) GetConnection(ctx context.Context) ProviderAPIGetConnectionRequest {
return ProviderAPIGetConnectionRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderConnectionsOut
func (a *ProviderAPIService) GetConnectionExecute(r ProviderAPIGetConnectionRequest) (*ProviderConnectionsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderConnectionsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnection")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetConnectionByIdTokenRequest struct {
ctx context.Context
ApiService *ProviderAPIService
id string
}
func (r ProviderAPIGetConnectionByIdTokenRequest) Execute() (*ProviderTokenOut, *http.Response, error) {
return r.ApiService.GetConnectionByIdTokenExecute(r)
}
/*
GetConnectionByIdToken Hands the custodied access token to its owner — the ONE place custody exits.
Hands the custodied access token to its owner — the ONE place
custody exits. The (org,user)-keyed row IS the same-user gate: another user's
id is simply "no row" → 404. fresh() auto-rotates within the refreshSkew
window; static providers degenerate to a plain kmsGet of Secrets[0]. Refresh
tokens are NEVER returned — custody keeps the sink. The token is never logged.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
@return ProviderAPIGetConnectionByIdTokenRequest
*/
func (a *ProviderAPIService) GetConnectionByIdToken(ctx context.Context, id string) ProviderAPIGetConnectionByIdTokenRequest {
return ProviderAPIGetConnectionByIdTokenRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ProviderTokenOut
func (a *ProviderAPIService) GetConnectionByIdTokenExecute(r ProviderAPIGetConnectionByIdTokenRequest) (*ProviderTokenOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderTokenOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnectionByIdToken")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{id}/token"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetConnectionProvidersRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetConnectionProvidersRequest) Execute() (*ProviderUserCatalogOut, *http.Response, error) {
return r.ApiService.GetConnectionProvidersExecute(r)
}
/*
GetConnectionProviders Lists the USER-plane provider cards.
Lists the USER-plane provider cards. It is not the org
catalog at /v1/provider and the two are not a duplicate of one another: a
provider declares its custody plane, and the planes are disjoint, so a
user-scoped provider 404s on the org surface and vice versa. Hence the
catalog of what a
user can connect, and how. Modes derive from capabilities (Device/Adopt/Verify
— Mount asserts at least one), never from a parallel kind enum.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetConnectionProvidersRequest
*/
func (a *ProviderAPIService) GetConnectionProviders(ctx context.Context) ProviderAPIGetConnectionProvidersRequest {
return ProviderAPIGetConnectionProvidersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderUserCatalogOut
func (a *ProviderAPIService) GetConnectionProvidersExecute(r ProviderAPIGetConnectionProvidersRequest) (*ProviderUserCatalogOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderUserCatalogOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnectionProviders")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/providers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderRequest) Execute() (*ProviderListOut, *http.Response, error) {
return r.ApiService.GetProviderExecute(r)
}
/*
GetProvider Returns every registered integration provider together with THIS org's connection status for it — the catalog the console's Integrations page renders.
Returns every registered integration provider together with THIS org's
connection status for it — the catalog the console's Integrations page renders.
Org-authed: a caller with no validated principal is 403, because the status is
per-org and there is no org-less answer. User-plane providers (the /v1/connection
surface) are omitted; the two planes are disjoint.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderRequest
*/
func (a *ProviderAPIService) GetProvider(ctx context.Context) ProviderAPIGetProviderRequest {
return ProviderAPIGetProviderRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderListOut
func (a *ProviderAPIService) GetProviderExecute(r ProviderAPIGetProviderRequest) (*ProviderListOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderListOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderByProviderRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
}
func (r ProviderAPIGetProviderByProviderRequest) Execute() (*ProviderProviderView, *http.Response, error) {
return r.ApiService.GetProviderByProviderExecute(r)
}
/*
GetProviderByProvider Returns ONE provider with this org's connection status — the same view list carries, for a single id.
Returns ONE provider with this org's connection status — the same view list
carries, for a single id. An unknown id is 404, and so is a user-plane provider:
the org surface never resolves one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider 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.
@return ProviderAPIGetProviderByProviderRequest
*/
func (a *ProviderAPIService) GetProviderByProvider(ctx context.Context, provider string) ProviderAPIGetProviderByProviderRequest {
return ProviderAPIGetProviderByProviderRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderProviderView
func (a *ProviderAPIService) GetProviderByProviderExecute(r ProviderAPIGetProviderByProviderRequest) (*ProviderProviderView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderProviderView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderByProviderCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
}
func (r ProviderAPIGetProviderByProviderCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderByProviderCallbackExecute(r)
}
/*
GetProviderByProviderCallback OAuth return for any connector
The single address every connector's OAuth flow returns to. It exchanges the authorization the provider granted, records the connection, and ALWAYS redirects the browser back to the console — on success and on every labeled failure alike, so a user never lands on a raw JSON dead end.
It is public and carries no principal, so the org is taken ONLY from the signed state minted when the flow began; no header is trusted here. That state is single-use and is burned BEFORE the exchange, so one authorization is one attempt and a replayed return fails instead of exchanging twice.
Tokens are sealed into the org's KMS namespace BEFORE the connection row is written, so a failure of the secret store leaves no half-connected integration advertising a credential that was never stored. Token values never appear in the redirect, in a log line or in an error.
One generalization is worth knowing: a GitHub App installation returns an installation identifier instead of an OAuth code, and it is accepted in the code's place so the App model needs no second address.
A GitHub connect that returns from GitHub's authorization page, rather than its install page, answers a short page instead of a redirect when the person already controls installations no organization holds: they choose which one to connect, or go on to install the app on another account. Nothing is bound until they choose.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider
@return ProviderAPIGetProviderByProviderCallbackRequest
*/
func (a *ProviderAPIService) GetProviderByProviderCallback(ctx context.Context, provider string) ProviderAPIGetProviderByProviderCallbackRequest {
return ProviderAPIGetProviderByProviderCallbackRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderByProviderCallbackExecute(r ProviderAPIGetProviderByProviderCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProviderCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/callback"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderByProviderLogoRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
}
func (r ProviderAPIGetProviderByProviderLogoRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderByProviderLogoExecute(r)
}
/*
GetProviderByProviderLogo Serves a connector's logo from the catalog.
Serves a connector's logo from the catalog. PUBLIC: an <img> carries no
bearer, and a logo is not the org's. It is served from the embedded catalog
only, never fetched, with a policy that runs nothing — an SVG opened directly
is a picture, not a page.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider
@return ProviderAPIGetProviderByProviderLogoRequest
*/
func (a *ProviderAPIService) GetProviderByProviderLogo(ctx context.Context, provider string) ProviderAPIGetProviderByProviderLogoRequest {
return ProviderAPIGetProviderByProviderLogoRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderByProviderLogoExecute(r ProviderAPIGetProviderByProviderLogoRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProviderLogo")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/logo"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderDiscordLinkRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderDiscordLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderDiscordLinkExecute(r)
}
/*
GetProviderDiscordLink Begin linking a Hanzo account from Discord
The entry point behind the connect prompt Hanzo shows in a Discord server. It starts a link session and redirects to Discord's OAuth `identify` consent — the narrowest scope that establishes which Discord user is asking, and nothing more.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderDiscordLinkRequest
*/
func (a *ProviderAPIService) GetProviderDiscordLink(ctx context.Context) ProviderAPIGetProviderDiscordLinkRequest {
return ProviderAPIGetProviderDiscordLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderDiscordLinkExecute(r ProviderAPIGetProviderDiscordLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/discord/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderDiscordLinkCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderDiscordLinkCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderDiscordLinkCallbackExecute(r)
}
/*
GetProviderDiscordLinkCallback Complete the Discord account link
The final leg: it binds the verified Discord user to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Discord. The Hanzo credential is sealed into the connected org's KMS namespace rather than stored beside the link.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderDiscordLinkCallbackRequest
*/
func (a *ProviderAPIService) GetProviderDiscordLinkCallback(ctx context.Context) ProviderAPIGetProviderDiscordLinkCallbackRequest {
return ProviderAPIGetProviderDiscordLinkCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderDiscordLinkCallbackExecute(r ProviderAPIGetProviderDiscordLinkCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLinkCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/discord/link/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderDiscordLinkDiscordRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderDiscordLinkDiscordRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderDiscordLinkDiscordExecute(r)
}
/*
GetProviderDiscordLinkDiscord Discord sign-in return leg
Where Discord returns the user after the identify consent. It resolves the verified Discord user, confirms the server is connected to an org, and hands the browser to the Hanzo sign-in that completes the link.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderDiscordLinkDiscordRequest
*/
func (a *ProviderAPIService) GetProviderDiscordLinkDiscord(ctx context.Context) ProviderAPIGetProviderDiscordLinkDiscordRequest {
return ProviderAPIGetProviderDiscordLinkDiscordRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderDiscordLinkDiscordExecute(r ProviderAPIGetProviderDiscordLinkDiscordRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLinkDiscord")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/discord/link/discord"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubInstallationsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGithubInstallationsRequest) Execute() (*ProviderGithubInstallationsOut, *http.Response, error) {
return r.ApiService.GetProviderGithubInstallationsExecute(r)
}
/*
GetProviderGithubInstallations 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.
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.
The confirmation is the point. A connection row holds an installation id, and
an id whose installation was since removed on GitHub is a row that mints
nothing — every list and import against it fails with a token error, which
reads as "our git integration is broken" rather than "that install is gone".
Checking the App's view turns that into a fact the caller can act on.
ORG-SCOPED for a tenant, deliberately. The App is installed across every
customer, so the raw list is the customer list; a tenant sees only accounts its
own org has bound. It discovers a NEW account by installing it (InstallURL),
which is GitHub's own consent screen — not by reading ours.
A SUPER ADMIN sees the App's whole install list, because that list is the
platform's own inventory rather than any one tenant's data, and platform sudo
is the single cross-tenant scope this house has. Without it an App installed
out-of-band — granted straight from GitHub, so no connect flow ever ran and no
connection row exists — is invisible to everyone: the console card reads "not
connected" and an operator asked "which GitHub orgs do you see" can only
answer for accounts already bound, which is precisely the accounts that were
never the question.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGithubInstallationsRequest
*/
func (a *ProviderAPIService) GetProviderGithubInstallations(ctx context.Context) ProviderAPIGetProviderGithubInstallationsRequest {
return ProviderAPIGetProviderGithubInstallationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubInstallationsOut
func (a *ProviderAPIService) GetProviderGithubInstallationsExecute(r ProviderAPIGetProviderGithubInstallationsRequest) (*ProviderGithubInstallationsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubInstallationsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubInstallations")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/installations"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubReposRequest struct {
ctx context.Context
ApiService *ProviderAPIService
q *string
owner *string
limit *int64
after *string
}
// Q keeps repositories whose owner/name contains it, case-insensitively.
func (r ProviderAPIGetProviderGithubReposRequest) Q(q string) ProviderAPIGetProviderGithubReposRequest {
r.q = &q
return r
}
// Owner keeps one GitHub account&#39;s repositories — an org or a user login.
func (r ProviderAPIGetProviderGithubReposRequest) Owner(owner string) ProviderAPIGetProviderGithubReposRequest {
r.owner = &owner
return r
}
// Limit is the page size: 1 to 100, and 50 when absent or unreadable.
func (r ProviderAPIGetProviderGithubReposRequest) Limit(limit int64) ProviderAPIGetProviderGithubReposRequest {
r.limit = &limit
return r
}
// After is the &#x60;next&#x60; of the previous page. Absent starts at the most recently pushed.
func (r ProviderAPIGetProviderGithubReposRequest) After(after string) ProviderAPIGetProviderGithubReposRequest {
r.after = &after
return r
}
func (r ProviderAPIGetProviderGithubReposRequest) Execute() (*ProviderGithubReposOut, *http.Response, error) {
return r.ApiService.GetProviderGithubReposExecute(r)
}
/*
GetProviderGithubRepos Lists the GitHub repositories the caller may work on, most recently pushed first, searched and paged on the server.
Lists the GitHub repositories the caller may work on, most
recently pushed first, searched and paged on the server.
A person who connected their own GitHub sees what their token reaches in this
App's installations. An org admin who has not sees every repository in the
installations their org holds. Anyone else gets an empty page with
connected:false, which is the console's cue to ask them to connect.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGithubReposRequest
*/
func (a *ProviderAPIService) GetProviderGithubRepos(ctx context.Context) ProviderAPIGetProviderGithubReposRequest {
return ProviderAPIGetProviderGithubReposRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubReposOut
func (a *ProviderAPIService) GetProviderGithubReposExecute(r ProviderAPIGetProviderGithubReposRequest) (*ProviderGithubReposOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubReposOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubRepos")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.q != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.after != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "after", r.after, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
owner string
repo string
q *string
limit *int64
after *string
}
// Q keeps branches whose name starts with it, matched by GitHub.
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Q(q string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
r.q = &q
return r
}
// Limit is the page size: 1 to 100, and 50 when absent or unreadable.
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Limit(limit int64) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
r.limit = &limit
return r
}
// After is the &#x60;next&#x60; of the previous page.
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) After(after string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
r.after = &after
return r
}
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Execute() (*ProviderGithubBranchesOut, *http.Response, error) {
return r.ApiService.GetProviderGithubReposByOwnerByRepoBranchesExecute(r)
}
/*
GetProviderGithubReposByOwnerByRepoBranches Lists a repository's branches, the default first, with prefix search.
Lists a repository's branches, the default first, with prefix
search. The repository must be one the caller may see — the same set
GET /v1/provider/github/repos lists — or it is 404.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner Owner is the GitHub account that holds the repository.
@param repo Repo is the repository's name within that account.
@return ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest
*/
func (a *ProviderAPIService) GetProviderGithubReposByOwnerByRepoBranches(ctx context.Context, owner string, repo string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
return ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest{
ApiService: a,
ctx: ctx,
owner: owner,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubBranchesOut
func (a *ProviderAPIService) GetProviderGithubReposByOwnerByRepoBranchesExecute(r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) (*ProviderGithubBranchesOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubBranchesOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubReposByOwnerByRepoBranches")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{owner}/{repo}/branches"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.q != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.after != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "after", r.after, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubReposByRepoPagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
repo string
}
func (r ProviderAPIGetProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesView, *http.Response, error) {
return r.ApiService.GetProviderGithubReposByRepoPagesExecute(r)
}
/*
GetProviderGithubReposByRepoPages Returns the repo's Pages status, live URL, custom domain and build source.
Returns the repo's Pages status, live URL, custom domain and build
source. The repo is resolved against the org installation's GRANTED set, so a
caller can never address a repo the App was not granted; 404 when the repo has no
Pages site.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param repo 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.
@return ProviderAPIGetProviderGithubReposByRepoPagesRequest
*/
func (a *ProviderAPIService) GetProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIGetProviderGithubReposByRepoPagesRequest {
return ProviderAPIGetProviderGithubReposByRepoPagesRequest{
ApiService: a,
ctx: ctx,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubPagesView
func (a *ProviderAPIService) GetProviderGithubReposByRepoPagesExecute(r ProviderAPIGetProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubPagesView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubReposByRepoPages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubUserRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGithubUserRequest) Execute() (*ProviderGithubUserOut, *http.Response, error) {
return r.ApiService.GetProviderGithubUserExecute(r)
}
/*
GetProviderGithubUser Reports whether the caller has connected their own GitHub account in the org they act in, and as whom.
Reports whether the caller has connected their own GitHub
account in the org they act in, and as whom.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGithubUserRequest
*/
func (a *ProviderAPIService) GetProviderGithubUser(ctx context.Context) ProviderAPIGetProviderGithubUserRequest {
return ProviderAPIGetProviderGithubUserRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubUserOut
func (a *ProviderAPIService) GetProviderGithubUserExecute(r ProviderAPIGetProviderGithubUserRequest) (*ProviderGithubUserOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubUserOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubUser")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/user"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGithubUserCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGithubUserCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderGithubUserCallbackExecute(r)
}
/*
GetProviderGithubUserCallback Is where GitHub returns the person.
Is where GitHub returns the person. It verifies the state,
burns its nonce, and parks the code for the return page to complete; it
exchanges nothing. PUBLIC and state-authed, like every OAuth return, and raw because it
answers a browser with a redirect.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGithubUserCallbackRequest
*/
func (a *ProviderAPIService) GetProviderGithubUserCallback(ctx context.Context) ProviderAPIGetProviderGithubUserCallbackRequest {
return ProviderAPIGetProviderGithubUserCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderGithubUserCallbackExecute(r ProviderAPIGetProviderGithubUserCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubUserCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/user/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGitlabProjectsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGitlabProjectsRequest) Execute() (*ProviderGitlabProjectsOut, *http.Response, error) {
return r.ApiService.GetProviderGitlabProjectsExecute(r)
}
/*
GetProviderGitlabProjects Lists the projects the org's GitLab connection can reach — membership projects, most recently active first.
Lists the projects the org's GitLab connection can reach —
membership projects, most recently active first.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGitlabProjectsRequest
*/
func (a *ProviderAPIService) GetProviderGitlabProjects(ctx context.Context) ProviderAPIGetProviderGitlabProjectsRequest {
return ProviderAPIGetProviderGitlabProjectsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGitlabProjectsOut
func (a *ProviderAPIService) GetProviderGitlabProjectsExecute(r ProviderAPIGetProviderGitlabProjectsRequest) (*ProviderGitlabProjectsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGitlabProjectsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGitlabProjects")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/gitlab/projects"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGoogleUserRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGoogleUserRequest) Execute() (*ProviderGoogleUserOut, *http.Response, error) {
return r.ApiService.GetProviderGoogleUserExecute(r)
}
/*
GetProviderGoogleUser Reports whether the caller has connected their own Google account in the org they act in, and as whom.
Reports whether the caller has connected their own Google
account in the org they act in, and as whom.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGoogleUserRequest
*/
func (a *ProviderAPIService) GetProviderGoogleUser(ctx context.Context) ProviderAPIGetProviderGoogleUserRequest {
return ProviderAPIGetProviderGoogleUserRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGoogleUserOut
func (a *ProviderAPIService) GetProviderGoogleUserExecute(r ProviderAPIGetProviderGoogleUserRequest) (*ProviderGoogleUserOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGoogleUserOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGoogleUser")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/google/user"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderGoogleUserCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderGoogleUserCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderGoogleUserCallbackExecute(r)
}
/*
GetProviderGoogleUserCallback Is where Google returns the person.
Is where Google returns the person. It verifies the state,
burns its nonce, and parks the code for the return page to complete; it
exchanges nothing. PUBLIC and state-authed, like every OAuth return, and raw
because it answers a browser with a redirect.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderGoogleUserCallbackRequest
*/
func (a *ProviderAPIService) GetProviderGoogleUserCallback(ctx context.Context) ProviderAPIGetProviderGoogleUserCallbackRequest {
return ProviderAPIGetProviderGoogleUserCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderGoogleUserCallbackExecute(r ProviderAPIGetProviderGoogleUserCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGoogleUserCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/google/user/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackChannelsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
types *string
cursor *string
}
// Types selects public_channel, private_channel, im or mpim, comma-separated. Defaults to public_channel; each selected type requires its own read scope.
func (r ProviderAPIGetProviderSlackChannelsRequest) Types(types string) ProviderAPIGetProviderSlackChannelsRequest {
r.types = &types
return r
}
// Cursor continues the previous page&#39;s next_cursor.
func (r ProviderAPIGetProviderSlackChannelsRequest) Cursor(cursor string) ProviderAPIGetProviderSlackChannelsRequest {
r.cursor = &cursor
return r
}
func (r ProviderAPIGetProviderSlackChannelsRequest) Execute() (*ProviderSlackChannelsOut, *http.Response, error) {
return r.ApiService.GetProviderSlackChannelsExecute(r)
}
/*
GetProviderSlackChannels Lists Slack conversations for the caller's connected workspace.
Lists Slack conversations for the caller's connected workspace.
Read next_cursor until empty to discover channels, including private channels
or group DMs when types requests them and the bot has their read scopes.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackChannelsRequest
*/
func (a *ProviderAPIService) GetProviderSlackChannels(ctx context.Context) ProviderAPIGetProviderSlackChannelsRequest {
return ProviderAPIGetProviderSlackChannelsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackChannelsOut
func (a *ProviderAPIService) GetProviderSlackChannelsExecute(r ProviderAPIGetProviderSlackChannelsRequest) (*ProviderSlackChannelsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackChannelsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackChannels")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/channels"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.types != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "types", r.types, "form", "")
}
if r.cursor != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackFileRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderSlackFileRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderSlackFileExecute(r)
}
/*
GetProviderSlackFile Read one Slack file's bytes.
Streams the bytes of a file attached to a message in the workspace this organization connected. `id` is the Slack file id a message's `files` carries; the response is the file itself, under the Content-Type Slack recorded for it, never JSON.
THE WORKSPACE IS THE CALLER'S. The org comes from the validated identity and never from the request, and it selects the token the read spends, so a caller cannot name a workspace they have not connected. A file that workspace cannot see answers 404 from Slack's own answer rather than from a guess made here, and a file past the size bound is refused by name instead of arriving truncated.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackFileRequest
*/
func (a *ProviderAPIService) GetProviderSlackFile(ctx context.Context) ProviderAPIGetProviderSlackFileRequest {
return ProviderAPIGetProviderSlackFileRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderSlackFileExecute(r ProviderAPIGetProviderSlackFileRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackFile")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/file"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackInstallRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderSlackInstallRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderSlackInstallExecute(r)
}
/*
GetProviderSlackInstall Install the Hanzo app into a Slack workspace
The address behind Slack's "Add to Slack" and Marketplace Install buttons. It answers a 302 to Slack's own consent screen and does nothing else — it is a redirector by design.
It exists because Slack refuses a slack.com URL in that field and requires one of ours that redirects there, which makes the field an ATTRIBUTION hook: routing the click through our own address is what lets an install be counted, and always answering the redirect is what keeps the counter from becoming a detour that never reaches consent. The destination is the same consent URL every time, built from the same scopes the console's Connect button asks for, so a workspace is asked to grant one thing however the install began.
It is PUBLIC and carries no principal, because whoever clicks Install in Slack's directory has no Hanzo session yet. It binds no org either, and that is deliberate rather than missing: the org is resolved at the shared provider callback, from the signed state a console connect minted or from the workspace's existing connection. Minting an org for an anonymous click is the one thing that would break tenant isolation, so an install begun here finishes under exactly the rules every other install obeys.
Where the app is not configured it answers 503, rather than a consent URL carrying an empty client_id that Slack would render as its own dead-end error page.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackInstallRequest
*/
func (a *ProviderAPIService) GetProviderSlackInstall(ctx context.Context) ProviderAPIGetProviderSlackInstallRequest {
return ProviderAPIGetProviderSlackInstallRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderSlackInstallExecute(r ProviderAPIGetProviderSlackInstallRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackInstall")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/install"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackLinkRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderSlackLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderSlackLinkExecute(r)
}
/*
GetProviderSlackLink Begin linking a Hanzo account from Slack
The entry point behind the connect prompt Hanzo posts in Slack. It starts a link session in the browser and redirects to Slack's own sign-in, which is what proves which Slack user is asking.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackLinkRequest
*/
func (a *ProviderAPIService) GetProviderSlackLink(ctx context.Context) ProviderAPIGetProviderSlackLinkRequest {
return ProviderAPIGetProviderSlackLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderSlackLinkExecute(r ProviderAPIGetProviderSlackLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackLinkCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderSlackLinkCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderSlackLinkCallbackExecute(r)
}
/*
GetProviderSlackLinkCallback Complete the Slack account link
The final leg: the user has proved both who they are in Slack and who they are in Hanzo, and this binds the two. It answers a short confirmation page telling them to return to Slack.
The Hanzo credential obtained here is sealed into the connected workspace's own KMS namespace; it is never written to a database column and never logged. A deployment whose secret store is unavailable refuses the link rather than completing it without custody of the credential.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackLinkCallbackRequest
*/
func (a *ProviderAPIService) GetProviderSlackLinkCallback(ctx context.Context) ProviderAPIGetProviderSlackLinkCallbackRequest {
return ProviderAPIGetProviderSlackLinkCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderSlackLinkCallbackExecute(r ProviderAPIGetProviderSlackLinkCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLinkCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/link/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackLinkSlackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderSlackLinkSlackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderSlackLinkSlackExecute(r)
}
/*
GetProviderSlackLinkSlack Slack sign-in return leg
Where Slack returns the user after they sign in. It establishes the verified Slack workspace and user, confirms that workspace is connected to an org, and hands the browser on to the Hanzo sign-in that completes the link.
The verified pair is carried onward in a host-bound cookie rather than in the URL, so the identity being linked cannot be edited in transit.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackLinkSlackRequest
*/
func (a *ProviderAPIService) GetProviderSlackLinkSlack(ctx context.Context) ProviderAPIGetProviderSlackLinkSlackRequest {
return ProviderAPIGetProviderSlackLinkSlackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderSlackLinkSlackExecute(r ProviderAPIGetProviderSlackLinkSlackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLinkSlack")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/link/slack"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderSlackMessagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
channel *string
limit *int64
cursor *string
threadTs *string
oldest *string
latest *string
}
// Channel is a Slack channel ID, name (#hanzo-gtm), or Slack channel mention.
func (r ProviderAPIGetProviderSlackMessagesRequest) Channel(channel string) ProviderAPIGetProviderSlackMessagesRequest {
r.channel = &channel
return r
}
// Limit bounds the page to 1-100 messages; zero defaults to 15.
func (r ProviderAPIGetProviderSlackMessagesRequest) Limit(limit int64) ProviderAPIGetProviderSlackMessagesRequest {
r.limit = &limit
return r
}
// Cursor continues the previous page&#39;s next_cursor.
func (r ProviderAPIGetProviderSlackMessagesRequest) Cursor(cursor string) ProviderAPIGetProviderSlackMessagesRequest {
r.cursor = &cursor
return r
}
// ThreadTS reads a thread via conversations.replies. Empty reads recent channel messages via conversations.history, which excludes thread replies.
func (r ProviderAPIGetProviderSlackMessagesRequest) ThreadTs(threadTs string) ProviderAPIGetProviderSlackMessagesRequest {
r.threadTs = &threadTs
return r
}
// Oldest filters to messages after this Slack timestamp (exclusive).
func (r ProviderAPIGetProviderSlackMessagesRequest) Oldest(oldest string) ProviderAPIGetProviderSlackMessagesRequest {
r.oldest = &oldest
return r
}
// Latest filters to messages before this Slack timestamp (exclusive).
func (r ProviderAPIGetProviderSlackMessagesRequest) Latest(latest string) ProviderAPIGetProviderSlackMessagesRequest {
r.latest = &latest
return r
}
func (r ProviderAPIGetProviderSlackMessagesRequest) Execute() (*ProviderSlackMessagesOut, *http.Response, error) {
return r.ApiService.GetProviderSlackMessagesExecute(r)
}
/*
GetProviderSlackMessages Reads recent messages from a named Slack channel such as #hanzo-gtm.
Reads recent messages from a named Slack channel such as
#hanzo-gtm. The bot must be a member and have the relevant history scope.
Set thread_ts to fetch a parent's replies, and cursor to continue a page.
Channel history is newest first; thread replies are oldest first.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderSlackMessagesRequest
*/
func (a *ProviderAPIService) GetProviderSlackMessages(ctx context.Context) ProviderAPIGetProviderSlackMessagesRequest {
return ProviderAPIGetProviderSlackMessagesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackMessagesOut
func (a *ProviderAPIService) GetProviderSlackMessagesExecute(r ProviderAPIGetProviderSlackMessagesRequest) (*ProviderSlackMessagesOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackMessagesOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/messages"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.channel != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "channel", r.channel, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.cursor != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "form", "")
}
if r.threadTs != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "thread_ts", r.threadTs, "form", "")
}
if r.oldest != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "oldest", r.oldest, "form", "")
}
if r.latest != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "latest", r.latest, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTeamsLinkRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTeamsLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTeamsLinkExecute(r)
}
/*
GetProviderTeamsLink Begin linking a Hanzo account from Teams
The entry point behind the connect prompt Hanzo shows in Teams. It starts a link session and redirects to Microsoft sign-in addressed to the CHAT'S OWN tenant, not the common endpoint, so only a member of that tenant can complete it.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTeamsLinkRequest
*/
func (a *ProviderAPIService) GetProviderTeamsLink(ctx context.Context) ProviderAPIGetProviderTeamsLinkRequest {
return ProviderAPIGetProviderTeamsLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTeamsLinkExecute(r ProviderAPIGetProviderTeamsLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/teams/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTeamsLinkAadRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTeamsLinkAadRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTeamsLinkAadExecute(r)
}
/*
GetProviderTeamsLinkAad Microsoft sign-in return leg
Where Microsoft returns the user after sign-in. It resolves the verified directory identity and then re-checks the tenant: the signed-in user's tenant must equal the tenant of the chat the link started from, so a valid Microsoft sign-in from a different organization is refused here rather than accepted.
This is the leg Teams has and the other platforms do not, which is why the Teams flow has an extra address.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTeamsLinkAadRequest
*/
func (a *ProviderAPIService) GetProviderTeamsLinkAad(ctx context.Context) ProviderAPIGetProviderTeamsLinkAadRequest {
return ProviderAPIGetProviderTeamsLinkAadRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTeamsLinkAadExecute(r ProviderAPIGetProviderTeamsLinkAadRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLinkAad")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/teams/link/aad"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTeamsLinkCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTeamsLinkCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTeamsLinkCallbackExecute(r)
}
/*
GetProviderTeamsLinkCallback Complete the Teams account link
The final leg: it binds the verified directory identity to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Teams. The Hanzo credential is sealed into the connected org's KMS namespace.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTeamsLinkCallbackRequest
*/
func (a *ProviderAPIService) GetProviderTeamsLinkCallback(ctx context.Context) ProviderAPIGetProviderTeamsLinkCallbackRequest {
return ProviderAPIGetProviderTeamsLinkCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTeamsLinkCallbackExecute(r ProviderAPIGetProviderTeamsLinkCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLinkCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/teams/link/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTelegramLinkRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTelegramLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTelegramLinkExecute(r)
}
/*
GetProviderTelegramLink Begin linking a Hanzo account from Telegram
The entry point behind the connect prompt Hanzo sends in Telegram. Unlike the other platforms it answers an HTML PAGE rather than a redirect: Telegram has no OAuth flow, so the page hosts Telegram's Login Widget, and the browser is sent onward only after the user signs in through it.
The widget only appears on the domain registered for the bot, so a deployment whose bot domain is unset renders a page with nothing on it.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTelegramLinkRequest
*/
func (a *ProviderAPIService) GetProviderTelegramLink(ctx context.Context) ProviderAPIGetProviderTelegramLinkRequest {
return ProviderAPIGetProviderTelegramLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTelegramLinkExecute(r ProviderAPIGetProviderTelegramLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/telegram/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTelegramLinkAuthRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTelegramLinkAuthRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTelegramLinkAuthExecute(r)
}
/*
GetProviderTelegramLinkAuth Telegram Login Widget return leg
Where Telegram's Login Widget sends the user with its signed authentication data. That data is verified against the bot token — this is the identity source, and it is the widget's signature rather than a code exchange — and the chat is confirmed to be bound to an org before the browser is handed to the Hanzo sign-in.
Widget data is only accepted while it is fresh, so a captured sign-in blob cannot be replayed later even though its signature stays valid.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTelegramLinkAuthRequest
*/
func (a *ProviderAPIService) GetProviderTelegramLinkAuth(ctx context.Context) ProviderAPIGetProviderTelegramLinkAuthRequest {
return ProviderAPIGetProviderTelegramLinkAuthRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTelegramLinkAuthExecute(r ProviderAPIGetProviderTelegramLinkAuthRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLinkAuth")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/telegram/link/auth"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTelegramLinkCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTelegramLinkCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTelegramLinkCallbackExecute(r)
}
/*
GetProviderTelegramLinkCallback Complete the Telegram account link
The final leg: it binds the verified Telegram user to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Telegram. The Hanzo credential is sealed into the connected org's KMS namespace.
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTelegramLinkCallbackRequest
*/
func (a *ProviderAPIService) GetProviderTelegramLinkCallback(ctx context.Context) ProviderAPIGetProviderTelegramLinkCallbackRequest {
return ProviderAPIGetProviderTelegramLinkCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTelegramLinkCallbackExecute(r ProviderAPIGetProviderTelegramLinkCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLinkCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/telegram/link/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderTwitterCallbackRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderTwitterCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderTwitterCallbackExecute(r)
}
/*
GetProviderTwitterCallback Completes an X consent that arrived on the twitter spelling of the callback.
Completes an X consent that arrived on the twitter spelling of the callback.
The consent URL this process sends is /v1/provider/x/callback. The X app is
also registered at this address, so a browser sent there still finishes the
same flow. State is signed for provider x, and the answer is a redirect.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderTwitterCallbackRequest
*/
func (a *ProviderAPIService) GetProviderTwitterCallback(ctx context.Context) ProviderAPIGetProviderTwitterCallbackRequest {
return ProviderAPIGetProviderTwitterCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderTwitterCallbackExecute(r ProviderAPIGetProviderTwitterCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTwitterCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/twitter/callback"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIGetProviderWhatsappGroupsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
group *string
}
// Group is the group id returned when the group was created.
func (r ProviderAPIGetProviderWhatsappGroupsRequest) Group(group string) ProviderAPIGetProviderWhatsappGroupsRequest {
r.group = &group
return r
}
func (r ProviderAPIGetProviderWhatsappGroupsRequest) Execute() (*ProviderWhatsappGroupOut, *http.Response, error) {
return r.ApiService.GetProviderWhatsappGroupsExecute(r)
}
/*
GetProviderWhatsappGroups Reads the invite link of a group this org's number owns.
Reads the invite link of a group this org's number owns.
Org admin, for the same reason creating one is: the link admits anyone who
holds it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderWhatsappGroupsRequest
*/
func (a *ProviderAPIService) GetProviderWhatsappGroups(ctx context.Context) ProviderAPIGetProviderWhatsappGroupsRequest {
return ProviderAPIGetProviderWhatsappGroupsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderWhatsappGroupOut
func (a *ProviderAPIService) GetProviderWhatsappGroupsExecute(r ProviderAPIGetProviderWhatsappGroupsRequest) (*ProviderWhatsappGroupOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderWhatsappGroupOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderWhatsappGroups")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/whatsapp/groups"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.group != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "group", r.group, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIGetProviderWhatsappWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIGetProviderWhatsappWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.GetProviderWhatsappWebhookExecute(r)
}
/*
GetProviderWhatsappWebhook WhatsApp Cloud API subscription challenge
Meta calls this once when the webhook is subscribed, carrying the verify token this deployment was configured with and a challenge to echo. The token is compared in constant time before the echo — answering the challenge without checking it would let anyone point their own app at this address and have it confirm the subscription.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIGetProviderWhatsappWebhookRequest
*/
func (a *ProviderAPIService) GetProviderWhatsappWebhook(ctx context.Context) ProviderAPIGetProviderWhatsappWebhookRequest {
return ProviderAPIGetProviderWhatsappWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) GetProviderWhatsappWebhookExecute(r ProviderAPIGetProviderWhatsappWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderWhatsappWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/whatsapp/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostConnectionByIdRefreshRequest struct {
ctx context.Context
ApiService *ProviderAPIService
id string
}
func (r ProviderAPIPostConnectionByIdRefreshRequest) Execute() (*ProviderRefreshOut, *http.Response, error) {
return r.ApiService.PostConnectionByIdRefreshExecute(r)
}
/*
PostConnectionByIdRefresh Forces a token rotation for a connected connector, ahead of the automatic rotation a token read would do inside the expiry window.
Forces a token rotation for a connected connector, ahead of the
automatic rotation a token read would do inside the expiry window. Only
providers that declare a Refresh support it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
@return ProviderAPIPostConnectionByIdRefreshRequest
*/
func (a *ProviderAPIService) PostConnectionByIdRefresh(ctx context.Context, id string) ProviderAPIPostConnectionByIdRefreshRequest {
return ProviderAPIPostConnectionByIdRefreshRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ProviderRefreshOut
func (a *ProviderAPIService) PostConnectionByIdRefreshExecute(r ProviderAPIPostConnectionByIdRefreshRequest) (*ProviderRefreshOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderRefreshOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByIdRefresh")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{id}/refresh"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostConnectionByProviderCredentialRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
providerCredentialIn *ProviderCredentialIn
}
func (r ProviderAPIPostConnectionByProviderCredentialRequest) ProviderCredentialIn(providerCredentialIn ProviderCredentialIn) ProviderAPIPostConnectionByProviderCredentialRequest {
r.providerCredentialIn = &providerCredentialIn
return r
}
func (r ProviderAPIPostConnectionByProviderCredentialRequest) Execute() (*ProviderCredentialOut, *http.Response, error) {
return r.ApiService.PostConnectionByProviderCredentialExecute(r)
}
/*
PostConnectionByProviderCredential 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).
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). ALWAYS verify-before-store: a bad credential is refused and NOTHING
is persisted (connectByCredential's fail-closed order).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the user-scoped provider's registry id, from the path.
@return ProviderAPIPostConnectionByProviderCredentialRequest
*/
func (a *ProviderAPIService) PostConnectionByProviderCredential(ctx context.Context, provider string) ProviderAPIPostConnectionByProviderCredentialRequest {
return ProviderAPIPostConnectionByProviderCredentialRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderCredentialOut
func (a *ProviderAPIService) PostConnectionByProviderCredentialExecute(r ProviderAPIPostConnectionByProviderCredentialRequest) (*ProviderCredentialOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderCredentialOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderCredential")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{provider}/credential"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerCredentialIn == nil {
return localVarReturnValue, nil, reportError("providerCredentialIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerCredentialIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostConnectionByProviderDeviceRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
providerDeviceStartIn *ProviderDeviceStartIn
}
func (r ProviderAPIPostConnectionByProviderDeviceRequest) ProviderDeviceStartIn(providerDeviceStartIn ProviderDeviceStartIn) ProviderAPIPostConnectionByProviderDeviceRequest {
r.providerDeviceStartIn = &providerDeviceStartIn
return r
}
func (r ProviderAPIPostConnectionByProviderDeviceRequest) Execute() (*ProviderDeviceStartOut, *http.Response, error) {
return r.ApiService.PostConnectionByProviderDeviceExecute(r)
}
/*
PostConnectionByProviderDevice Begins a device sign-in and returns the code to show the user plus how to poll for completion.
Begins a device sign-in and returns the code to show the user plus
how to poll for completion. KMS readiness is checked NOW rather than dead-ending
the user at poll-done (connect() parity), and the per-provider connector cap is
checked before the provider is called. The provider's device code is persisted
only in the encrypted grants table and is NEVER returned.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the user-scoped provider's registry id, from the path.
@return ProviderAPIPostConnectionByProviderDeviceRequest
*/
func (a *ProviderAPIService) PostConnectionByProviderDevice(ctx context.Context, provider string) ProviderAPIPostConnectionByProviderDeviceRequest {
return ProviderAPIPostConnectionByProviderDeviceRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderDeviceStartOut
func (a *ProviderAPIService) PostConnectionByProviderDeviceExecute(r ProviderAPIPostConnectionByProviderDeviceRequest) (*ProviderDeviceStartOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderDeviceStartOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderDevice")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{provider}/device"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerDeviceStartIn == nil {
return localVarReturnValue, nil, reportError("providerDeviceStartIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerDeviceStartIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
flow string
}
func (r ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest) Execute() (*ProviderDevicePollOut, *http.Response, error) {
return r.ApiService.PostConnectionByProviderDeviceByFlowPollExecute(r)
}
/*
PostConnectionByProviderDeviceByFlowPoll Advances a device sign-in.
Advances a device sign-in. Terminal outcomes are DATA, not errors
(verifyConn {active:false} discipline) — the status set is closed:
pending|connected|denied|expired. pollSlow collapses to "pending" on the
wire; the raised cadence rides interval.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the user-scoped provider's registry id, from the path.
@param flow Flow is the id deviceStartOut returned. Expired or another user's flow is indistinguishable from an unknown one: 404.
@return ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest
*/
func (a *ProviderAPIService) PostConnectionByProviderDeviceByFlowPoll(ctx context.Context, provider string, flow string) ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest {
return ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest{
ApiService: a,
ctx: ctx,
provider: provider,
flow: flow,
}
}
// Execute executes the request
//
// @return ProviderDevicePollOut
func (a *ProviderAPIService) PostConnectionByProviderDeviceByFlowPollExecute(r ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest) (*ProviderDevicePollOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderDevicePollOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderDeviceByFlowPoll")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/connection/{provider}/device/{flow}/poll"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"flow"+"}", url.PathEscape(parameterValueToString(r.flow, "flow")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderByProviderChooseRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
}
func (r ProviderAPIPostProviderByProviderChooseRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderByProviderChooseExecute(r)
}
/*
PostProviderByProviderChoose Answer the connect's account chooser
The form the chooser page posts: `state` (the token the page was given), and either `account` (one of the accounts it offered) or `install` (go on to the provider's install page). It binds the chosen account to the organization that started the connect and redirects back to the page that asked, as the callback does.
It is public and carries no principal. Its authority is the token alone: signed like the callback's state, carrying the offered accounts under its signature, and single-use, so a page answers once and only with an account it offered.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider
@return ProviderAPIPostProviderByProviderChooseRequest
*/
func (a *ProviderAPIService) PostProviderByProviderChoose(ctx context.Context, provider string) ProviderAPIPostProviderByProviderChooseRequest {
return ProviderAPIPostProviderByProviderChooseRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderByProviderChooseExecute(r ProviderAPIPostProviderByProviderChooseRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderChoose")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/choose"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderByProviderConnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
providerConnectIn *ProviderConnectIn
}
func (r ProviderAPIPostProviderByProviderConnectRequest) ProviderConnectIn(providerConnectIn ProviderConnectIn) ProviderAPIPostProviderByProviderConnectRequest {
r.providerConnectIn = &providerConnectIn
return r
}
func (r ProviderAPIPostProviderByProviderConnectRequest) Execute() (*ProviderConnectOut, *http.Response, error) {
return r.ApiService.PostProviderByProviderConnectExecute(r)
}
/*
PostProviderByProviderConnect Acquires the org's credential for one provider.
Acquires the org's credential for one provider. It has TWO paths and the
REQUEST picks which: a "token" key in the body seals that credential directly
(verify-before-store), and its absence begins the 3-legged OAuth flow — minting a
single-use nonce plus an HMAC-signed state that binds this org to this provider,
and answering with the provider's authorize URL for the caller to redirect to.
Fail-closed order, unchanged: no principal → 403; unknown provider → 404; an
AdminOnly connector without the caller's own-org admin bit → 403; not configured
→ 503; KMS not ready → 503 (the flow WILL need to seal a token, so refuse now
rather than dead-end at the callback).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the connector's registry id, from the :provider path segment.
@return ProviderAPIPostProviderByProviderConnectRequest
*/
func (a *ProviderAPIService) PostProviderByProviderConnect(ctx context.Context, provider string) ProviderAPIPostProviderByProviderConnectRequest {
return ProviderAPIPostProviderByProviderConnectRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderConnectOut
func (a *ProviderAPIService) PostProviderByProviderConnectExecute(r ProviderAPIPostProviderByProviderConnectRequest) (*ProviderConnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderConnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderConnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/connect"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerConnectIn == nil {
return localVarReturnValue, nil, reportError("providerConnectIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerConnectIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderByProviderDisconnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
providerDisconnectIn *ProviderDisconnectIn
}
func (r ProviderAPIPostProviderByProviderDisconnectRequest) ProviderDisconnectIn(providerDisconnectIn ProviderDisconnectIn) ProviderAPIPostProviderByProviderDisconnectRequest {
r.providerDisconnectIn = &providerDisconnectIn
return r
}
func (r ProviderAPIPostProviderByProviderDisconnectRequest) Execute() (*ProviderDisconnectOut, *http.Response, error) {
return r.ApiService.PostProviderByProviderDisconnectExecute(r)
}
/*
PostProviderByProviderDisconnect Revokes (best-effort) and forgets an org's connection: it deletes every custodied KMS secret and the connection row.
Revokes (best-effort) and forgets an org's connection: it deletes
every custodied KMS secret and the connection row. Idempotent — disconnecting a
provider that was never connected still returns {disconnected:true}. Symmetric
with connect: an AdminOnly connector needs the caller's own-org admin bit.
An `account` disconnects that one account and leaves the org's others; without
it every account goes. A provider with an App installation (GitHub) also removes
the installation at the provider for each account no other org still holds, so
connecting that account again is a fresh install rather than GitHub's Configure
page, which returns nothing the connect can bind.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the connector's registry id, from the :provider path segment.
@return ProviderAPIPostProviderByProviderDisconnectRequest
*/
func (a *ProviderAPIService) PostProviderByProviderDisconnect(ctx context.Context, provider string) ProviderAPIPostProviderByProviderDisconnectRequest {
return ProviderAPIPostProviderByProviderDisconnectRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderDisconnectOut
func (a *ProviderAPIService) PostProviderByProviderDisconnectExecute(r ProviderAPIPostProviderByProviderDisconnectRequest) (*ProviderDisconnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderDisconnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderDisconnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/disconnect"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerDisconnectIn == nil {
return localVarReturnValue, nil, reportError("providerDisconnectIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerDisconnectIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderByProviderRunRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
providerRunIn *ProviderRunIn
}
func (r ProviderAPIPostProviderByProviderRunRequest) ProviderRunIn(providerRunIn ProviderRunIn) ProviderAPIPostProviderByProviderRunRequest {
r.providerRunIn = &providerRunIn
return r
}
func (r ProviderAPIPostProviderByProviderRunRequest) Execute() (*ProviderRunOut, *http.Response, error) {
return r.ApiService.PostProviderByProviderRunExecute(r)
}
/*
PostProviderByProviderRun Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned.
Runs one action of a connector as the caller's org, with the credential
the org connected, and answers what the action returned. The credential is
read from the org's KMS namespace here and never leaves this service. An
action that ran and failed is ok:false with the reason; an unknown connector
is 404, an action that does not run on this deployment 422, and a connector
the org has not connected 424.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider Provider is the connector, from the path.
@return ProviderAPIPostProviderByProviderRunRequest
*/
func (a *ProviderAPIService) PostProviderByProviderRun(ctx context.Context, provider string) ProviderAPIPostProviderByProviderRunRequest {
return ProviderAPIPostProviderByProviderRunRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderRunOut
func (a *ProviderAPIService) PostProviderByProviderRunExecute(r ProviderAPIPostProviderByProviderRunRequest) (*ProviderRunOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderRunOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderRun")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/run"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerRunIn == nil {
return localVarReturnValue, nil, reportError("providerRunIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerRunIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderByProviderVerifyRequest struct {
ctx context.Context
ApiService *ProviderAPIService
provider string
}
func (r ProviderAPIPostProviderByProviderVerifyRequest) Execute() (*ProviderVerifyOut, *http.Response, error) {
return r.ApiService.PostProviderByProviderVerifyExecute(r)
}
/*
PostProviderByProviderVerify Re-checks a CONNECTED apikey connector's stored credential against the provider, live (`hanzo connector verify`).
Re-checks a CONNECTED apikey connector's stored credential against the
provider, live (`hanzo connector verify`). Org-scoped (any member may check
status); the credential is read from KMS, verified, and NEVER returned or logged.
A verification failure is reported as {active:false}, not an error — the console/
CLI renders it. Only apikey providers support verify (OAuth tokens are checked at
use, not re-verified here).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider 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.
@return ProviderAPIPostProviderByProviderVerifyRequest
*/
func (a *ProviderAPIService) PostProviderByProviderVerify(ctx context.Context, provider string) ProviderAPIPostProviderByProviderVerifyRequest {
return ProviderAPIPostProviderByProviderVerifyRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
//
// @return ProviderVerifyOut
func (a *ProviderAPIService) PostProviderByProviderVerifyExecute(r ProviderAPIPostProviderByProviderVerifyRequest) (*ProviderVerifyOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderVerifyOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderVerify")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/{provider}/verify"
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderDiscordInteractionsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderDiscordInteractionsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderDiscordInteractionsExecute(r)
}
/*
PostProviderDiscordInteractions Discord interactions endpoint
The Interactions Endpoint URL for the Discord app. It answers Discord's PING with a PONG, and handles the `/hanzo` slash command by acknowledging with a deferred ephemeral reply and editing that reply with the answer once the agent has run. Any other interaction is acknowledged and ignored.
Requests are verified by ED25519 SIGNATURE over the timestamp and body against the app's public key — not by HMAC, unlike the Slack webhooks. Interactions work over plain HTTP, so no gateway connection and no message-content intent is involved.
Discord does not retry, so this is the one channel where being at capacity is shown to the user as an ephemeral ask-to-run-it-again rather than answered as a retriable failure — nothing is recorded either way, so the next attempt is clean.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderDiscordInteractionsRequest
*/
func (a *ProviderAPIService) PostProviderDiscordInteractions(ctx context.Context) ProviderAPIPostProviderDiscordInteractionsRequest {
return ProviderAPIPostProviderDiscordInteractionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderDiscordInteractionsExecute(r ProviderAPIPostProviderDiscordInteractionsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderDiscordInteractions")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/discord/interactions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderForgeWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
forgeJob *ForgeJob
}
func (r ProviderAPIPostProviderForgeWebhookRequest) ForgeJob(forgeJob ForgeJob) ProviderAPIPostProviderForgeWebhookRequest {
r.forgeJob = &forgeJob
return r
}
func (r ProviderAPIPostProviderForgeWebhookRequest) Execute() (*ForgeLaunched, *http.Response, error) {
return r.ApiService.PostProviderForgeWebhookExecute(r)
}
/*
PostProviderForgeWebhook Forge workflow_job webhook
Receives the forge's workflow_job delivery. The signature over the raw body is checked against the secret at KMS forge.WebhookRef before anything is decoded; a queued job becomes one ephemeral runner Job on the cluster, minted a registration token for exactly that job. Every other action is answered 200 and ignored.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderForgeWebhookRequest
*/
func (a *ProviderAPIService) PostProviderForgeWebhook(ctx context.Context) ProviderAPIPostProviderForgeWebhookRequest {
return ProviderAPIPostProviderForgeWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ForgeLaunched
func (a *ProviderAPIService) PostProviderForgeWebhookExecute(r ProviderAPIPostProviderForgeWebhookRequest) (*ForgeLaunched, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ForgeLaunched
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderForgeWebhook")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/forge/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.forgeJob
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubForkRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubForkReq *ProviderGithubForkReq
}
func (r ProviderAPIPostProviderGithubForkRequest) ProviderGithubForkReq(providerGithubForkReq ProviderGithubForkReq) ProviderAPIPostProviderGithubForkRequest {
r.providerGithubForkReq = &providerGithubForkReq
return r
}
func (r ProviderAPIPostProviderGithubForkRequest) Execute() (*ProviderGithubForkOut, *http.Response, error) {
return r.ApiService.PostProviderGithubForkExecute(r)
}
/*
PostProviderGithubFork Forks a granted repository.
Forks a granted repository.
GitHub's fork is ASYNCHRONOUS: it answers 202 with the target repo and
populates it in the background, and it answers the same 202 when the fork
already exists. So this reports what GitHub said rather than waiting — a call
that blocked until the clone finished would time out on a large repository and
tell the caller nothing it does not already know.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubForkRequest
*/
func (a *ProviderAPIService) PostProviderGithubFork(ctx context.Context) ProviderAPIPostProviderGithubForkRequest {
return ProviderAPIPostProviderGithubForkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubForkOut
func (a *ProviderAPIService) PostProviderGithubForkExecute(r ProviderAPIPostProviderGithubForkRequest) (*ProviderGithubForkOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubForkOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubFork")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/fork"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubForkReq == nil {
return localVarReturnValue, nil, reportError("providerGithubForkReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubForkReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubIssuesBackfillRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubBackfillIn *ProviderGithubBackfillIn
}
func (r ProviderAPIPostProviderGithubIssuesBackfillRequest) ProviderGithubBackfillIn(providerGithubBackfillIn ProviderGithubBackfillIn) ProviderAPIPostProviderGithubIssuesBackfillRequest {
r.providerGithubBackfillIn = &providerGithubBackfillIn
return r
}
func (r ProviderAPIPostProviderGithubIssuesBackfillRequest) Execute() (*ProviderGithubBackfillResult, *http.Response, error) {
return r.ApiService.PostProviderGithubIssuesBackfillExecute(r)
}
/*
PostProviderGithubIssuesBackfill Seeds the native todo with the EXISTING issues across the org's granted repos (default state=open); the webhook keeps them live thereafter.
Seeds the native todo with the EXISTING issues across the
org's granted repos (default state=open); the webhook keeps them live thereafter.
Org-scoped by the validated principal — a caller only ever backfills its OWN org.
Synchronous + bounded (a total time budget and an issue cap) so it returns the
counts directly; idempotent by ExtRef, so a re-run continues where a truncated
pass left off and never duplicates.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubIssuesBackfillRequest
*/
func (a *ProviderAPIService) PostProviderGithubIssuesBackfill(ctx context.Context) ProviderAPIPostProviderGithubIssuesBackfillRequest {
return ProviderAPIPostProviderGithubIssuesBackfillRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubBackfillResult
func (a *ProviderAPIService) PostProviderGithubIssuesBackfillExecute(r ProviderAPIPostProviderGithubIssuesBackfillRequest) (*ProviderGithubBackfillResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubBackfillResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubIssuesBackfill")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/issues/backfill"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubBackfillIn == nil {
return localVarReturnValue, nil, reportError("providerGithubBackfillIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubBackfillIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubReposByRepoPagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
repo string
providerGithubPagesEnableReq *ProviderGithubPagesEnableReq
}
func (r ProviderAPIPostProviderGithubReposByRepoPagesRequest) ProviderGithubPagesEnableReq(providerGithubPagesEnableReq ProviderGithubPagesEnableReq) ProviderAPIPostProviderGithubReposByRepoPagesRequest {
r.providerGithubPagesEnableReq = &providerGithubPagesEnableReq
return r
}
func (r ProviderAPIPostProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesView, *http.Response, error) {
return r.ApiService.PostProviderGithubReposByRepoPagesExecute(r)
}
/*
PostProviderGithubReposByRepoPages Creates the repo's Pages site and answers 201 Created with it.
Creates the repo's Pages site and answers 201 Created with it.
With buildType "workflow" the site builds via GitHub Actions; otherwise it builds
from a branch source, defaulting to the repo's own default branch when none is
given. Only "/" and "/docs" are legal source paths (GitHub's rule).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param repo Repo is the repository, from the :repo path segment.
@return ProviderAPIPostProviderGithubReposByRepoPagesRequest
*/
func (a *ProviderAPIService) PostProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIPostProviderGithubReposByRepoPagesRequest {
return ProviderAPIPostProviderGithubReposByRepoPagesRequest{
ApiService: a,
ctx: ctx,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubPagesView
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesExecute(r ProviderAPIPostProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubPagesView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposByRepoPages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubPagesEnableReq == nil {
return localVarReturnValue, nil, reportError("providerGithubPagesEnableReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubPagesEnableReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
repo string
}
func (r ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest) Execute() (*ProviderGithubPagesBuildOut, *http.Response, error) {
return r.ApiService.PostProviderGithubReposByRepoPagesBuildsExecute(r)
}
/*
PostProviderGithubReposByRepoPagesBuilds Requests a Pages rebuild and returns the queued build's status.
Requests a Pages rebuild and returns the queued build's status.
The build is queued AT GITHUB, not completed here, so the answer is 202 Accepted
and its status is the one GitHub reported at queue time. 404 when the repository
has no Pages site, or when the org's installation was not granted it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param repo 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.
@return ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest
*/
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesBuilds(ctx context.Context, repo string) ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest {
return ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest{
ApiService: a,
ctx: ctx,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubPagesBuildOut
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesBuildsExecute(r ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest) (*ProviderGithubPagesBuildOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubPagesBuildOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposByRepoPagesBuilds")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages/builds"
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubReposImportRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubImportIn *ProviderGithubImportIn
}
func (r ProviderAPIPostProviderGithubReposImportRequest) ProviderGithubImportIn(providerGithubImportIn ProviderGithubImportIn) ProviderAPIPostProviderGithubReposImportRequest {
r.providerGithubImportIn = &providerGithubImportIn
return r
}
func (r ProviderAPIPostProviderGithubReposImportRequest) Execute() (*ProviderGithubImportOut, *http.Response, error) {
return r.ApiService.PostProviderGithubReposImportExecute(r)
}
/*
PostProviderGithubReposImport Imports the selected (or all) granted repos into git.hanzo.ai.
Imports the selected (or all) granted repos into git.hanzo.ai. The
selection is intersected with the installation's GRANTED set, so a client can
never import a repo the App was not granted (org isolation + a grant check). The
import runs in a bounded background worker (don't block the request), so the
answer is 202 Accepted; poll GET /v1/git/repos for each repository to appear
on git.hanzo.ai.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubReposImportRequest
*/
func (a *ProviderAPIService) PostProviderGithubReposImport(ctx context.Context) ProviderAPIPostProviderGithubReposImportRequest {
return ProviderAPIPostProviderGithubReposImportRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubImportOut
func (a *ProviderAPIService) PostProviderGithubReposImportExecute(r ProviderAPIPostProviderGithubReposImportRequest) (*ProviderGithubImportOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubImportOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposImport")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/import"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubImportIn == nil {
return localVarReturnValue, nil, reportError("providerGithubImportIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubImportIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubSearchRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubSearchReq *ProviderGithubSearchReq
}
func (r ProviderAPIPostProviderGithubSearchRequest) ProviderGithubSearchReq(providerGithubSearchReq ProviderGithubSearchReq) ProviderAPIPostProviderGithubSearchRequest {
r.providerGithubSearchReq = &providerGithubSearchReq
return r
}
func (r ProviderAPIPostProviderGithubSearchRequest) Execute() (*ProviderGithubSearchOut, *http.Response, error) {
return r.ApiService.PostProviderGithubSearchExecute(r)
}
/*
PostProviderGithubSearch Finds repositories on GitHub.
Finds repositories on GitHub.
This reads the PUBLIC index and returns nothing an installation unlocks: it is
how you find a repository to fork, not a way to see inside one. The org's own
token is used only so the query is rate-limited against the installation
rather than anonymously — the results are the same ones anyone would get.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubSearchRequest
*/
func (a *ProviderAPIService) PostProviderGithubSearch(ctx context.Context) ProviderAPIPostProviderGithubSearchRequest {
return ProviderAPIPostProviderGithubSearchRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubSearchOut
func (a *ProviderAPIService) PostProviderGithubSearchExecute(r ProviderAPIPostProviderGithubSearchRequest) (*ProviderGithubSearchOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubSearchOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubSearch")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/search"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubSearchReq == nil {
return localVarReturnValue, nil, reportError("providerGithubSearchReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubSearchReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubUserCompleteRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubUserCompleteIn *ProviderGithubUserCompleteIn
}
func (r ProviderAPIPostProviderGithubUserCompleteRequest) ProviderGithubUserCompleteIn(providerGithubUserCompleteIn ProviderGithubUserCompleteIn) ProviderAPIPostProviderGithubUserCompleteRequest {
r.providerGithubUserCompleteIn = &providerGithubUserCompleteIn
return r
}
func (r ProviderAPIPostProviderGithubUserCompleteRequest) Execute() (*ProviderGithubUserOut, *http.Response, error) {
return r.ApiService.PostProviderGithubUserCompleteExecute(r)
}
/*
PostProviderGithubUserComplete Finishes connecting the caller's GitHub account: it takes the authorization the callback parked, trades it for the person's token, and seals it.
Finishes connecting the caller's GitHub account: it takes
the authorization the callback parked, trades it for the person's token, and
seals it. Only the person who started the flow can complete it — another
person's grant id is simply not found — and a grant completes once.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubUserCompleteRequest
*/
func (a *ProviderAPIService) PostProviderGithubUserComplete(ctx context.Context) ProviderAPIPostProviderGithubUserCompleteRequest {
return ProviderAPIPostProviderGithubUserCompleteRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubUserOut
func (a *ProviderAPIService) PostProviderGithubUserCompleteExecute(r ProviderAPIPostProviderGithubUserCompleteRequest) (*ProviderGithubUserOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubUserOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserComplete")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/user/complete"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubUserCompleteIn == nil {
return localVarReturnValue, nil, reportError("providerGithubUserCompleteIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubUserCompleteIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubUserConnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGithubUserConnectIn *ProviderGithubUserConnectIn
}
func (r ProviderAPIPostProviderGithubUserConnectRequest) ProviderGithubUserConnectIn(providerGithubUserConnectIn ProviderGithubUserConnectIn) ProviderAPIPostProviderGithubUserConnectRequest {
r.providerGithubUserConnectIn = &providerGithubUserConnectIn
return r
}
func (r ProviderAPIPostProviderGithubUserConnectRequest) Execute() (*ProviderGithubUserConnectOut, *http.Response, error) {
return r.ApiService.PostProviderGithubUserConnectExecute(r)
}
/*
PostProviderGithubUserConnect 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.
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. Every member may connect their own; it grants nothing the person does
not already hold on GitHub. The page shows GitHub's account picker (githubPick),
so a connect after a Disconnect can choose another account: GitHub otherwise
skips the page for anyone who authorized the App before.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubUserConnectRequest
*/
func (a *ProviderAPIService) PostProviderGithubUserConnect(ctx context.Context) ProviderAPIPostProviderGithubUserConnectRequest {
return ProviderAPIPostProviderGithubUserConnectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubUserConnectOut
func (a *ProviderAPIService) PostProviderGithubUserConnectExecute(r ProviderAPIPostProviderGithubUserConnectRequest) (*ProviderGithubUserConnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubUserConnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserConnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/user/connect"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubUserConnectIn == nil {
return localVarReturnValue, nil, reportError("providerGithubUserConnectIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubUserConnectIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubUserDisconnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderGithubUserDisconnectRequest) Execute() (*ProviderGithubUserDisconnectOut, *http.Response, error) {
return r.ApiService.PostProviderGithubUserDisconnectExecute(r)
}
/*
PostProviderGithubUserDisconnect Forgets the caller's GitHub connection in this org: the token is revoked at GitHub, and the sealed secrets and the row go.
Forgets the caller's GitHub connection in this org: the
token is revoked at GitHub, and the sealed secrets and the row go. It says
whether GitHub confirmed the revocation rather than reporting a success it did
not see. Disconnecting what is not connected succeeds.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubUserDisconnectRequest
*/
func (a *ProviderAPIService) PostProviderGithubUserDisconnect(ctx context.Context) ProviderAPIPostProviderGithubUserDisconnectRequest {
return ProviderAPIPostProviderGithubUserDisconnectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGithubUserDisconnectOut
func (a *ProviderAPIService) PostProviderGithubUserDisconnectExecute(r ProviderAPIPostProviderGithubUserDisconnectRequest) (*ProviderGithubUserDisconnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubUserDisconnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserDisconnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/user/disconnect"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGithubWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderGithubWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderGithubWebhookExecute(r)
}
/*
PostProviderGithubWebhook GitHub App webhook
The address the GitHub App delivers events to. A push is handed to the repository sync engine, and an issue or issue-comment event is mirrored into the native todo — idempotently, so the same issue re-syncs to one row however many times it is edited, closed or reopened. A repository event that puts a repo INTO the granted set (created, transferred, unarchived) raises one todo offering to import it; accepting means POSTing that repo to /v1/provider/github/import. It never imports on its own.
It answers a benign 200 for everything it does not act on — the ping, other event types, an unknown installation — deliberately, so GitHub does not enter a retry storm over events that were never going to do anything. Only a bad signature and a genuine sync failure are non-200, and an oversized payload is refused outright.
Two sync rules are worth stating because neither is guessable. EVERY ref syncs, tags as well as branches, because releases are cut by tag and filtering them would stop publishing with nothing reporting a failure. And a delete is NEVER propagated: the native side is canonical, so an inbound delete never removes a native ref.
The payload is verified by HMAC against the webhook secret before it is parsed.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGithubWebhookRequest
*/
func (a *ProviderAPIService) PostProviderGithubWebhook(ctx context.Context) ProviderAPIPostProviderGithubWebhookRequest {
return ProviderAPIPostProviderGithubWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderGithubWebhookExecute(r ProviderAPIPostProviderGithubWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGoogleUserCompleteRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGoogleUserCompleteIn *ProviderGoogleUserCompleteIn
}
func (r ProviderAPIPostProviderGoogleUserCompleteRequest) ProviderGoogleUserCompleteIn(providerGoogleUserCompleteIn ProviderGoogleUserCompleteIn) ProviderAPIPostProviderGoogleUserCompleteRequest {
r.providerGoogleUserCompleteIn = &providerGoogleUserCompleteIn
return r
}
func (r ProviderAPIPostProviderGoogleUserCompleteRequest) Execute() (*ProviderGoogleUserOut, *http.Response, error) {
return r.ApiService.PostProviderGoogleUserCompleteExecute(r)
}
/*
PostProviderGoogleUserComplete Finishes connecting the caller's Google account: it takes the authorization the callback parked, trades it for the person's tokens, and seals them.
Finishes connecting the caller's Google account: it takes
the authorization the callback parked, trades it for the person's tokens, and
seals them. Only the person who started the flow can complete it — another
person's grant id is simply not found — and a grant completes once. A grant
that leaves out sending mail, or offline access, is refused and nothing is
kept: a connection that cannot send is not one this surface offers.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGoogleUserCompleteRequest
*/
func (a *ProviderAPIService) PostProviderGoogleUserComplete(ctx context.Context) ProviderAPIPostProviderGoogleUserCompleteRequest {
return ProviderAPIPostProviderGoogleUserCompleteRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGoogleUserOut
func (a *ProviderAPIService) PostProviderGoogleUserCompleteExecute(r ProviderAPIPostProviderGoogleUserCompleteRequest) (*ProviderGoogleUserOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGoogleUserOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserComplete")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/google/user/complete"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGoogleUserCompleteIn == nil {
return localVarReturnValue, nil, reportError("providerGoogleUserCompleteIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGoogleUserCompleteIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGoogleUserConnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerGoogleUserConnectIn *ProviderGoogleUserConnectIn
}
func (r ProviderAPIPostProviderGoogleUserConnectRequest) ProviderGoogleUserConnectIn(providerGoogleUserConnectIn ProviderGoogleUserConnectIn) ProviderAPIPostProviderGoogleUserConnectRequest {
r.providerGoogleUserConnectIn = &providerGoogleUserConnectIn
return r
}
func (r ProviderAPIPostProviderGoogleUserConnectRequest) Execute() (*ProviderGoogleUserConnectOut, *http.Response, error) {
return r.ApiService.PostProviderGoogleUserConnectExecute(r)
}
/*
PostProviderGoogleUserConnect 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.
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. Every member may connect their own;
it grants nothing the person does not already hold at Google.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGoogleUserConnectRequest
*/
func (a *ProviderAPIService) PostProviderGoogleUserConnect(ctx context.Context) ProviderAPIPostProviderGoogleUserConnectRequest {
return ProviderAPIPostProviderGoogleUserConnectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGoogleUserConnectOut
func (a *ProviderAPIService) PostProviderGoogleUserConnectExecute(r ProviderAPIPostProviderGoogleUserConnectRequest) (*ProviderGoogleUserConnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGoogleUserConnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserConnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/google/user/connect"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGoogleUserConnectIn == nil {
return localVarReturnValue, nil, reportError("providerGoogleUserConnectIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGoogleUserConnectIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderGoogleUserDisconnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderGoogleUserDisconnectRequest) Execute() (*ProviderGoogleUserDisconnectOut, *http.Response, error) {
return r.ApiService.PostProviderGoogleUserDisconnectExecute(r)
}
/*
PostProviderGoogleUserDisconnect Forgets the caller's Google connection in this org: the grant is revoked at Google, and the sealed secrets and the row go.
Forgets the caller's Google connection in this org: the
grant is revoked at Google, and the sealed secrets and the row go. It says
whether Google confirmed the revocation rather than reporting a success it did
not see. Disconnecting what is not connected succeeds.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderGoogleUserDisconnectRequest
*/
func (a *ProviderAPIService) PostProviderGoogleUserDisconnect(ctx context.Context) ProviderAPIPostProviderGoogleUserDisconnectRequest {
return ProviderAPIPostProviderGoogleUserDisconnectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderGoogleUserDisconnectOut
func (a *ProviderAPIService) PostProviderGoogleUserDisconnectExecute(r ProviderAPIPostProviderGoogleUserDisconnectRequest) (*ProviderGoogleUserDisconnectOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGoogleUserDisconnectOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserDisconnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/google/user/disconnect"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderLinearClaimRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerLinearClaimIn *ProviderLinearClaimIn
}
func (r ProviderAPIPostProviderLinearClaimRequest) ProviderLinearClaimIn(providerLinearClaimIn ProviderLinearClaimIn) ProviderAPIPostProviderLinearClaimRequest {
r.providerLinearClaimIn = &providerLinearClaimIn
return r
}
func (r ProviderAPIPostProviderLinearClaimRequest) Execute() (*ProviderLinearClaimOut, *http.Response, error) {
return r.ApiService.PostProviderLinearClaimExecute(r)
}
/*
PostProviderLinearClaim Binds the caller's Linear organization to the org and seals the webhook secret.
Binds the caller's Linear organization to the org and seals the
webhook secret. The organization is READ from the caller's own key, never taken
from the body: a person can only bind an organization they are a member of. An
organization another org already holds is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderLinearClaimRequest
*/
func (a *ProviderAPIService) PostProviderLinearClaim(ctx context.Context) ProviderAPIPostProviderLinearClaimRequest {
return ProviderAPIPostProviderLinearClaimRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderLinearClaimOut
func (a *ProviderAPIService) PostProviderLinearClaimExecute(r ProviderAPIPostProviderLinearClaimRequest) (*ProviderLinearClaimOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderLinearClaimOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearClaim")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/linear/claim"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerLinearClaimIn == nil {
return localVarReturnValue, nil, reportError("providerLinearClaimIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerLinearClaimIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderLinearCommentsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerLinearCommentIn *ProviderLinearCommentIn
}
func (r ProviderAPIPostProviderLinearCommentsRequest) ProviderLinearCommentIn(providerLinearCommentIn ProviderLinearCommentIn) ProviderAPIPostProviderLinearCommentsRequest {
r.providerLinearCommentIn = &providerLinearCommentIn
return r
}
func (r ProviderAPIPostProviderLinearCommentsRequest) Execute() (*ProviderLinearCommentOut, *http.Response, error) {
return r.ApiService.PostProviderLinearCommentsExecute(r)
}
/*
PostProviderLinearComments Posts a comment on a Linear issue with the caller's own key, so it carries their name.
Posts a comment on a Linear issue with the caller's own key, so it
carries their name. This is the op an agent is offered when it should answer in
Linear rather than in chat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderLinearCommentsRequest
*/
func (a *ProviderAPIService) PostProviderLinearComments(ctx context.Context) ProviderAPIPostProviderLinearCommentsRequest {
return ProviderAPIPostProviderLinearCommentsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderLinearCommentOut
func (a *ProviderAPIService) PostProviderLinearCommentsExecute(r ProviderAPIPostProviderLinearCommentsRequest) (*ProviderLinearCommentOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderLinearCommentOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearComments")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/linear/comments"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerLinearCommentIn == nil {
return localVarReturnValue, nil, reportError("providerLinearCommentIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerLinearCommentIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderLinearIssuesBackfillRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerLinearBackfillIn *ProviderLinearBackfillIn
}
func (r ProviderAPIPostProviderLinearIssuesBackfillRequest) ProviderLinearBackfillIn(providerLinearBackfillIn ProviderLinearBackfillIn) ProviderAPIPostProviderLinearIssuesBackfillRequest {
r.providerLinearBackfillIn = &providerLinearBackfillIn
return r
}
func (r ProviderAPIPostProviderLinearIssuesBackfillRequest) Execute() (*ProviderLinearBackfillResult, *http.Response, error) {
return r.ApiService.PostProviderLinearIssuesBackfillExecute(r)
}
/*
PostProviderLinearIssuesBackfill Seeds the native todo with the EXISTING Linear issues the caller's key can see (default state=open); the webhook keeps them live thereafter.
Seeds the native todo with the EXISTING Linear issues the
caller's key can see (default state=open); the webhook keeps them live
thereafter. Synchronous and bounded, idempotent by ExtRef.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderLinearIssuesBackfillRequest
*/
func (a *ProviderAPIService) PostProviderLinearIssuesBackfill(ctx context.Context) ProviderAPIPostProviderLinearIssuesBackfillRequest {
return ProviderAPIPostProviderLinearIssuesBackfillRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderLinearBackfillResult
func (a *ProviderAPIService) PostProviderLinearIssuesBackfillExecute(r ProviderAPIPostProviderLinearIssuesBackfillRequest) (*ProviderLinearBackfillResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderLinearBackfillResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearIssuesBackfill")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/linear/issues/backfill"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerLinearBackfillIn == nil {
return localVarReturnValue, nil, reportError("providerLinearBackfillIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerLinearBackfillIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderLinearWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderLinearWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderLinearWebhookExecute(r)
}
/*
PostProviderLinearWebhook Linear webhook
The address Linear delivers Issue and Comment events to. An issue event is mirrored into the native todo — idempotently by identifier, so ENG-123 is one row however many times it is edited, moved or closed — and every issue and comment event is handed to the automations engine as a verified trigger, which is how an org runs an agent when an issue is assigned to it or a comment mentions it. A remove is never propagated: the native side is canonical.
It answers a benign 200 for what it does not act on — an unknown organization, other event types — so Linear does not retry-storm. A bad signature and a delivery older than a minute are 401; only a sink failure is 502.
The delivery names its Linear organization; that organization's own webhook secret — sealed at /v1/provider/linear/claim — verifies the HMAC over the raw body, so the tenant is the organization the signature proves, never a header.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderLinearWebhookRequest
*/
func (a *ProviderAPIService) PostProviderLinearWebhook(ctx context.Context) ProviderAPIPostProviderLinearWebhookRequest {
return ProviderAPIPostProviderLinearWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderLinearWebhookExecute(r ProviderAPIPostProviderLinearWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/linear/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderOpenrouterWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
requestBody *map[string]interface{}
}
func (r ProviderAPIPostProviderOpenrouterWebhookRequest) RequestBody(requestBody map[string]interface{}) ProviderAPIPostProviderOpenrouterWebhookRequest {
r.requestBody = &requestBody
return r
}
func (r ProviderAPIPostProviderOpenrouterWebhookRequest) Execute() (map[string]interface{}, *http.Response, error) {
return r.ApiService.PostProviderOpenrouterWebhookExecute(r)
}
/*
PostProviderOpenrouterWebhook Receive OpenRouter Broadcast traces as usage rows
OpenRouter's spend is invisible to every Hanzo money lens because those lenses read hanzo.cloud_usage and OpenRouter meters keys of its own. Point a Broadcast destination (Settings ▸ Observability ▸ Webhook) at this endpoint and each generation span becomes ONE row in that same ledger with provider `openrouter`, so one query answers what we spend everywhere. Enable the Cost and Identity field categories: cost is the money and identity carries `openrouter.api_key_name`, which is what says WHICH key spent it — it lands in `account` as openrouter/<key name>.
AUTHENTICATION IS A HANZO KEY. Broadcast signs nothing; its only authentication is the destination's Headers map, so send a key as `Authorization: Bearer pk-…` and it is admitted exactly as /v1/event admits a beacon's: a project key resolves through the project that minted it, an IAM-issued key through IAM. That key names the org every row is filed under; it can write and cannot read. No key, or a key that names no org, is 401 and nothing is stored.
The body is OTLP/JSON — `{resourceSpans:[{scopeSpans:[{spans:[…]}]}]}` — exactly as OpenTelemetry defines it; the model, tokens and cost are read from each span's `gen_ai.*` attributes and the key name from `openrouter.api_key_name`. The answer is `{stored, dropped}`: how many generations became rows, and how many spans named no model. Those are OpenRouter's trace and span parents — they carry no cost to meter. An empty payload stores nothing and answers 200, which is what makes Test Connection pass. A warehouse that cannot take the rows answers 503 so the delivery shows red and can be replayed: a row is keyed by its span id, so a redelivery collapses rather than double-counting.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderOpenrouterWebhookRequest
*/
func (a *ProviderAPIService) PostProviderOpenrouterWebhook(ctx context.Context) ProviderAPIPostProviderOpenrouterWebhookRequest {
return ProviderAPIPostProviderOpenrouterWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return map[string]interface{}
func (a *ProviderAPIService) PostProviderOpenrouterWebhookExecute(r ProviderAPIPostProviderOpenrouterWebhookRequest) (map[string]interface{}, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue map[string]interface{}
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderOpenrouterWebhook")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/openrouter/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.requestBody
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackCommandsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderSlackCommandsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderSlackCommandsExecute(r)
}
/*
PostProviderSlackCommands Slack slash command webhook
The address Slack posts a slash command to, form-encoded. It acknowledges inside Slack's three-second budget and posts the answer afterwards to the command's own response URL, which is why the immediate reply is empty.
The body is verified against the same app signing secret as the events webhook, and a repeat of the same command invocation is absorbed rather than answered twice.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackCommandsRequest
*/
func (a *ProviderAPIService) PostProviderSlackCommands(ctx context.Context) ProviderAPIPostProviderSlackCommandsRequest {
return ProviderAPIPostProviderSlackCommandsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderSlackCommandsExecute(r ProviderAPIPostProviderSlackCommandsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackCommands")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/commands"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackEventsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderSlackEventsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderSlackEventsExecute(r)
}
/*
PostProviderSlackEvents Slack Events API webhook
The address a Slack app posts workspace events to. It answers Slack's url_verification handshake with the challenge, and routes an @mention or a direct message to an agent turn that replies in the same thread. The turn holds the product's own tools, so a request to change code starts a sandbox run because the model chose to — there is no prefix and no second path.
The raw body and its timestamp are verified against the app's signing secret before anything is read from them. Hanzo's own bot messages are dropped, so a reply cannot trigger another reply.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackEventsRequest
*/
func (a *ProviderAPIService) PostProviderSlackEvents(ctx context.Context) ProviderAPIPostProviderSlackEventsRequest {
return ProviderAPIPostProviderSlackEventsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderSlackEventsExecute(r ProviderAPIPostProviderSlackEventsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackEvents")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/events"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackJoinRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderSlackJoinRequest) Execute() (*ProviderSlackJoinOut, *http.Response, error) {
return r.ApiService.PostProviderSlackJoinExecute(r)
}
/*
PostProviderSlackJoin Joins every public channel in the caller org's workspace.
Joins every public channel in the caller org's workspace.
Org admin, because it changes what the whole workspace sees: after it the agent
is a member of every public room and answers in all of them.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackJoinRequest
*/
func (a *ProviderAPIService) PostProviderSlackJoin(ctx context.Context) ProviderAPIPostProviderSlackJoinRequest {
return ProviderAPIPostProviderSlackJoinRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackJoinOut
func (a *ProviderAPIService) PostProviderSlackJoinExecute(r ProviderAPIPostProviderSlackJoinRequest) (*ProviderSlackJoinOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackJoinOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackJoin")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/join"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackMessagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerSlackSendMessageIn *ProviderSlackSendMessageIn
}
func (r ProviderAPIPostProviderSlackMessagesRequest) ProviderSlackSendMessageIn(providerSlackSendMessageIn ProviderSlackSendMessageIn) ProviderAPIPostProviderSlackMessagesRequest {
r.providerSlackSendMessageIn = &providerSlackSendMessageIn
return r
}
func (r ProviderAPIPostProviderSlackMessagesRequest) Execute() (*ProviderSlackSendMessageOut, *http.Response, error) {
return r.ApiService.PostProviderSlackMessagesExecute(r)
}
/*
PostProviderSlackMessages Posts as Hanzo to the caller's connected Slack workspace.
Posts as Hanzo to the caller's connected Slack workspace.
Use channel from a message read and thread_ts to reply to a specific message.
Requires chat:write; this operation does not join channels automatically.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackMessagesRequest
*/
func (a *ProviderAPIService) PostProviderSlackMessages(ctx context.Context) ProviderAPIPostProviderSlackMessagesRequest {
return ProviderAPIPostProviderSlackMessagesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackSendMessageOut
func (a *ProviderAPIService) PostProviderSlackMessagesExecute(r ProviderAPIPostProviderSlackMessagesRequest) (*ProviderSlackSendMessageOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackSendMessageOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/messages"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerSlackSendMessageIn == nil {
return localVarReturnValue, nil, reportError("providerSlackSendMessageIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerSlackSendMessageIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackReactionsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerSlackReactIn *ProviderSlackReactIn
}
func (r ProviderAPIPostProviderSlackReactionsRequest) ProviderSlackReactIn(providerSlackReactIn ProviderSlackReactIn) ProviderAPIPostProviderSlackReactionsRequest {
r.providerSlackReactIn = &providerSlackReactIn
return r
}
func (r ProviderAPIPostProviderSlackReactionsRequest) Execute() (*ProviderSlackReactOut, *http.Response, error) {
return r.ApiService.PostProviderSlackReactionsExecute(r)
}
/*
PostProviderSlackReactions Adds an emoji reaction: POST /v1/provider/slack/reactions.
Adds an emoji reaction: POST /v1/provider/slack/reactions.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackReactionsRequest
*/
func (a *ProviderAPIService) PostProviderSlackReactions(ctx context.Context) ProviderAPIPostProviderSlackReactionsRequest {
return ProviderAPIPostProviderSlackReactionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackReactOut
func (a *ProviderAPIService) PostProviderSlackReactionsExecute(r ProviderAPIPostProviderSlackReactionsRequest) (*ProviderSlackReactOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackReactOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackReactions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/reactions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerSlackReactIn == nil {
return localVarReturnValue, nil, reportError("providerSlackReactIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerSlackReactIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderSlackSearchRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerSlackSearchIn *ProviderSlackSearchIn
}
func (r ProviderAPIPostProviderSlackSearchRequest) ProviderSlackSearchIn(providerSlackSearchIn ProviderSlackSearchIn) ProviderAPIPostProviderSlackSearchRequest {
r.providerSlackSearchIn = &providerSlackSearchIn
return r
}
func (r ProviderAPIPostProviderSlackSearchRequest) Execute() (*ProviderSlackSearchOut, *http.Response, error) {
return r.ApiService.PostProviderSlackSearchExecute(r)
}
/*
PostProviderSlackSearch Answers a workspace question: POST /v1/provider/slack/search.
Answers a workspace question: POST /v1/provider/slack/search.
Slack's search.messages wants a USER token for a person's own view of a
workspace; a bot token searches what the app can see. Whichever the install
granted, the token custodied for this org is the one sent.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderSlackSearchRequest
*/
func (a *ProviderAPIService) PostProviderSlackSearch(ctx context.Context) ProviderAPIPostProviderSlackSearchRequest {
return ProviderAPIPostProviderSlackSearchRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackSearchOut
func (a *ProviderAPIService) PostProviderSlackSearchExecute(r ProviderAPIPostProviderSlackSearchRequest) (*ProviderSlackSearchOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackSearchOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackSearch")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/search"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerSlackSearchIn == nil {
return localVarReturnValue, nil, reportError("providerSlackSearchIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerSlackSearchIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderTeamsEventsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderTeamsEventsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderTeamsEventsExecute(r)
}
/*
PostProviderTeamsEvents Microsoft Teams Bot Framework webhook
The messaging endpoint for the Teams bot. A message activity is routed to an agent turn and answered proactively through the Bot Connection; anything that is not a message with text is acknowledged and ignored.
Authentication is the Bot Framework's RS256 JWT, verified against its published keys and bound BOTH to this deployment's app id and to the activity's own service URL. The service-URL binding is the part that matters: without it a token valid for one activity could point the outbound reply somewhere else.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderTeamsEventsRequest
*/
func (a *ProviderAPIService) PostProviderTeamsEvents(ctx context.Context) ProviderAPIPostProviderTeamsEventsRequest {
return ProviderAPIPostProviderTeamsEventsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderTeamsEventsExecute(r ProviderAPIPostProviderTeamsEventsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTeamsEvents")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/teams/events"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderTelegramConnectRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderTelegramConnectRequest) Execute() (*ProviderAuthorizeOut, *http.Response, error) {
return r.ApiService.PostProviderTelegramConnectExecute(r)
}
/*
PostProviderTelegramConnect Mints a short, single-use deep-link code bound to the caller's org and returns the t.me link the console navigates to.
Mints a short, single-use deep-link code bound to the caller's
org and returns the t.me link the console navigates to. Org-authed: a caller with
no validated principal is 403 (same gate as the framework connect). The code is
stored as an oauth_nonce (org,telegram); the webhook's /start handler claims it to
bind chat→org. It is short (128-bit hex) so it fits Telegram's 64-char `start`
payload limit.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderTelegramConnectRequest
*/
func (a *ProviderAPIService) PostProviderTelegramConnect(ctx context.Context) ProviderAPIPostProviderTelegramConnectRequest {
return ProviderAPIPostProviderTelegramConnectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderAuthorizeOut
func (a *ProviderAPIService) PostProviderTelegramConnectExecute(r ProviderAPIPostProviderTelegramConnectRequest) (*ProviderAuthorizeOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderAuthorizeOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTelegramConnect")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/telegram/connect"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderTelegramWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderTelegramWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderTelegramWebhookExecute(r)
}
/*
PostProviderTelegramWebhook Telegram Bot API webhook
The update webhook for the Telegram bot. It does two jobs: `/start <code>` or `/connect <code>` binds the chat it was sent from to an org, idempotently; anything else is treated as a possible agent trigger.
What counts as a trigger differs by chat type, and it is easy to get wrong: in a private chat every message is a trigger, while in a group the message must mention the bot or use the `/hanzo` command. Non-triggers and non-message updates are acknowledged and dropped.
Authentication is the secret token Telegram echoes on every update, compared in constant time. A message in a chat that has never been bound is dropped, which is why the bind command exists.
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderTelegramWebhookRequest
*/
func (a *ProviderAPIService) PostProviderTelegramWebhook(ctx context.Context) ProviderAPIPostProviderTelegramWebhookRequest {
return ProviderAPIPostProviderTelegramWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderTelegramWebhookExecute(r ProviderAPIPostProviderTelegramWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTelegramWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/telegram/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPostProviderWhatsappGroupsRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerWhatsappGroupIn *ProviderWhatsappGroupIn
}
func (r ProviderAPIPostProviderWhatsappGroupsRequest) ProviderWhatsappGroupIn(providerWhatsappGroupIn ProviderWhatsappGroupIn) ProviderAPIPostProviderWhatsappGroupsRequest {
r.providerWhatsappGroupIn = &providerWhatsappGroupIn
return r
}
func (r ProviderAPIPostProviderWhatsappGroupsRequest) Execute() (*ProviderWhatsappGroupOut, *http.Response, error) {
return r.ApiService.PostProviderWhatsappGroupsExecute(r)
}
/*
PostProviderWhatsappGroups Creates a group on the org's WhatsApp number and returns its invite link.
Creates a group on the org's WhatsApp number and returns
its invite link.
Org admin, because the group speaks as the org's number and the invite link
admits anyone who holds it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderWhatsappGroupsRequest
*/
func (a *ProviderAPIService) PostProviderWhatsappGroups(ctx context.Context) ProviderAPIPostProviderWhatsappGroupsRequest {
return ProviderAPIPostProviderWhatsappGroupsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderWhatsappGroupOut
func (a *ProviderAPIService) PostProviderWhatsappGroupsExecute(r ProviderAPIPostProviderWhatsappGroupsRequest) (*ProviderWhatsappGroupOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderWhatsappGroupOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderWhatsappGroups")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/whatsapp/groups"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerWhatsappGroupIn == nil {
return localVarReturnValue, nil, reportError("providerWhatsappGroupIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerWhatsappGroupIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPostProviderWhatsappWebhookRequest struct {
ctx context.Context
ApiService *ProviderAPIService
}
func (r ProviderAPIPostProviderWhatsappWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.PostProviderWhatsappWebhookExecute(r)
}
/*
PostProviderWhatsappWebhook WhatsApp Cloud API webhook
One delivery from Meta. Authenticity is the X-Hub-Signature-256 HMAC over the raw body, and it is the whole of it: a message accepted here creates the reply route that authorises this org to answer, so an unsigned delivery would let anyone hand an org a conversation to answer under its own number.
Meta batches (entry × changes × messages) and sends status callbacks — sent/delivered/read — through this same address with no message at all. Those are acknowledged and dropped rather than refused, because a non-2xx is retried with backoff and eventually disables the subscription: the only refusals here are an unconfigured endpoint and a bad signature, which are ours to fix and not Meta's to retry.
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPostProviderWhatsappWebhookRequest
*/
func (a *ProviderAPIService) PostProviderWhatsappWebhook(ctx context.Context) ProviderAPIPostProviderWhatsappWebhookRequest {
return ProviderAPIPostProviderWhatsappWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ProviderAPIService) PostProviderWhatsappWebhookExecute(r ProviderAPIPostProviderWhatsappWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderWhatsappWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/whatsapp/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ProviderAPIPutProviderGithubReposByRepoPagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
repo string
providerGithubPagesUpdateReq *ProviderGithubPagesUpdateReq
}
func (r ProviderAPIPutProviderGithubReposByRepoPagesRequest) ProviderGithubPagesUpdateReq(providerGithubPagesUpdateReq ProviderGithubPagesUpdateReq) ProviderAPIPutProviderGithubReposByRepoPagesRequest {
r.providerGithubPagesUpdateReq = &providerGithubPagesUpdateReq
return r
}
func (r ProviderAPIPutProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesUpdatedOut, *http.Response, error) {
return r.ApiService.PutProviderGithubReposByRepoPagesExecute(r)
}
/*
PutProviderGithubReposByRepoPages Sets or clears the custom domain (cname) and updates HTTPS enforcement, build type, or source.
Sets or clears the custom domain (cname) and updates HTTPS
enforcement, build type, or source. ONLY the provided fields are sent to GitHub,
so an update never resets a setting the caller did not mention.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param repo Repo is the repository, from the :repo path segment.
@return ProviderAPIPutProviderGithubReposByRepoPagesRequest
*/
func (a *ProviderAPIService) PutProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIPutProviderGithubReposByRepoPagesRequest {
return ProviderAPIPutProviderGithubReposByRepoPagesRequest{
ApiService: a,
ctx: ctx,
repo: repo,
}
}
// Execute executes the request
//
// @return ProviderGithubPagesUpdatedOut
func (a *ProviderAPIService) PutProviderGithubReposByRepoPagesExecute(r ProviderAPIPutProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesUpdatedOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderGithubPagesUpdatedOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PutProviderGithubReposByRepoPages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerGithubPagesUpdateReq == nil {
return localVarReturnValue, nil, reportError("providerGithubPagesUpdateReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerGithubPagesUpdateReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ProviderAPIPutProviderSlackMessagesRequest struct {
ctx context.Context
ApiService *ProviderAPIService
providerSlackUpdateMessageIn *ProviderSlackUpdateMessageIn
}
func (r ProviderAPIPutProviderSlackMessagesRequest) ProviderSlackUpdateMessageIn(providerSlackUpdateMessageIn ProviderSlackUpdateMessageIn) ProviderAPIPutProviderSlackMessagesRequest {
r.providerSlackUpdateMessageIn = &providerSlackUpdateMessageIn
return r
}
func (r ProviderAPIPutProviderSlackMessagesRequest) Execute() (*ProviderSlackUpdateMessageOut, *http.Response, error) {
return r.ApiService.PutProviderSlackMessagesExecute(r)
}
/*
PutProviderSlackMessages Rewrites one of this app's messages: PUT /v1/provider/slack/messages.
Rewrites one of this app's messages:
PUT /v1/provider/slack/messages. Slack refuses a message the token did not
post, and that refusal is reported as it arrives.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ProviderAPIPutProviderSlackMessagesRequest
*/
func (a *ProviderAPIService) PutProviderSlackMessages(ctx context.Context) ProviderAPIPutProviderSlackMessagesRequest {
return ProviderAPIPutProviderSlackMessagesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ProviderSlackUpdateMessageOut
func (a *ProviderAPIService) PutProviderSlackMessagesExecute(r ProviderAPIPutProviderSlackMessagesRequest) (*ProviderSlackUpdateMessageOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ProviderSlackUpdateMessageOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PutProviderSlackMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/provider/slack/messages"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.providerSlackUpdateMessageIn == nil {
return localVarReturnValue, nil, reportError("providerSlackUpdateMessageIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.providerSlackUpdateMessageIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}