Files
sdk/api_team.go

5478 lines
200 KiB
Go

/*
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"
"os"
"strings"
)
// TeamAPIService TeamAPI service
type TeamAPIService service
type TeamAPIDeleteTeamAccountCookieRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIDeleteTeamAccountCookieRequest) Execute() (*TeamCookieAck, *http.Response, error) {
return r.ApiService.DeleteTeamAccountCookieExecute(r)
}
/*
DeleteTeamAccountCookie Signs this browser out of team by expiring the HttpOnly account-token cookie the OAuth callback set.
Signs this browser out of team by expiring the HttpOnly
account-token cookie the OAuth callback set. It is the counterpart of the
cookie PUT, it takes nothing — the cookie it clears is named by this service,
never by the caller — and it is unconditional: a caller with no cookie, an
expired one or a forged one all get the same acknowledgement, because clearing
something that is not there is the same outcome as clearing something that is.
It clears ONLY the team session cookie. The IAM access-token cookie the same
callback set is a different credential with a different lifetime and is left
alone, so this is a team sign-out, not a platform one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIDeleteTeamAccountCookieRequest
*/
func (a *TeamAPIService) DeleteTeamAccountCookie(ctx context.Context) TeamAPIDeleteTeamAccountCookieRequest {
return TeamAPIDeleteTeamAccountCookieRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamCookieAck
func (a *TeamAPIService) DeleteTeamAccountCookieExecute(r TeamAPIDeleteTeamAccountCookieRequest) (*TeamCookieAck, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamCookieAck
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamAccountCookie")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account/cookie"
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 TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
account string
space *string
}
// Space is the space uuid holding the channel.
func (r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) Space(space string) TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest {
r.space = &space
return r
}
func (r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteTeamChannelsByIdMembersByAccountExecute(r)
}
/*
DeleteTeamChannelsByIdMembersByAccount Takes one person out of a channel — the caller leaving, when the account is their own.
Takes one person out of a channel — the caller leaving, when the
account is their own. Removing somebody else takes owning the channel or
administering the space. Leaving a channel you are not in, or removing somebody
who is not there, changes nothing. A direct message cannot be left: its people
are what it is. Answers 204.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel, from the path.
@param account Account is the account uuid to remove, from the path. Your own is leaving.
@return TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest
*/
func (a *TeamAPIService) DeleteTeamChannelsByIdMembersByAccount(ctx context.Context, id string, account string) TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest {
return TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest{
ApiService: a,
ctx: ctx,
id: id,
account: account,
}
}
// Execute executes the request
func (a *TeamAPIService) DeleteTeamChannelsByIdMembersByAccountExecute(r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamChannelsByIdMembersByAccount")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}/members/{account}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"account"+"}", url.PathEscape(parameterValueToString(r.account, "account")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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/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 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,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type TeamAPIDeleteTeamDocsByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space is the space uuid holding it.
func (r TeamAPIDeleteTeamDocsByIdRequest) Space(space string) TeamAPIDeleteTeamDocsByIdRequest {
r.space = &space
return r
}
func (r TeamAPIDeleteTeamDocsByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteTeamDocsByIdExecute(r)
}
/*
DeleteTeamDocsById Removes a document with everything nested under it and every comment on any of them — the Team client's own delete, which takes the subtree with it.
Removes a document with everything nested under it and every
comment on any of them — the Team client's own delete, which takes the
subtree with it. Its author, an owner of its teamspace or an admin of the
space may delete it. Answers 204.
The document model has no archived state for a page (only a teamspace can be
archived), so there is nothing softer to offer here than removal.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the document, from the path.
@return TeamAPIDeleteTeamDocsByIdRequest
*/
func (a *TeamAPIService) DeleteTeamDocsById(ctx context.Context, id string) TeamAPIDeleteTeamDocsByIdRequest {
return TeamAPIDeleteTeamDocsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *TeamAPIService) DeleteTeamDocsByIdExecute(r TeamAPIDeleteTeamDocsByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamDocsById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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/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 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,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type TeamAPIDeleteTeamFilesBySpaceByFilenameRequest struct {
ctx context.Context
ApiService *TeamAPIService
space string
filename string
file *string
}
// File is the blob id, and wins over the path segment when both are present.
func (r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) File(file string) TeamAPIDeleteTeamFilesBySpaceByFilenameRequest {
r.file = &file
return r
}
func (r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteTeamFilesBySpaceByFilenameExecute(r)
}
/*
DeleteTeamFilesBySpaceByFilename Removes one blob from a space's file store.
Removes one blob from a space's file store. The caller must
hold a verified session AND be a member of the space; anything else — an
unknown space, another tenant's space, a space the caller is not
in — answers the same 404, so a probe learns nothing about what exists.
It is IDEMPOTENT: deleting a present or an absent blob both answer 204, so a
delete never confirms a blob's existence and a foreign blob id (a physical key
the caller can never name into another tenant's box) is a harmless no-op. A
storage backend that is unavailable fails closed with 502 rather than lying
about success.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param space Space is the space uuid the blob belongs to, from the path.
@param filename Filename is the last path segment, which the front sets to the blob id when it sends no explicit `file`.
@return TeamAPIDeleteTeamFilesBySpaceByFilenameRequest
*/
func (a *TeamAPIService) DeleteTeamFilesBySpaceByFilename(ctx context.Context, space string, filename string) TeamAPIDeleteTeamFilesBySpaceByFilenameRequest {
return TeamAPIDeleteTeamFilesBySpaceByFilenameRequest{
ApiService: a,
ctx: ctx,
space: space,
filename: filename,
}
}
// Execute executes the request
func (a *TeamAPIService) DeleteTeamFilesBySpaceByFilenameExecute(r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamFilesBySpaceByFilename")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/files/{space}/{filename}"
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"filename"+"}", url.PathEscape(parameterValueToString(r.filename, "filename")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.file != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "file", r.file, "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/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 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,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type TeamAPIDeleteTeamMessagesByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space names the space holding it. A message id is unique within a space, not across the org.
func (r TeamAPIDeleteTeamMessagesByIdRequest) Space(space string) TeamAPIDeleteTeamMessagesByIdRequest {
r.space = &space
return r
}
func (r TeamAPIDeleteTeamMessagesByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteTeamMessagesByIdExecute(r)
}
/*
DeleteTeamMessagesById Removes a message, with its replies, reactions, files and the inbox notifications that point at it.
Removes a message, with its replies, reactions, files and the
inbox notifications that point at it. Its author may delete it, and so may an
owner or admin of the space.
Each removal is a platform remove through the Team client's write path, so the
message disappears from every open client live. Answers 204.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message, from the path.
@return TeamAPIDeleteTeamMessagesByIdRequest
*/
func (a *TeamAPIService) DeleteTeamMessagesById(ctx context.Context, id string) TeamAPIDeleteTeamMessagesByIdRequest {
return TeamAPIDeleteTeamMessagesByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *TeamAPIService) DeleteTeamMessagesByIdExecute(r TeamAPIDeleteTeamMessagesByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamMessagesById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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/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 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,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
emoji string
space *string
}
// Space names the space holding the message.
func (r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) Space(space string) TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest {
r.space = &space
return r
}
func (r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.DeleteTeamMessagesByIdReactionsByEmojiExecute(r)
}
/*
DeleteTeamMessagesByIdReactionsByEmoji Takes back the caller's reaction to a message and answers the message with its reactions as they now stand.
Takes back the caller's reaction to a message and answers the message
with its reactions as they now stand. Taking back a reaction the caller never
made changes nothing and is not an error.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message, from the path.
@param emoji Emoji is the reaction, from the path (percent-encoded on the wire).
@return TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest
*/
func (a *TeamAPIService) DeleteTeamMessagesByIdReactionsByEmoji(ctx context.Context, id string, emoji string) TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest {
return TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest{
ApiService: a,
ctx: ctx,
id: id,
emoji: emoji,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) DeleteTeamMessagesByIdReactionsByEmojiExecute(r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamMessagesByIdReactionsByEmoji")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}/reactions/{emoji}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"emoji"+"}", url.PathEscape(parameterValueToString(r.emoji, "emoji")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamAccountAuthByProviderRequest struct {
ctx context.Context
ApiService *TeamAPIService
provider string
}
func (r TeamAPIGetTeamAccountAuthByProviderRequest) Execute() (*http.Response, error) {
return r.ApiService.GetTeamAccountAuthByProviderExecute(r)
}
/*
GetTeamAccountAuthByProvider Start a sign-in at hanzo.id
STARTS the OAuth hop: answers 302 to hanzo.id's authorize endpoint and sets the short-lived HttpOnly state cookie that binds the flow to this browser. NO TOKEN COMES BACK FROM THIS CALL — the session is minted by the callback below, and a client that expects JSON here gets a redirect with no body.
A browser is the intended caller. Anything else must follow the Location AND keep the Set-Cookie, because the callback refuses a flow whose state it cannot match. That cookie carries the random nonce plus the client's navigateUrl, so the round trip needs no second channel, and it lives ten minutes — the whole budget for the hop.
The provider segment only picks a hint: the redirect_uri is ALWAYS the canonical openid callback, the one IAM has registered. Measured end to end, hanzo.id strips that hint today, so /auth/google and /auth/openid land on the same Hanzo sign-in page — the federation shortcut is an upstream fix, not a second endpoint here.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider
@return TeamAPIGetTeamAccountAuthByProviderRequest
*/
func (a *TeamAPIService) GetTeamAccountAuthByProvider(ctx context.Context, provider string) TeamAPIGetTeamAccountAuthByProviderRequest {
return TeamAPIGetTeamAccountAuthByProviderRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
func (a *TeamAPIService) GetTeamAccountAuthByProviderExecute(r TeamAPIGetTeamAccountAuthByProviderRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountAuthByProvider")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account/auth/{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{}
// 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 TeamAPIGetTeamAccountAuthByProviderCallbackRequest struct {
ctx context.Context
ApiService *TeamAPIService
provider string
}
func (r TeamAPIGetTeamAccountAuthByProviderCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetTeamAccountAuthByProviderCallbackExecute(r)
}
/*
GetTeamAccountAuthByProviderCallback Complete a sign-in and hand the browser its session
COMPLETES the OAuth hop: hanzo.id redirects the browser here with ?code and ?state, and the answer is another 302 — back to the client's login route carrying the freshly minted team session token in the query. Never JSON, and never a token in this response's own body.
THE STATE IS CHECKED FIRST, before the code is even looked at: the flow cookie is read and cleared one-shot, and a callback whose ?state does not equal the nonce it held is bounced with error=state_mismatch and NEVER exchanged. That is what makes a forged or replayed callback inert. Only then is the code exchanged server-side — team is a confidential client with a client_secret, so there is no PKCE and the code never passes through the browser's JS.
The tenant is derived from the IAM access token VERIFIED RS256 against the JWKS, the same trust anchor the identity boundary uses; a token whose owner claim is empty fails closed with no login at all. Every org that token proves gets a space ensured, so a member of two orgs is a counted seat in both. The IAM access token is also parked in an HttpOnly cookie for the same-origin agents proxy — page JS never reads it.
EVERY failure is a redirect, not a status: a denied consent, a missing code, a failed exchange, an unreadable userinfo, an unverifiable org and a token-mint failure each bounce to the login page with an ?error code naming the step.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param provider
@return TeamAPIGetTeamAccountAuthByProviderCallbackRequest
*/
func (a *TeamAPIService) GetTeamAccountAuthByProviderCallback(ctx context.Context, provider string) TeamAPIGetTeamAccountAuthByProviderCallbackRequest {
return TeamAPIGetTeamAccountAuthByProviderCallbackRequest{
ApiService: a,
ctx: ctx,
provider: provider,
}
}
// Execute executes the request
func (a *TeamAPIService) GetTeamAccountAuthByProviderCallbackExecute(r TeamAPIGetTeamAccountAuthByProviderCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountAuthByProviderCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account/auth/{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 TeamAPIGetTeamAccountProvidersRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamAccountProvidersRequest) Execute() ([]TeamProviderInfo, *http.Response, error) {
return r.ApiService.GetTeamAccountProvidersExecute(r)
}
/*
GetTeamAccountProviders Returns the identity providers this deployment starts a login with.
Returns the identity providers this deployment starts a login
with. It is always exactly one — hanzo.id. Which identities that provider accepts
(Google, GitHub, passkey, password) is IAM's question, answered on IAM's own
page next to the identity check and the training-data consent that must
precede a first session; listing them here would be a second place holding
that answer, and the two drift the moment IAM gains or drops one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamAccountProvidersRequest
*/
func (a *TeamAPIService) GetTeamAccountProviders(ctx context.Context) TeamAPIGetTeamAccountProvidersRequest {
return TeamAPIGetTeamAccountProvidersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return []TeamProviderInfo
func (a *TeamAPIService) GetTeamAccountProvidersExecute(r TeamAPIGetTeamAccountProvidersRequest) ([]TeamProviderInfo, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue []TeamProviderInfo
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountProviders")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account/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 TeamAPIGetTeamBillingPlanRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamBillingPlanRequest) Execute() (*TeamPlanInfo, *http.Response, error) {
return r.ApiService.GetTeamBillingPlanExecute(r)
}
/*
GetTeamBillingPlan Returns the plan and seat counts for the caller's OWN org, resolved from the VERIFIED team session token — never a client header.
Returns the plan and seat counts for the caller's OWN org, resolved
from the VERIFIED team session token — never a client header. Seats and guests
are the org's distinct active human members (a bot member is not a seat); the
plan comes from the licensing entitlement and is empty when that read is
unavailable, so the page shows an honest dash rather than a fabricated tier. A
caller with no verified session gets 401, and a real seat-read failure is a
502 rather than a false "0 members".
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamBillingPlanRequest
*/
func (a *TeamAPIService) GetTeamBillingPlan(ctx context.Context) TeamAPIGetTeamBillingPlanRequest {
return TeamAPIGetTeamBillingPlanRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamPlanInfo
func (a *TeamAPIService) GetTeamBillingPlanExecute(r TeamAPIGetTeamBillingPlanRequest) (*TeamPlanInfo, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamPlanInfo
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamBillingPlan")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/billing/plan"
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 TeamAPIGetTeamBillingUiRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamBillingUiRequest) Execute() (*os.File, *http.Response, error) {
return r.ApiService.GetTeamBillingUiExecute(r)
}
/*
GetTeamBillingUi Open the wallet page
Serves the usage-and-wallet page the Team front links to — HTML, not JSON. It is a static React build compiled into this binary, so there is no upstream to be down and no build step at request time.
SESSION-GATED: without a verified team session token — bearer, else the HttpOnly account cookie — the caller gets 401 and not one byte of the page, so an anonymous browser meets a refusal rather than a shell that then fails to load anything.
The page is markup only. It reads money SAME-ORIGIN from cloud's own balance and usage endpoints, which pin the org from the IAM cookie the team OAuth callback set — nothing under this path proxies a money read, so there is no second auth mechanism here to get wrong. A deployment whose page was never built answers 503 naming the missing bundle, never a blank 200.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamBillingUiRequest
*/
func (a *TeamAPIService) GetTeamBillingUi(ctx context.Context) TeamAPIGetTeamBillingUiRequest {
return TeamAPIGetTeamBillingUiRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return *os.File
func (a *TeamAPIService) GetTeamBillingUiExecute(r TeamAPIGetTeamBillingUiRequest) (*os.File, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *os.File
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamBillingUi")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/billing/ui"
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{"text/html; charset=utf-8"}
// 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,
}
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 TeamAPIGetTeamChannelsRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamChannelsRequest) Execute() (*TeamTeamChannels, *http.Response, error) {
return r.ApiService.GetTeamChannelsExecute(r)
}
/*
GetTeamChannels Returns the channels the caller may see, with the kind and work facet each carries.
Returns the channels the caller may see, with the kind and work
facet each carries.
A signed-in TEAM MEMBER reads every channel of every space they are in that is
open to them: public channels, and the private channels and direct messages
that name them. An APPLICATION of the org (its own machine credential) reads
the public channels of the org's spaces and nothing that belongs to
particular people. Anybody else without a team session is 401.
It reads the SAME channel documents the transactor serves, so a channel opened
in the Team client appears here with no sync, and a facet written here is read
by anything holding the document.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamChannelsRequest
*/
func (a *TeamAPIService) GetTeamChannels(ctx context.Context) TeamAPIGetTeamChannelsRequest {
return TeamAPIGetTeamChannelsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamChannels
func (a *TeamAPIService) GetTeamChannelsExecute(r TeamAPIGetTeamChannelsRequest) (*TeamTeamChannels, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannels
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannels")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels"
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 TeamAPIGetTeamChannelsByIdMembersRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space names the space holding the channel, and is required for the reason the bind op requires it: a channel id is unique within a space and not across the org, so searching every space for a match would make the answer depend on iteration order.
func (r TeamAPIGetTeamChannelsByIdMembersRequest) Space(space string) TeamAPIGetTeamChannelsByIdMembersRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamChannelsByIdMembersRequest) Execute() (*TeamTeamChannelMembers, *http.Response, error) {
return r.ApiService.GetTeamChannelsByIdMembersExecute(r)
}
/*
GetTeamChannelsByIdMembers Returns the people and agents in one channel, as the roster describes them.
Returns the people and agents in one channel, as the roster
describes them. The caller must be able to see the channel.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel, from the path. The URL is the authority.
@return TeamAPIGetTeamChannelsByIdMembersRequest
*/
func (a *TeamAPIService) GetTeamChannelsByIdMembers(ctx context.Context, id string) TeamAPIGetTeamChannelsByIdMembersRequest {
return TeamAPIGetTeamChannelsByIdMembersRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamChannelMembers
func (a *TeamAPIService) GetTeamChannelsByIdMembersExecute(r TeamAPIGetTeamChannelsByIdMembersRequest) (*TeamTeamChannelMembers, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannelMembers
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannelsByIdMembers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}/members"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamChannelsByIdMessagesRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space names the space holding the channel, and is required for the reason the bind op requires it: a channel id is unique within a space and not across the org, so searching every space for a match would make the answer depend on iteration order.
func (r TeamAPIGetTeamChannelsByIdMessagesRequest) Space(space string) TeamAPIGetTeamChannelsByIdMessagesRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamChannelsByIdMessagesRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
return r.ApiService.GetTeamChannelsByIdMessagesExecute(r)
}
/*
GetTeamChannelsByIdMessages Returns the tail of one channel's conversation, oldest first, each message with its reactions, files and thread count.
Returns the tail of one channel's conversation, oldest first, each
message with its reactions, files and thread count.
It reads the SAME message documents the transactor serves, so a message typed
in the Team client is here with no sync. A team member reads any channel they
may see; an application of the org reads public channels only; anybody else
without a team session is 401. A channel the caller may not read answers 404
rather than 403, so a probe learns nothing about what exists.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel, from the path. The URL is the authority.
@return TeamAPIGetTeamChannelsByIdMessagesRequest
*/
func (a *TeamAPIService) GetTeamChannelsByIdMessages(ctx context.Context, id string) TeamAPIGetTeamChannelsByIdMessagesRequest {
return TeamAPIGetTeamChannelsByIdMessagesRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessages
func (a *TeamAPIService) GetTeamChannelsByIdMessagesExecute(r TeamAPIGetTeamChannelsByIdMessagesRequest) (*TeamTeamMessages, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessages
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannelsByIdMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}/messages"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamCollaboratorRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamCollaboratorRequest) Execute() (*http.Response, error) {
return r.ApiService.GetTeamCollaboratorExecute(r)
}
/*
GetTeamCollaborator Open the live collaborative-editing socket
Upgrades to the hocuspocus WebSocket the Team editor syncs its Y.js documents over: binary frames of document name, message type and payload, with ONE socket multiplexing every document a tab has open. The server is a relay and an ordered update log, not a CRDT engine — it replays the log to each joining peer and broadcasts every update to the rest, which converges because Y.js updates are commutative and idempotent. There is no body; the response is a protocol upgrade.
BOTH LANES SHARE ONE ROOT. The client derives them from one configured URL — this socket at its root, the markup-snapshot RPC one segment in — so pointing the editor at this service is one value, and the two lanes cannot drift apart.
AUTH IS IN-BAND, PER DOCUMENT, NOT ON THE UPGRADE. The handshake gates only on browser Origin (403 outside the team surfaces; no Origin at all is admitted, which is what a non-browser sends), and then the first frame for a document must be an Auth message carrying the same session or space token every other team route verifies — a browser WebSocket cannot set an Authorization header, which is why the token rides inside the protocol. Anything else on an unauthenticated document is answered with one permission denial and nothing further.
Every document is authorized on its own: the document's space must be the token's space when the token pins one, and the caller must be a member of it. A mismatch, an unknown space and a non-member deny alike with "document not found". Rooms are keyed by org and space and the persisted log's key embeds both, so a foreign document id can neither join a room nor read a blob.
The server pings every twenty seconds and drops a socket silent for sixty, so a backgrounded tab — whose JS timers are throttled but whose network stack still auto-pongs — stays connected instead of dying into a reconnect loop.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamCollaboratorRequest
*/
func (a *TeamAPIService) GetTeamCollaborator(ctx context.Context) TeamAPIGetTeamCollaboratorRequest {
return TeamAPIGetTeamCollaboratorRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *TeamAPIService) GetTeamCollaboratorExecute(r TeamAPIGetTeamCollaboratorRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamCollaborator")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/collaborator"
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 TeamAPIGetTeamDocsRequest struct {
ctx context.Context
ApiService *TeamAPIService
space *string
teamspace *string
parent *string
}
// Space is the space uuid. Optional for a caller in exactly one space.
func (r TeamAPIGetTeamDocsRequest) Space(space string) TeamAPIGetTeamDocsRequest {
r.space = &space
return r
}
// Teamspace narrows the answer to one teamspace.
func (r TeamAPIGetTeamDocsRequest) Teamspace(teamspace string) TeamAPIGetTeamDocsRequest {
r.teamspace = &teamspace
return r
}
// Parent narrows the answer to one document's children.
func (r TeamAPIGetTeamDocsRequest) Parent(parent string) TeamAPIGetTeamDocsRequest {
r.parent = &parent
return r
}
func (r TeamAPIGetTeamDocsRequest) Execute() (*TeamTeamDocs, *http.Response, error) {
return r.ApiService.GetTeamDocsExecute(r)
}
/*
GetTeamDocs Returns the documents of a space the caller may see, with the teamspaces they are grouped in.
Returns the documents of a space the caller may see, with the
teamspaces they are grouped in.
These are the Team client's own document rows, so a page created there is
here with no sync. Each carries the `collaborator` id its body opens with on
the /v1/team/collaborator socket. A private teamspace's documents are listed
only for its members.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamDocsRequest
*/
func (a *TeamAPIService) GetTeamDocs(ctx context.Context) TeamAPIGetTeamDocsRequest {
return TeamAPIGetTeamDocsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamDocs
func (a *TeamAPIService) GetTeamDocsExecute(r TeamAPIGetTeamDocsRequest) (*TeamTeamDocs, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamDocs
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
}
if r.teamspace != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "teamspace", r.teamspace, "form", "")
}
if r.parent != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "parent", r.parent, "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 TeamAPIGetTeamDocsByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space is the space uuid holding it.
func (r TeamAPIGetTeamDocsByIdRequest) Space(space string) TeamAPIGetTeamDocsByIdRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamDocsByIdRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
return r.ApiService.GetTeamDocsByIdExecute(r)
}
/*
GetTeamDocsById Returns one document the caller may see.
Returns one document the caller may see.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the document, from the path.
@return TeamAPIGetTeamDocsByIdRequest
*/
func (a *TeamAPIService) GetTeamDocsById(ctx context.Context, id string) TeamAPIGetTeamDocsByIdRequest {
return TeamAPIGetTeamDocsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamDoc
func (a *TeamAPIService) GetTeamDocsByIdExecute(r TeamAPIGetTeamDocsByIdRequest) (*TeamTeamDoc, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamDoc
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamDocsByIdCommentsRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space is the space uuid holding it.
func (r TeamAPIGetTeamDocsByIdCommentsRequest) Space(space string) TeamAPIGetTeamDocsByIdCommentsRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamDocsByIdCommentsRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
return r.ApiService.GetTeamDocsByIdCommentsExecute(r)
}
/*
GetTeamDocsByIdComments Returns the comments on a document, oldest first — the same message shape a channel's conversation answers.
Returns the comments on a document, oldest first — the same
message shape a channel's conversation answers.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the document, from the path.
@return TeamAPIGetTeamDocsByIdCommentsRequest
*/
func (a *TeamAPIService) GetTeamDocsByIdComments(ctx context.Context, id string) TeamAPIGetTeamDocsByIdCommentsRequest {
return TeamAPIGetTeamDocsByIdCommentsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessages
func (a *TeamAPIService) GetTeamDocsByIdCommentsExecute(r TeamAPIGetTeamDocsByIdCommentsRequest) (*TeamTeamMessages, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessages
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocsByIdComments")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs/{id}/comments"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamEventsRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIGetTeamEventsRequest) Execute() (*os.File, *http.Response, error) {
return r.ApiService.GetTeamEventsExecute(r)
}
/*
GetTeamEvents Stream live changes to what the caller may see, as Server-Sent Events
Holds one text/event-stream open per caller and pushes each change as it is written — by the Team client, a typed op or an agent — filtered to the channels, documents and inbox the caller may see under the same rule the ops apply. Authenticate with `Authorization: Bearer` (a fetch-based SSE reader; a browser EventSource cannot set it). `?space=` narrows the stream to one space; without it the stream covers every space the caller is a member of at connect.
Each frame is `event: <name>` and a JSON `data:` line carrying `space` and one of:
- `message.created`, `message.updated` — `message`, the message as the message ops answer it (a channel message, a thread reply or a document comment; a count or reaction change is an update);
- `message.deleted` — `id`, and `channel`/`doc`/`thread` where known;
- `reaction.changed` — `message`, with its reactions as they now stand;
- `channel.changed` — `channel`, as the channel listing answers it, sent to those who can see it after the change (somebody removed from a private channel is not told; the channel list is the truth);
- `doc.changed` — `doc`, as the document ops answer it (`removed: true` and `id` when deleted); body edits happen on the collaborator socket and are not streamed here;
- `inbox.created`, `inbox.updated` — `item`, one of the caller's own notifications.
A `: ping` comment is written every 25 seconds. There is no resume: the server keeps no event sequence, so frames carry no `id` and Last-Event-ID is ignored; on reconnect, re-read the ops. A stream that falls too far behind is closed rather than allowed to slow a writer, and so is one whose caller is no longer a member of the space an event is in. 401 without a verified team credential; 404 for a named space the caller is not in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamEventsRequest
*/
func (a *TeamAPIService) GetTeamEvents(ctx context.Context) TeamAPIGetTeamEventsRequest {
return TeamAPIGetTeamEventsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return *os.File
func (a *TeamAPIService) GetTeamEventsExecute(r TeamAPIGetTeamEventsRequest) (*os.File, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *os.File
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamEvents")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/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{"text/event-stream"}
// 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,
}
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 TeamAPIGetTeamFilesBySpaceByFilenameRequest struct {
ctx context.Context
ApiService *TeamAPIService
space string
filename string
}
func (r TeamAPIGetTeamFilesBySpaceByFilenameRequest) Execute() (*os.File, *http.Response, error) {
return r.ApiService.GetTeamFilesBySpaceByFilenameExecute(r)
}
/*
GetTeamFilesBySpaceByFilename Download a space file
Streams one blob's raw BYTES back — this is the read side of the space file store, not a JSON envelope around it.
THE BLOB IS NAMED BY THE `file` QUERY PARAMETER, NOT BY :filename. The path segment is only the name a browser saves the download under; a request without ?file= is a 400 no matter what the path says.
The Content-Type is derived from the STORED BYTES, never from the name: only png, jpeg, gif and webp, recognized by their magic bytes, are served inline under their true type, and everything else is served inert as application/octet-stream with an attachment disposition. Every response carries nosniff, so a file uploaded under an .svg or .html name cannot be talked into executing in a viewer's origin. Blobs are immutable, so a hit caches privately for a year.
Same gate as the upload: verified token, membership of the space. A genuine miss, another tenant's space, a space the caller is not in, and a blob id belonging to a different space are ONE answer — 404 — because the physical key is org- and space-scoped and a foreign id is simply a key that does not exist. An unavailable backend is a 502, never an empty 200.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param space
@param filename
@return TeamAPIGetTeamFilesBySpaceByFilenameRequest
*/
func (a *TeamAPIService) GetTeamFilesBySpaceByFilename(ctx context.Context, space string, filename string) TeamAPIGetTeamFilesBySpaceByFilenameRequest {
return TeamAPIGetTeamFilesBySpaceByFilenameRequest{
ApiService: a,
ctx: ctx,
space: space,
filename: filename,
}
}
// Execute executes the request
//
// @return *os.File
func (a *TeamAPIService) GetTeamFilesBySpaceByFilenameExecute(r TeamAPIGetTeamFilesBySpaceByFilenameRequest) (*os.File, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *os.File
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamFilesBySpaceByFilename")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/files/{space}/{filename}"
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"filename"+"}", url.PathEscape(parameterValueToString(r.filename, "filename")), -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/octet-stream"}
// 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,
}
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 TeamAPIGetTeamInboxRequest struct {
ctx context.Context
ApiService *TeamAPIService
space *string
archived *bool
}
// Space is the space uuid. Optional for a caller in exactly one space.
func (r TeamAPIGetTeamInboxRequest) Space(space string) TeamAPIGetTeamInboxRequest {
r.space = &space
return r
}
// Archived lists the archived notifications instead of the live ones.
func (r TeamAPIGetTeamInboxRequest) Archived(archived bool) TeamAPIGetTeamInboxRequest {
r.archived = &archived
return r
}
func (r TeamAPIGetTeamInboxRequest) Execute() (*TeamTeamInbox, *http.Response, error) {
return r.ApiService.GetTeamInboxExecute(r)
}
/*
GetTeamInbox Returns the caller's notifications, newest first, each with the channel or document it is about and the message that caused it.
Returns the caller's notifications, newest first, each with the
channel or document it is about and the message that caused it.
These are the rows the Team client's Inbox reads, so a notification cleared
there is cleared here. Only the caller's own notifications are ever listed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamInboxRequest
*/
func (a *TeamAPIService) GetTeamInbox(ctx context.Context) TeamAPIGetTeamInboxRequest {
return TeamAPIGetTeamInboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamInbox
func (a *TeamAPIService) GetTeamInboxExecute(r TeamAPIGetTeamInboxRequest) (*TeamTeamInbox, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamInbox
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamInbox")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/inbox"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
}
if r.archived != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "archived", r.archived, "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 TeamAPIGetTeamMembersRequest struct {
ctx context.Context
ApiService *TeamAPIService
space *string
}
// Space is the space uuid. Optional for a caller in exactly one space.
func (r TeamAPIGetTeamMembersRequest) Space(space string) TeamAPIGetTeamMembersRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamMembersRequest) Execute() (*TeamTeamMembers, *http.Response, error) {
return r.ApiService.GetTeamMembersExecute(r)
}
/*
GetTeamMembers Returns the people and agents in a space, with the name, avatar, role and presence a client draws them with.
Returns the people and agents in a space, with the name, avatar,
role and presence a client draws them with.
People come from IAM, the membership authority; agents from the org's agent
registry; avatars from the Person documents the Team client edits. An IAM that
does not answer is a 502 rather than an empty roster, and an agent registry
that does not answer is named in `degraded` beside the people who did load.
The caller must be a member of the space.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamMembersRequest
*/
func (a *TeamAPIService) GetTeamMembers(ctx context.Context) TeamAPIGetTeamMembersRequest {
return TeamAPIGetTeamMembersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamMembers
func (a *TeamAPIService) GetTeamMembersExecute(r TeamAPIGetTeamMembersRequest) (*TeamTeamMembers, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMembers
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamMembers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/members"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamMessagesByIdRepliesRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
space *string
}
// Space names the space holding it. A message id is unique within a space, not across the org.
func (r TeamAPIGetTeamMessagesByIdRepliesRequest) Space(space string) TeamAPIGetTeamMessagesByIdRepliesRequest {
r.space = &space
return r
}
func (r TeamAPIGetTeamMessagesByIdRepliesRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
return r.ApiService.GetTeamMessagesByIdRepliesExecute(r)
}
/*
GetTeamMessagesByIdReplies Returns a message's thread, oldest first, each reply with its reactions and files.
Returns a message's thread, oldest first, each reply with its
reactions and files.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message, from the path.
@return TeamAPIGetTeamMessagesByIdRepliesRequest
*/
func (a *TeamAPIService) GetTeamMessagesByIdReplies(ctx context.Context, id string) TeamAPIGetTeamMessagesByIdRepliesRequest {
return TeamAPIGetTeamMessagesByIdRepliesRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessages
func (a *TeamAPIService) GetTeamMessagesByIdRepliesExecute(r TeamAPIGetTeamMessagesByIdRepliesRequest) (*TeamTeamMessages, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessages
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamMessagesByIdReplies")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}/replies"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "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 TeamAPIGetTeamPublicRequest struct {
ctx context.Context
ApiService *TeamAPIService
q *string
org *string
limit *int64
}
// Q matches a channel&#39;s name or its topic.
func (r TeamAPIGetTeamPublicRequest) Q(q string) TeamAPIGetTeamPublicRequest {
r.q = &q
return r
}
// Org narrows to one org&#39;s published channels.
func (r TeamAPIGetTeamPublicRequest) Org(org string) TeamAPIGetTeamPublicRequest {
r.org = &org
return r
}
// Limit caps the page, 50 when unstated and 200 at most. An unparseable value reads as unstated rather than as zero — zero pages is not an answer anybody asked for.
func (r TeamAPIGetTeamPublicRequest) Limit(limit int64) TeamAPIGetTeamPublicRequest {
r.limit = &limit
return r
}
func (r TeamAPIGetTeamPublicRequest) Execute() (*TeamPublicChannels, *http.Response, error) {
return r.ApiService.GetTeamPublicExecute(r)
}
/*
GetTeamPublic Lists the channels orgs have published, across every org.
Lists the channels orgs have published, across every org.
It is NOT part of GET /channels, and the separation is the point: that address
answers the CALLER'S channels, so folding these in would put strangers' channels
in somebody's own sidebar.
It reads the directory and never a tenant's store. Every field it can answer
with is one an org published by making a channel public, so there is nothing here
to scope by org — a directory only its own org can read is not a directory.
An authenticated principal is still required, because an anonymous crawler is
not who this is for.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamPublicRequest
*/
func (a *TeamAPIService) GetTeamPublic(ctx context.Context) TeamAPIGetTeamPublicRequest {
return TeamAPIGetTeamPublicRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamPublicChannels
func (a *TeamAPIService) GetTeamPublicExecute(r TeamAPIGetTeamPublicRequest) (*TeamPublicChannels, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamPublicChannels
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamPublic")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/public"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.q != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
}
if r.org != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "org", r.org, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "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 TeamAPIGetTeamTransactorByTokenRequest struct {
ctx context.Context
ApiService *TeamAPIService
token string
}
func (r TeamAPIGetTeamTransactorByTokenRequest) Execute() (*http.Response, error) {
return r.ApiService.GetTeamTransactorByTokenExecute(r)
}
/*
GetTeamTransactorByToken Open the space data-plane socket
Upgrades to the WebSocket the Team client runs an entire space over: every frame is a ZAP envelope wrapping one JSON-RPC message — findAll/findOne reads against the space's documents, tx writes that broadcast to the other live sessions, hello negotiating JSON rather than msgpack. The response is a protocol upgrade, so there is no body to read.
THE PATH SEGMENT IS THE CREDENTIAL. It is the space token selectWorkspace minted — bearer-equivalent, and sitting in a URL that proxies and access logs record, which is exactly why it expires in twelve hours and is re-minted on demand rather than being long-lived like the session token. It is decoded and verified (signature and expiry) BEFORE the upgrade, so a bad one is a 401 and never a socket that is accepted and then dropped, and it must carry both an account and a space claim. Nothing ambient authorizes this socket: a WebSocket is exempt from CORS, so a cookie-borne credential would make the Origin check the only access control on the whole data plane.
The tenant is the token's SIGNED org claim and it keys every store path, so no header can name another space's data. The upgrade ALSO refuses a browser Origin outside the team surfaces with 403 — otherwise any page could open an authenticated socket with a token it lured out of a logged-in browser — while a request with no Origin at all is admitted, because that is what a non-browser client sends.
On connect the space's system spaces are seeded once and the roster is reconciled every time, so the org's human members and its bots are present as space people without a separate sync call.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param token
@return TeamAPIGetTeamTransactorByTokenRequest
*/
func (a *TeamAPIService) GetTeamTransactorByToken(ctx context.Context, token string) TeamAPIGetTeamTransactorByTokenRequest {
return TeamAPIGetTeamTransactorByTokenRequest{
ApiService: a,
ctx: ctx,
token: token,
}
}
// Execute executes the request
func (a *TeamAPIService) GetTeamTransactorByTokenExecute(r TeamAPIGetTeamTransactorByTokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamTransactorByToken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/transactor/{token}"
localVarPath = strings.Replace(localVarPath, "{"+"token"+"}", url.PathEscape(parameterValueToString(r.token, "token")), -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 TeamAPIGetTeamTransactorStatisticsRequest struct {
ctx context.Context
ApiService *TeamAPIService
token *string
}
// Token is the space token minted by selectWorkspace.
func (r TeamAPIGetTeamTransactorStatisticsRequest) Token(token string) TeamAPIGetTeamTransactorStatisticsRequest {
r.token = &token
return r
}
func (r TeamAPIGetTeamTransactorStatisticsRequest) Execute() (*TeamStatsOut, *http.Response, error) {
return r.ApiService.GetTeamTransactorStatisticsExecute(r)
}
/*
GetTeamTransactorStatistics Returns the transactor's live sessions for the space the caller's credential names — the endpoint the front's space switcher and server panel poll on the transactor base.
Returns the transactor's live sessions for the space the caller's
credential names — the endpoint the front's space switcher and server panel
poll on the transactor base. `token` carries the same two lanes the socket's path
segment does: a space UUID names the space and is authorized against the
membership rows, an HS256 space token names it in its signed claims.
activeSessions carries ONLY that one space, never another tenant's sessions.
An unverifiable credential, or one the caller is no member under, is 401.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIGetTeamTransactorStatisticsRequest
*/
func (a *TeamAPIService) GetTeamTransactorStatistics(ctx context.Context) TeamAPIGetTeamTransactorStatisticsRequest {
return TeamAPIGetTeamTransactorStatisticsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamStatsOut
func (a *TeamAPIService) GetTeamTransactorStatisticsExecute(r TeamAPIGetTeamTransactorStatisticsRequest) (*TeamStatsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamStatsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamTransactorStatistics")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/transactor/statistics"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.token != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "token", r.token, "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 TeamAPIPatchTeamChannelsByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamChannelEdit *TeamTeamChannelEdit
}
func (r TeamAPIPatchTeamChannelsByIdRequest) TeamTeamChannelEdit(teamTeamChannelEdit TeamTeamChannelEdit) TeamAPIPatchTeamChannelsByIdRequest {
r.teamTeamChannelEdit = &teamTeamChannelEdit
return r
}
func (r TeamAPIPatchTeamChannelsByIdRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
return r.ApiService.PatchTeamChannelsByIdExecute(r)
}
/*
PatchTeamChannelsById Renames a channel, sets its topic, or archives or reopens it, and answers the channel as it now stands.
Renames a channel, sets its topic, or archives or reopens it, and
answers the channel as it now stands.
Its owners and the space's admins may edit a channel; a channel nobody owns — one
opened by an integration — may be edited by anyone in it, and a direct
message by either person in it. Archiving withdraws a public channel from the
cross-org directory in the same write; reopening lists it again.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel, from the path.
@return TeamAPIPatchTeamChannelsByIdRequest
*/
func (a *TeamAPIService) PatchTeamChannelsById(ctx context.Context, id string) TeamAPIPatchTeamChannelsByIdRequest {
return TeamAPIPatchTeamChannelsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamChannelOne
func (a *TeamAPIService) PatchTeamChannelsByIdExecute(r TeamAPIPatchTeamChannelsByIdRequest) (*TeamTeamChannelOne, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPatch
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannelOne
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamChannelsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamChannelEdit == nil {
return localVarReturnValue, nil, reportError("teamTeamChannelEdit 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.teamTeamChannelEdit
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 TeamAPIPatchTeamDocsByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamDocEdit *TeamTeamDocEdit
}
func (r TeamAPIPatchTeamDocsByIdRequest) TeamTeamDocEdit(teamTeamDocEdit TeamTeamDocEdit) TeamAPIPatchTeamDocsByIdRequest {
r.teamTeamDocEdit = &teamTeamDocEdit
return r
}
func (r TeamAPIPatchTeamDocsByIdRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
return r.ApiService.PatchTeamDocsByIdExecute(r)
}
/*
PatchTeamDocsById Renames a document or moves it — under another document, to the top of its teamspace, or to another teamspace with everything nested under it.
Renames a document or moves it — under another document, to the top
of its teamspace, or to another teamspace with everything nested under it.
Anyone who can write the teamspace may rename or move a page, as in the Team
client. A move goes after its new siblings, and a document cannot be moved
under itself or under one of its own descendants.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the document, from the path.
@return TeamAPIPatchTeamDocsByIdRequest
*/
func (a *TeamAPIService) PatchTeamDocsById(ctx context.Context, id string) TeamAPIPatchTeamDocsByIdRequest {
return TeamAPIPatchTeamDocsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamDoc
func (a *TeamAPIService) PatchTeamDocsByIdExecute(r TeamAPIPatchTeamDocsByIdRequest) (*TeamTeamDoc, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPatch
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamDoc
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamDocsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamDocEdit == nil {
return localVarReturnValue, nil, reportError("teamTeamDocEdit 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.teamTeamDocEdit
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 TeamAPIPatchTeamMessagesByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamMessageEdit *TeamTeamMessageEdit
}
func (r TeamAPIPatchTeamMessagesByIdRequest) TeamTeamMessageEdit(teamTeamMessageEdit TeamTeamMessageEdit) TeamAPIPatchTeamMessagesByIdRequest {
r.teamTeamMessageEdit = &teamTeamMessageEdit
return r
}
func (r TeamAPIPatchTeamMessagesByIdRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.PatchTeamMessagesByIdExecute(r)
}
/*
PatchTeamMessagesById Rewrites what a message says.
Rewrites what a message says. Only its author may edit it.
The edit is an ordinary update of the message document through the Team
client's own write path, stamped with editedOn, so an open client shows the
new text and the "edited" mark live. Somebody the new text mentions for the
first time is notified.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message, from the path.
@return TeamAPIPatchTeamMessagesByIdRequest
*/
func (a *TeamAPIService) PatchTeamMessagesById(ctx context.Context, id string) TeamAPIPatchTeamMessagesByIdRequest {
return TeamAPIPatchTeamMessagesByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) PatchTeamMessagesByIdExecute(r TeamAPIPatchTeamMessagesByIdRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPatch
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamMessagesById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamMessageEdit == nil {
return localVarReturnValue, nil, reportError("teamTeamMessageEdit 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.teamTeamMessageEdit
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 TeamAPIPostTeamAccountRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIPostTeamAccountRequest) Execute() (*http.Response, error) {
return r.ApiService.PostTeamAccountExecute(r)
}
/*
PostTeamAccount Read the caller's account and switch space
The account control plane the Team client speaks: one POST carries a `method` verb and its `params`, and answers {"result": …}. The verbs are the session's own reads and the space switch — getLoginInfoByToken, getUserWorkspaces, selectWorkspace, getWorkspaceInfo, getMemberships, getPerson, getRegionInfo, isReadOnlyGuest — plus sendInvite, which adds a member to a space and is refused for a caller who is not its owner or admin.
A REFUSAL IS HTTP 200 carrying {"error": {severity, code, params}} — the platform Status the client translates — not a 4xx. An unreadable body, an unauthorized session and an unknown verb all arrive that way, so a caller that reads only the status code reads every failure here as a success.
NO CREDENTIAL IS EVER HANDLED HERE. login, signUp, the OTP verbs, password change and reset, join and the guest-token exchange each answer Unauthorized with "sign in at hanzo.id" — a stated policy, not an unknown method, so the refusal is a fact a test can pin. Sessions come from the OAuth pair under /account/auth.
Auth is the team session token: Authorization: Bearer, else the HttpOnly account-token cookie. The tenant is that token's SIGNED org claim, never a header, and selectWorkspace resolves only among the orgs the token proves membership of. It also demands an explicit workspaceUrl — it never falls back to a first space, and a slug that resolves in two of the caller's orgs answers Ambiguous rather than picking one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPostTeamAccountRequest
*/
func (a *TeamAPIService) PostTeamAccount(ctx context.Context) TeamAPIPostTeamAccountRequest {
return TeamAPIPostTeamAccountRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *TeamAPIService) PostTeamAccountExecute(r TeamAPIPostTeamAccountRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamAccount")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account"
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 TeamAPIPostTeamChannelsRequest struct {
ctx context.Context
ApiService *TeamAPIService
teamTeamChannelNew *TeamTeamChannelNew
}
func (r TeamAPIPostTeamChannelsRequest) TeamTeamChannelNew(teamTeamChannelNew TeamTeamChannelNew) TeamAPIPostTeamChannelsRequest {
r.teamTeamChannelNew = &teamTeamChannelNew
return r
}
func (r TeamAPIPostTeamChannelsRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
return r.ApiService.PostTeamChannelsExecute(r)
}
/*
PostTeamChannels Opens a named channel and answers it as the store now holds it.
Opens a named channel and answers it as the store now holds it.
It writes through the SAME applyTx path the Team client uses, so a channel opened
here is broadcast to every live client of the space and appears in an open
sidebar without a reload — the same property listChannels rests on, read from the
write side.
A SIGNED-IN TEAM MEMBER opens it as themselves: they are its first member and
its owner, every other member named must be somebody the space knows (a person
in it, or one of the org's agents), and a guest may not open channels at all. An
application of the org opens it as the org, with exactly the members it names.
Anybody else without a team session is 401.
TWO TRANSACTIONS, NOT ONE, when the request states a facet. The document and
its work update are separate writes in this model (bindChannel writes only the second),
and composing them here rather than inventing a combined tx keeps one write
path for each. A create that lands and a facet that does not is visible as a
channel with default intent, which is the honest partial state.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPostTeamChannelsRequest
*/
func (a *TeamAPIService) PostTeamChannels(ctx context.Context) TeamAPIPostTeamChannelsRequest {
return TeamAPIPostTeamChannelsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamChannelOne
func (a *TeamAPIService) PostTeamChannelsExecute(r TeamAPIPostTeamChannelsRequest) (*TeamTeamChannelOne, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannelOne
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannels")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamChannelNew == nil {
return localVarReturnValue, nil, reportError("teamTeamChannelNew 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.teamTeamChannelNew
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 TeamAPIPostTeamChannelsByIdMembersRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamChannelJoin *TeamTeamChannelJoin
}
func (r TeamAPIPostTeamChannelsByIdMembersRequest) TeamTeamChannelJoin(teamTeamChannelJoin TeamTeamChannelJoin) TeamAPIPostTeamChannelsByIdMembersRequest {
r.teamTeamChannelJoin = &teamTeamChannelJoin
return r
}
func (r TeamAPIPostTeamChannelsByIdMembersRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
return r.ApiService.PostTeamChannelsByIdMembersExecute(r)
}
/*
PostTeamChannelsByIdMembers Adds people to a channel and answers the channel as it now stands.
Adds people to a channel and answers the channel as it now stands.
Anyone in the space except a guest may join a public channel by naming
themselves. Adding somebody else takes being in the channel already (or
administering the space, for a channel they can see). A direct message's people
are what it is, so none can be added — open another one. Everyone added must
be a member of the space or one of the org's agents; an agent added to a channel
answers when it is @-mentioned there.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel, from the path.
@return TeamAPIPostTeamChannelsByIdMembersRequest
*/
func (a *TeamAPIService) PostTeamChannelsByIdMembers(ctx context.Context, id string) TeamAPIPostTeamChannelsByIdMembersRequest {
return TeamAPIPostTeamChannelsByIdMembersRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamChannelOne
func (a *TeamAPIService) PostTeamChannelsByIdMembersExecute(r TeamAPIPostTeamChannelsByIdMembersRequest) (*TeamTeamChannelOne, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannelOne
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannelsByIdMembers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}/members"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamChannelJoin == nil {
return localVarReturnValue, nil, reportError("teamTeamChannelJoin 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.teamTeamChannelJoin
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 TeamAPIPostTeamChannelsByIdMessagesRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamMessageWrite *TeamTeamMessageWrite
}
func (r TeamAPIPostTeamChannelsByIdMessagesRequest) TeamTeamMessageWrite(teamTeamMessageWrite TeamTeamMessageWrite) TeamAPIPostTeamChannelsByIdMessagesRequest {
r.teamTeamMessageWrite = &teamTeamMessageWrite
return r
}
func (r TeamAPIPostTeamChannelsByIdMessagesRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.PostTeamChannelsByIdMessagesExecute(r)
}
/*
PostTeamChannelsByIdMessages Says one thing in a channel, as the caller.
Says one thing in a channel, as the caller.
The write goes through the SAME applyTx path the Team client's own messages
take and is broadcast to every connected client of the space, so a message
sent here appears live in an open channel rather than on the next reload. It
answers the message as the store now HOLDS it.
`<@account-uuid>` in the text is stored as the platform's mention, so the
person is notified in their inbox. Mentioning one of the org's agents — or
writing in a direct message with one — wakes it: it runs as itself, on behalf
of the caller, and posts its answer into the same channel. The caller must be
able to see the channel, and an archived channel refuses new messages (409).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel to say it in, from the path.
@return TeamAPIPostTeamChannelsByIdMessagesRequest
*/
func (a *TeamAPIService) PostTeamChannelsByIdMessages(ctx context.Context, id string) TeamAPIPostTeamChannelsByIdMessagesRequest {
return TeamAPIPostTeamChannelsByIdMessagesRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) PostTeamChannelsByIdMessagesExecute(r TeamAPIPostTeamChannelsByIdMessagesRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannelsByIdMessages")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}/messages"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamMessageWrite == nil {
return localVarReturnValue, nil, reportError("teamTeamMessageWrite 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.teamTeamMessageWrite
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 TeamAPIPostTeamCollaboratorRpcByDocumentidRequest struct {
ctx context.Context
ApiService *TeamAPIService
documentId string
teamCollabRequest *TeamCollabRequest
}
func (r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) TeamCollabRequest(teamCollabRequest TeamCollabRequest) TeamAPIPostTeamCollaboratorRpcByDocumentidRequest {
r.teamCollabRequest = &teamCollabRequest
return r
}
func (r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) Execute() (*TeamCollabResult, *http.Response, error) {
return r.ApiService.PostTeamCollaboratorRpcByDocumentidExecute(r)
}
/*
PostTeamCollaboratorRpcByDocumentid CollabRPC is the collaborative-markup snapshot plane the Team front's editor speaks: createContent stores a document field's markup at a fresh, immutable blob ref and returns it, updateContent stores a new snapshot and answers nothing, and getContent reads back the exact snapshot a ref names.
CollabRPC is the collaborative-markup snapshot plane the Team front's editor
speaks: createContent stores a document field's markup at a fresh, immutable
blob ref and returns it, updateContent stores a new snapshot and answers
nothing, and getContent reads back the exact snapshot a ref names.
createContent ALSO seeds the live-editing update log from the front-supplied
Y.js update, so a dialog-authored description is visible in the collaborative
editor — which replays that log — and not only in snapshot reads.
updateContent never touches that log: peers may be live-editing the document,
and their edits are not this call's to overwrite.
Every call is scoped to the caller's VERIFIED session or space token: the
documentId's space must be the token's space when the token names one,
and the caller must be a member of it. An unknown space, another tenant's
space and a space the caller is not in all answer the same 404, so a
probe learns nothing about what exists.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param documentId DocumentID addresses the document field, as \"<spaceUuid>|<objectClass>|<objectId>|<objectAttr>\" — the collaborator-client encodeDocumentId shape, from the path.
@return TeamAPIPostTeamCollaboratorRpcByDocumentidRequest
*/
func (a *TeamAPIService) PostTeamCollaboratorRpcByDocumentid(ctx context.Context, documentId string) TeamAPIPostTeamCollaboratorRpcByDocumentidRequest {
return TeamAPIPostTeamCollaboratorRpcByDocumentidRequest{
ApiService: a,
ctx: ctx,
documentId: documentId,
}
}
// Execute executes the request
//
// @return TeamCollabResult
func (a *TeamAPIService) PostTeamCollaboratorRpcByDocumentidExecute(r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) (*TeamCollabResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamCollabResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamCollaboratorRpcByDocumentid")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/collaborator/rpc/{documentId}"
localVarPath = strings.Replace(localVarPath, "{"+"documentId"+"}", url.PathEscape(parameterValueToString(r.documentId, "documentId")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamCollabRequest == nil {
return localVarReturnValue, nil, reportError("teamCollabRequest 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.teamCollabRequest
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 TeamAPIPostTeamDmsRequest struct {
ctx context.Context
ApiService *TeamAPIService
teamTeamDirectOpen *TeamTeamDirectOpen
}
func (r TeamAPIPostTeamDmsRequest) TeamTeamDirectOpen(teamTeamDirectOpen TeamTeamDirectOpen) TeamAPIPostTeamDmsRequest {
r.teamTeamDirectOpen = &teamTeamDirectOpen
return r
}
func (r TeamAPIPostTeamDmsRequest) Execute() (*TeamTeamDirect, *http.Response, error) {
return r.ApiService.PostTeamDmsExecute(r)
}
/*
PostTeamDms Opens the direct message between the caller and the people named, or answers the one that already exists — there is one conversation per set of people, however many times it is asked for.
Opens the direct message between the caller and the people named,
or answers the one that already exists — there is one conversation per set of
people, however many times it is asked for.
Every person named must be a member of the space or one of the org's agents;
a direct message with an agent is a conversation it answers every message in,
and a guest may not open one.
Answers 201 when this call opened it and 200 when it was already there.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPostTeamDmsRequest
*/
func (a *TeamAPIService) PostTeamDms(ctx context.Context) TeamAPIPostTeamDmsRequest {
return TeamAPIPostTeamDmsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamDirect
func (a *TeamAPIService) PostTeamDmsExecute(r TeamAPIPostTeamDmsRequest) (*TeamTeamDirect, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamDirect
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDms")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/dms"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamDirectOpen == nil {
return localVarReturnValue, nil, reportError("teamTeamDirectOpen 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.teamTeamDirectOpen
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 TeamAPIPostTeamDocsRequest struct {
ctx context.Context
ApiService *TeamAPIService
teamTeamDocNew *TeamTeamDocNew
}
func (r TeamAPIPostTeamDocsRequest) TeamTeamDocNew(teamTeamDocNew TeamTeamDocNew) TeamAPIPostTeamDocsRequest {
r.teamTeamDocNew = &teamTeamDocNew
return r
}
func (r TeamAPIPostTeamDocsRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
return r.ApiService.PostTeamDocsExecute(r)
}
/*
PostTeamDocs Creates a document, as the caller, after its siblings.
Creates a document, as the caller, after its siblings.
It is created through the Team client's own write path, so it appears in an
open Documents sidebar live, and its author is subscribed to it: a comment on
it lands in their inbox. Its body starts empty — open the returned
`collaborator` id on the /v1/team/collaborator socket to write it.
A space whose caller can write no teamspace at all gets one on its first
document: a public "General" teamspace every current member of the space is
in, which is what the Team client would otherwise make somebody create by hand
before the first page. Guests and agents are not made members of it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPostTeamDocsRequest
*/
func (a *TeamAPIService) PostTeamDocs(ctx context.Context) TeamAPIPostTeamDocsRequest {
return TeamAPIPostTeamDocsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamDoc
func (a *TeamAPIService) PostTeamDocsExecute(r TeamAPIPostTeamDocsRequest) (*TeamTeamDoc, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamDoc
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDocs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamDocNew == nil {
return localVarReturnValue, nil, reportError("teamTeamDocNew 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.teamTeamDocNew
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 TeamAPIPostTeamDocsByIdCommentsRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamCommentWrite *TeamTeamCommentWrite
}
func (r TeamAPIPostTeamDocsByIdCommentsRequest) TeamTeamCommentWrite(teamTeamCommentWrite TeamTeamCommentWrite) TeamAPIPostTeamDocsByIdCommentsRequest {
r.teamTeamCommentWrite = &teamTeamCommentWrite
return r
}
func (r TeamAPIPostTeamDocsByIdCommentsRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.PostTeamDocsByIdCommentsExecute(r)
}
/*
PostTeamDocsByIdComments Comments on a document, as the caller.
Comments on a document, as the caller.
It is a message attached to the document, written through the Team client's
own path: the people subscribed to the document and anyone mentioned are
notified, and an agent mentioned answers with a comment of its own. It can be
replied to, reacted to, edited and deleted with the message ops.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the document, from the path.
@return TeamAPIPostTeamDocsByIdCommentsRequest
*/
func (a *TeamAPIService) PostTeamDocsByIdComments(ctx context.Context, id string) TeamAPIPostTeamDocsByIdCommentsRequest {
return TeamAPIPostTeamDocsByIdCommentsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) PostTeamDocsByIdCommentsExecute(r TeamAPIPostTeamDocsByIdCommentsRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDocsByIdComments")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/docs/{id}/comments"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamCommentWrite == nil {
return localVarReturnValue, nil, reportError("teamTeamCommentWrite 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.teamTeamCommentWrite
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 TeamAPIPostTeamFilesBySpaceRequest struct {
ctx context.Context
ApiService *TeamAPIService
space string
body *os.File
}
func (r TeamAPIPostTeamFilesBySpaceRequest) Body(body *os.File) TeamAPIPostTeamFilesBySpaceRequest {
r.body = body
return r
}
func (r TeamAPIPostTeamFilesBySpaceRequest) Execute() (*os.File, *http.Response, error) {
return r.ApiService.PostTeamFilesBySpaceExecute(r)
}
/*
PostTeamFilesBySpace Upload a file into a space
Stores one file in a space's blob store and answers the blob id it is addressable by, as plain text — the front discards that body, it is there for a caller driving this by hand.
The body is a multipart form with a `file` part, and THAT PART'S FILENAME IS THE BLOB ID: the client mints it (a uuid v4) and the server stores under it, so a part whose filename is not a uuid is refused rather than assigned one. A file over 100 MiB is 413 and an empty one is 400.
The caller must hold a verified session or space token AND be a member of the space; an unknown space, another tenant's space and a space the caller is not in all answer the same 404, so a probe learns nothing about what exists. The stored key embeds the verified org and the space, so an upload cannot land in another tenant's box whatever id it names. A storage backend that is unavailable fails closed with 502 rather than reporting a write it never made.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param space
@return TeamAPIPostTeamFilesBySpaceRequest
*/
func (a *TeamAPIService) PostTeamFilesBySpace(ctx context.Context, space string) TeamAPIPostTeamFilesBySpaceRequest {
return TeamAPIPostTeamFilesBySpaceRequest{
ApiService: a,
ctx: ctx,
space: space,
}
}
// Execute executes the request
//
// @return *os.File
func (a *TeamAPIService) PostTeamFilesBySpaceExecute(r TeamAPIPostTeamFilesBySpaceRequest) (*os.File, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *os.File
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamFilesBySpace")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/files/{space}"
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/octet-stream"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"text/plain; charset=utf-8"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.body
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 TeamAPIPostTeamInboxByIdArchiveRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamInboxAt *TeamTeamInboxAt
}
func (r TeamAPIPostTeamInboxByIdArchiveRequest) TeamTeamInboxAt(teamTeamInboxAt TeamTeamInboxAt) TeamAPIPostTeamInboxByIdArchiveRequest {
r.teamTeamInboxAt = &teamTeamInboxAt
return r
}
func (r TeamAPIPostTeamInboxByIdArchiveRequest) Execute() (*TeamTeamInboxItem, *http.Response, error) {
return r.ApiService.PostTeamInboxByIdArchiveExecute(r)
}
/*
PostTeamInboxByIdArchive Archives one of the caller's notifications — read, and out of the live inbox — and answers it.
Archives one of the caller's notifications — read, and
out of the live inbox — and answers it. It is listed again with
`archived=true`.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the notification, from the path.
@return TeamAPIPostTeamInboxByIdArchiveRequest
*/
func (a *TeamAPIService) PostTeamInboxByIdArchive(ctx context.Context, id string) TeamAPIPostTeamInboxByIdArchiveRequest {
return TeamAPIPostTeamInboxByIdArchiveRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamInboxItem
func (a *TeamAPIService) PostTeamInboxByIdArchiveExecute(r TeamAPIPostTeamInboxByIdArchiveRequest) (*TeamTeamInboxItem, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamInboxItem
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxByIdArchive")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/inbox/{id}/archive"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamInboxAt == nil {
return localVarReturnValue, nil, reportError("teamTeamInboxAt 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.teamTeamInboxAt
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 TeamAPIPostTeamInboxByIdReadRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamInboxAt *TeamTeamInboxAt
}
func (r TeamAPIPostTeamInboxByIdReadRequest) TeamTeamInboxAt(teamTeamInboxAt TeamTeamInboxAt) TeamAPIPostTeamInboxByIdReadRequest {
r.teamTeamInboxAt = &teamTeamInboxAt
return r
}
func (r TeamAPIPostTeamInboxByIdReadRequest) Execute() (*TeamTeamInboxItem, *http.Response, error) {
return r.ApiService.PostTeamInboxByIdReadExecute(r)
}
/*
PostTeamInboxByIdRead Marks one of the caller's notifications read and answers it.
Marks one of the caller's notifications read and answers it.
Another person's notification is a 404, as one that does not exist is.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the notification, from the path.
@return TeamAPIPostTeamInboxByIdReadRequest
*/
func (a *TeamAPIService) PostTeamInboxByIdRead(ctx context.Context, id string) TeamAPIPostTeamInboxByIdReadRequest {
return TeamAPIPostTeamInboxByIdReadRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamInboxItem
func (a *TeamAPIService) PostTeamInboxByIdReadExecute(r TeamAPIPostTeamInboxByIdReadRequest) (*TeamTeamInboxItem, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamInboxItem
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxByIdRead")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/inbox/{id}/read"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamInboxAt == nil {
return localVarReturnValue, nil, reportError("teamTeamInboxAt 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.teamTeamInboxAt
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 TeamAPIPostTeamInboxReadRequest struct {
ctx context.Context
ApiService *TeamAPIService
teamTeamInboxAll *TeamTeamInboxAll
}
func (r TeamAPIPostTeamInboxReadRequest) TeamTeamInboxAll(teamTeamInboxAll TeamTeamInboxAll) TeamAPIPostTeamInboxReadRequest {
r.teamTeamInboxAll = &teamTeamInboxAll
return r
}
func (r TeamAPIPostTeamInboxReadRequest) Execute() (*TeamTeamInboxCleared, *http.Response, error) {
return r.ApiService.PostTeamInboxReadExecute(r)
}
/*
PostTeamInboxRead Marks every live notification of the caller's read, and says how many it changed.
Marks every live notification of the caller's read, and
says how many it changed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPostTeamInboxReadRequest
*/
func (a *TeamAPIService) PostTeamInboxRead(ctx context.Context) TeamAPIPostTeamInboxReadRequest {
return TeamAPIPostTeamInboxReadRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return TeamTeamInboxCleared
func (a *TeamAPIService) PostTeamInboxReadExecute(r TeamAPIPostTeamInboxReadRequest) (*TeamTeamInboxCleared, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamInboxCleared
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxRead")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/inbox/read"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamInboxAll == nil {
return localVarReturnValue, nil, reportError("teamTeamInboxAll 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.teamTeamInboxAll
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 TeamAPIPostTeamMessagesByIdRepliesRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamReplyWrite *TeamTeamReplyWrite
}
func (r TeamAPIPostTeamMessagesByIdRepliesRequest) TeamTeamReplyWrite(teamTeamReplyWrite TeamTeamReplyWrite) TeamAPIPostTeamMessagesByIdRepliesRequest {
r.teamTeamReplyWrite = &teamTeamReplyWrite
return r
}
func (r TeamAPIPostTeamMessagesByIdRepliesRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.PostTeamMessagesByIdRepliesExecute(r)
}
/*
PostTeamMessagesByIdReplies Answers a message in its thread, as the caller.
Answers a message in its thread, as the caller.
A reply is a thread message attached to the one it answers, written through
the Team client's own path: the parent's reply count and last-reply time move
with it, the people already in the thread and anyone mentioned are notified,
and an agent mentioned in a reply answers in the same thread. A reply cannot
itself be replied to — threads are one level deep, as in the Team client.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message being answered, from the path.
@return TeamAPIPostTeamMessagesByIdRepliesRequest
*/
func (a *TeamAPIService) PostTeamMessagesByIdReplies(ctx context.Context, id string) TeamAPIPostTeamMessagesByIdRepliesRequest {
return TeamAPIPostTeamMessagesByIdRepliesRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) PostTeamMessagesByIdRepliesExecute(r TeamAPIPostTeamMessagesByIdRepliesRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamMessagesByIdReplies")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}/replies"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamReplyWrite == nil {
return localVarReturnValue, nil, reportError("teamTeamReplyWrite 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.teamTeamReplyWrite
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 TeamAPIPutTeamAccountCookieRequest struct {
ctx context.Context
ApiService *TeamAPIService
}
func (r TeamAPIPutTeamAccountCookieRequest) Execute() (*CookieAck, *http.Response, error) {
return r.ApiService.PutTeamAccountCookieExecute(r)
}
/*
PutTeamAccountCookie Store the session token as this browser's cookie
Writes the team session token into the HttpOnly `account-token` cookie — Secure, SameSite=Lax, whole-origin scope, thirty days — and answers {"result": true}. This is how the client turns the token it caught off the OAuth bounce into a credential page JS can no longer read, which IS the security property: script that cannot see the cookie cannot exfiltrate it, and every later call on the files, billing and collaborator planes authenticates from it when no bearer is sent.
The token is VERIFIED — signature and expiry, against this service's own signing secret — BEFORE it is stored. Anything this service did not sign is 401 and nothing is written; persisting a caller-supplied value unchecked would be a session-fixation hole, where an attacker pins a cookie the victim's browser then presents as its own.
The token may arrive as `token` in the JSON body or, when the body is absent or unparseable, from the Authorization bearer — an unreadable body is NOT an error here. The sibling DELETE clears this same cookie and signs the browser out of team only: the IAM cookie set alongside it is a different credential with its own lifetime and is left alone.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return TeamAPIPutTeamAccountCookieRequest
*/
func (a *TeamAPIService) PutTeamAccountCookie(ctx context.Context) TeamAPIPutTeamAccountCookieRequest {
return TeamAPIPutTeamAccountCookieRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return CookieAck
func (a *TeamAPIService) PutTeamAccountCookieExecute(r TeamAPIPutTeamAccountCookieRequest) (*CookieAck, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *CookieAck
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamAccountCookie")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/account/cookie"
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"}
// 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,
}
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 TeamAPIPutTeamChannelsByIdRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
teamTeamChannelBind *TeamTeamChannelBind
}
func (r TeamAPIPutTeamChannelsByIdRequest) TeamTeamChannelBind(teamTeamChannelBind TeamTeamChannelBind) TeamAPIPutTeamChannelsByIdRequest {
r.teamTeamChannelBind = &teamTeamChannelBind
return r
}
func (r TeamAPIPutTeamChannelsByIdRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
return r.ApiService.PutTeamChannelsByIdExecute(r)
}
/*
PutTeamChannelsById States what a channel is for: its lifecycle intent, and what it is about.
States what a channel is for: its lifecycle intent, and what it is
about. It answers the channel as it now stands.
The write updates the work fields on the channel document, applied through the
SAME applyTx path the Team client's own writes take and broadcast to every
connected client — so a channel bound here updates live in an open space
rather than on the next reload. A team member binds a channel they can see; an
application of the org binds its public channels only; anybody else without
a team session is 401.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the channel to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.
@return TeamAPIPutTeamChannelsByIdRequest
*/
func (a *TeamAPIService) PutTeamChannelsById(ctx context.Context, id string) TeamAPIPutTeamChannelsByIdRequest {
return TeamAPIPutTeamChannelsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return TeamTeamChannelOne
func (a *TeamAPIService) PutTeamChannelsByIdExecute(r TeamAPIPutTeamChannelsByIdRequest) (*TeamTeamChannelOne, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamChannelOne
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamChannelsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/channels/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamChannelBind == nil {
return localVarReturnValue, nil, reportError("teamTeamChannelBind 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.teamTeamChannelBind
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 TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest struct {
ctx context.Context
ApiService *TeamAPIService
id string
emoji string
teamTeamReactionWrite *TeamTeamReactionWrite
}
func (r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) TeamTeamReactionWrite(teamTeamReactionWrite TeamTeamReactionWrite) TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest {
r.teamTeamReactionWrite = &teamTeamReactionWrite
return r
}
func (r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
return r.ApiService.PutTeamMessagesByIdReactionsByEmojiExecute(r)
}
/*
PutTeamMessagesByIdReactionsByEmoji Adds the caller's reaction to a message and answers the message with its reactions as they now stand.
Adds the caller's reaction to a message and answers the message with
its reactions as they now stand. Reacting twice with one emoji is one
reaction: the second call changes nothing.
The emoji is the last path segment, percent-encoded — PUT
/v1/team/messages/7a1c/reactions/%F0%9F%91%8D for 👍.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the message, from the path.
@param emoji Emoji is the reaction, from the path (percent-encoded on the wire).
@return TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest
*/
func (a *TeamAPIService) PutTeamMessagesByIdReactionsByEmoji(ctx context.Context, id string, emoji string) TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest {
return TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest{
ApiService: a,
ctx: ctx,
id: id,
emoji: emoji,
}
}
// Execute executes the request
//
// @return TeamTeamMessage
func (a *TeamAPIService) PutTeamMessagesByIdReactionsByEmojiExecute(r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) (*TeamTeamMessage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *TeamTeamMessage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamMessagesByIdReactionsByEmoji")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/team/messages/{id}/reactions/{emoji}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"emoji"+"}", url.PathEscape(parameterValueToString(r.emoji, "emoji")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.teamTeamReactionWrite == nil {
return localVarReturnValue, nil, reportError("teamTeamReactionWrite 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.teamTeamReactionWrite
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
}