mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
2306 lines
86 KiB
Go
2306 lines
86 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"
|
||
"strings"
|
||
)
|
||
|
||
// KnowledgeAPIService KnowledgeAPI service
|
||
type KnowledgeAPIService service
|
||
|
||
type KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest) Execute() (*KnowledgeConnectionOut, *http.Response, error) {
|
||
return r.ApiService.DeleteKnowledgeConnectorsByProviderExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteKnowledgeConnectorsByProvider Revokes a connection: it tombstones the stored credential so a later sync cannot reuse it, removes this provider's passages from the org's store, and marks the connector disconnected.
|
||
|
||
Revokes a connection: it tombstones the stored credential
|
||
so a later sync cannot reuse it, removes this provider's passages from the
|
||
org's store, and marks the connector disconnected. The documents already
|
||
ingested stay in the org's store — they are the org's own data — but stop being
|
||
retrievable by search; a caller deletes them through the document surface.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector to act on: github, slack, google or notion.
|
||
@return KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) DeleteKnowledgeConnectorsByProvider(ctx context.Context, provider string) KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest {
|
||
return KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeConnectionOut
|
||
func (a *KnowledgeAPIService) DeleteKnowledgeConnectorsByProviderExecute(r KnowledgeAPIDeleteKnowledgeConnectorsByProviderRequest) (*KnowledgeConnectionOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeConnectionOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.DeleteKnowledgeConnectorsByProvider")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors/{provider}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIDeleteKnowledgeFilesByIdRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
id string
|
||
}
|
||
|
||
func (r KnowledgeAPIDeleteKnowledgeFilesByIdRequest) Execute() (*KnowledgeForgotten, *http.Response, error) {
|
||
return r.ApiService.DeleteKnowledgeFilesByIdExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteKnowledgeFilesById Removes one of the caller's org files from the index — its table of contents, passages, full-text rows, mentions and links — and its record.
|
||
|
||
Removes one of the caller's org files from the index — its table of
|
||
contents, passages, full-text rows, mentions and links — and its record. The
|
||
file is gone from every read when this answers: its listing, its contents,
|
||
search and retrieval. What the index held of it is removed after, a batch at
|
||
a time, so forgetting a file of any size answers at once. The object itself
|
||
stays in its bucket; delete it there. Drive calls this when it deletes a file.
|
||
|
||
Only the person who registered the file or an admin of the org may forget it;
|
||
anyone else in the org, who can still read it, is refused 403. A file
|
||
registered before uploaders were recorded is forgotten by an admin alone.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the file's id, as POST /v1/knowledge/files answered it.
|
||
@return KnowledgeAPIDeleteKnowledgeFilesByIdRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) DeleteKnowledgeFilesById(ctx context.Context, id string) KnowledgeAPIDeleteKnowledgeFilesByIdRequest {
|
||
return KnowledgeAPIDeleteKnowledgeFilesByIdRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeForgotten
|
||
func (a *KnowledgeAPIService) DeleteKnowledgeFilesByIdExecute(r KnowledgeAPIDeleteKnowledgeFilesByIdRequest) (*KnowledgeForgotten, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeForgotten
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.DeleteKnowledgeFilesById")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/{id}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIGetKnowledgeConnectorsRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsRequest) Execute() (*KnowledgeKbConnectorsOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeConnectorsExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeConnectors Returns every supported knowledge connector with THIS org's connection state and the REAL number of documents each has ingested into the org's store.
|
||
|
||
Returns every supported knowledge connector with THIS org's
|
||
connection state and the REAL number of documents each has ingested into the
|
||
org's store. A provider that is configured for the deployment but not yet
|
||
connected appears as disconnected, so the console can offer a Connect button.
|
||
No secret is ever returned.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIGetKnowledgeConnectorsRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectors(ctx context.Context) KnowledgeAPIGetKnowledgeConnectorsRequest {
|
||
return KnowledgeAPIGetKnowledgeConnectorsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeKbConnectorsOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsExecute(r KnowledgeAPIGetKnowledgeConnectorsRequest) (*KnowledgeKbConnectorsOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeKbConnectorsOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeConnectors")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors"
|
||
|
||
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 KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
provider string
|
||
code *string
|
||
state *string
|
||
error_ *string
|
||
}
|
||
|
||
// Code is the provider's authorization code, exchanged for a token.
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest) Code(code string) KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest {
|
||
r.code = &code
|
||
return r
|
||
}
|
||
|
||
// State is the org-bound value this server signed at connect time.
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest) State(state string) KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest {
|
||
r.state = &state
|
||
return r
|
||
}
|
||
|
||
// Error is the provider's denial reason when the user refused consent.
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest) Error_(error_ string) KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest {
|
||
r.error_ = &error_
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest) Execute() (*KnowledgeConnectionOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeConnectorsByProviderCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeConnectorsByProviderCallback CompleteConnectorOAuth finishes an OAuth connection: it exchanges the provider's code for a token, seals that token in KMS, and records the connection.
|
||
|
||
CompleteConnectorOAuth finishes an OAuth connection: it exchanges the
|
||
provider's code for a token, seals that token in KMS, and records the
|
||
connection. THE ORG COMES FROM THE SIGNED STATE, not from a header and not from
|
||
the provider, so an attacker cannot bind their own account to someone else's
|
||
org — a tampered, expired or foreign-provider state is refused outright. The
|
||
token itself is never returned, never written into the document, and never
|
||
logged; the document holds only its KMS path.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector completing its flow, from the path.
|
||
@return KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsByProviderCallback(ctx context.Context, provider string) KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest {
|
||
return KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeConnectionOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsByProviderCallbackExecute(r KnowledgeAPIGetKnowledgeConnectorsByProviderCallbackRequest) (*KnowledgeConnectionOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeConnectionOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeConnectorsByProviderCallback")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors/{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{}
|
||
|
||
if r.code != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "code", r.code, "form", "")
|
||
}
|
||
if r.state != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "state", r.state, "form", "")
|
||
}
|
||
if r.error_ != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "error", r.error_, "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 KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest) Execute() (*KnowledgeKbAuthorizeOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeConnectorsByProviderConnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeConnectorsByProviderConnect StartConnectorOAuth returns the provider authorize URL the console opens to connect this org's account.
|
||
|
||
StartConnectorOAuth returns the provider authorize URL the console opens to
|
||
connect this org's account. There is no server-side redirect — the console
|
||
stays in control of the navigation. The URL carries a state this server SIGNED
|
||
over the caller's validated org, so the connection the callback completes can
|
||
only ever land in that org.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector to act on: github, slack, google or notion.
|
||
@return KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsByProviderConnect(ctx context.Context, provider string) KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest {
|
||
return KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeKbAuthorizeOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsByProviderConnectExecute(r KnowledgeAPIGetKnowledgeConnectorsByProviderConnectRequest) (*KnowledgeKbAuthorizeOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeKbAuthorizeOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeConnectorsByProviderConnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors/{provider}/connect"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// 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 KnowledgeAPIGetKnowledgeConnectorsCatalogRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeConnectorsCatalogRequest) Execute() (*KnowledgeCatalogOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeConnectorsCatalogExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeConnectorsCatalog Returns the ONE catalog of everything a caller can connect: every first-party connector and every long-tail one, in a single list sorted by provider.
|
||
|
||
Returns the ONE catalog of everything a caller can
|
||
connect: every first-party connector and every long-tail one, in a single list
|
||
sorted by provider. `configured` reports whether this deployment holds OAuth
|
||
credentials for a source, so the console can show Connect rather than a dead
|
||
button, and `kind` is a badge only — the connect and sync lifecycle is
|
||
identical for both. The catalog itself is org-independent; a validated
|
||
principal is still required. It is metadata only: no secret is ever returned.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIGetKnowledgeConnectorsCatalogRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsCatalog(ctx context.Context) KnowledgeAPIGetKnowledgeConnectorsCatalogRequest {
|
||
return KnowledgeAPIGetKnowledgeConnectorsCatalogRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeCatalogOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeConnectorsCatalogExecute(r KnowledgeAPIGetKnowledgeConnectorsCatalogRequest) (*KnowledgeCatalogOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeCatalogOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeConnectorsCatalog")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors/catalog"
|
||
|
||
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 KnowledgeAPIGetKnowledgeFilesRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
bucket *string
|
||
limit *string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesRequest) Bucket(bucket string) KnowledgeAPIGetKnowledgeFilesRequest {
|
||
r.bucket = &bucket
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesRequest) Limit(limit string) KnowledgeAPIGetKnowledgeFilesRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesRequest) Execute() (*KnowledgeFilesOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeFilesExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeFiles Answers the caller's org files, most recently changed first, each with its status and stage — optionally only those in one bucket, which is how Drive shows a folder's files with their index state.
|
||
|
||
Answers the caller's org files, most recently changed first, each
|
||
with its status and stage — optionally only those in one bucket, which is how
|
||
Drive shows a folder's files with their index state.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIGetKnowledgeFilesRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeFiles(ctx context.Context) KnowledgeAPIGetKnowledgeFilesRequest {
|
||
return KnowledgeAPIGetKnowledgeFilesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeFilesOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesExecute(r KnowledgeAPIGetKnowledgeFilesRequest) (*KnowledgeFilesOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeFilesOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeFiles")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.bucket != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "bucket", r.bucket, "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 KnowledgeAPIGetKnowledgeFilesByIdRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
id string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesByIdRequest) Execute() (*KnowledgeFile, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeFilesByIdExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeFilesById Answers one of the caller's org files: what it is, where its bytes are, and how far its ingest has got.
|
||
|
||
Answers one of the caller's org files: what it is, where its bytes
|
||
are, and how far its ingest has got. 404 for an id the org holds no file for.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the file's id, as POST /v1/knowledge/files answered it.
|
||
@return KnowledgeAPIGetKnowledgeFilesByIdRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesById(ctx context.Context, id string) KnowledgeAPIGetKnowledgeFilesByIdRequest {
|
||
return KnowledgeAPIGetKnowledgeFilesByIdRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeFile
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdExecute(r KnowledgeAPIGetKnowledgeFilesByIdRequest) (*KnowledgeFile, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeFilesById")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/{id}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIGetKnowledgeFilesByIdGraphRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
id string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesByIdGraphRequest) Execute() (*KnowledgeFileGraph, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeFilesByIdGraphExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeFilesByIdGraph Answers one of the caller's org files' place in the org's graph: the files it links to and is linked from (a hyperlink, a citation by name), the files that name the same entities, and the entities it names.
|
||
|
||
Answers one of the caller's org files' place in the org's graph:
|
||
the files it links to and is linked from (a hyperlink, a citation by name),
|
||
the files that name the same entities, and the entities it names. It is how
|
||
an agent finds the other documents a question about this one needs.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the file's id, as POST /v1/knowledge/files answered it.
|
||
@return KnowledgeAPIGetKnowledgeFilesByIdGraphRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdGraph(ctx context.Context, id string) KnowledgeAPIGetKnowledgeFilesByIdGraphRequest {
|
||
return KnowledgeAPIGetKnowledgeFilesByIdGraphRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeFileGraph
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdGraphExecute(r KnowledgeAPIGetKnowledgeFilesByIdGraphRequest) (*KnowledgeFileGraph, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeFileGraph
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeFilesByIdGraph")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/{id}/graph"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
id string
|
||
section string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest) Execute() (*KnowledgeSectionOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeFilesByIdSectionsBySectionExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeFilesByIdSectionsBySection Answers one section of one of the caller's org files: its own text, its subsections, the sections it links to or shares entities with — in this file or another — and the entities it names.
|
||
|
||
Answers one section of one of the caller's org files: its own
|
||
text, its subsections, the sections it links to or shares entities with —
|
||
in this file or another — and the entities it names. Open the document
|
||
itself with section 0.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the file's id.
|
||
@param section Section is the section's number in the file's table of contents.
|
||
@return KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdSectionsBySection(ctx context.Context, id string, section string) KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest {
|
||
return KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
section: section,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeSectionOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdSectionsBySectionExecute(r KnowledgeAPIGetKnowledgeFilesByIdSectionsBySectionRequest) (*KnowledgeSectionOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeSectionOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeFilesByIdSectionsBySection")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/{id}/sections/{section}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"section"+"}", url.PathEscape(parameterValueToString(r.section, "section")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIGetKnowledgeFilesByIdTocRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
id string
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeFilesByIdTocRequest) Execute() (*KnowledgeTocOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeFilesByIdTocExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeFilesByIdToc Answers one of the caller's org files' table of contents: every section in document order with its depth, its parent and a one-line summary.
|
||
|
||
Answers one of the caller's org files' table of contents: every
|
||
section in document order with its depth, its parent and a one-line summary.
|
||
It is the map a reader — a person in Drive, or an agent deciding where to
|
||
look — reads before opening a section with GET
|
||
/v1/knowledge/files/{id}/sections/{section}.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the file's id, as POST /v1/knowledge/files answered it.
|
||
@return KnowledgeAPIGetKnowledgeFilesByIdTocRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdToc(ctx context.Context, id string) KnowledgeAPIGetKnowledgeFilesByIdTocRequest {
|
||
return KnowledgeAPIGetKnowledgeFilesByIdTocRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeTocOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeFilesByIdTocExecute(r KnowledgeAPIGetKnowledgeFilesByIdTocRequest) (*KnowledgeTocOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeTocOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeFilesByIdToc")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/{id}/toc"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIGetKnowledgeGraphRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
project *string
|
||
}
|
||
|
||
// Project narrows the graph to one project scope. Empty reads the whole org.
|
||
func (r KnowledgeAPIGetKnowledgeGraphRequest) Project(project string) KnowledgeAPIGetKnowledgeGraphRequest {
|
||
r.project = &project
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIGetKnowledgeGraphRequest) Execute() (*KnowledgeGraphOut, *http.Response, error) {
|
||
return r.ApiService.GetKnowledgeGraphExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetKnowledgeGraph Returns the caller org's knowledge as a node/edge graph shaped for a force-directed renderer: pages, memories and synced sources as nodes; the page parent tree, the wikilinks between pages, and each source's connector provenance as edges.
|
||
|
||
Returns the caller org's knowledge as a node/edge graph
|
||
shaped for a force-directed renderer: pages, memories and synced sources as
|
||
nodes; the page parent tree, the wikilinks between pages, and each source's
|
||
connector provenance as edges. Wikilink targets are resolved HERE by title or
|
||
slug, so a rename never needs an edge rewrite and a link that matches no page
|
||
renders as its own "unresolved" node instead of vanishing. ?project= narrows
|
||
it. A store outage degrades to an honest empty graph, never a 5xx.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIGetKnowledgeGraphRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) GetKnowledgeGraph(ctx context.Context) KnowledgeAPIGetKnowledgeGraphRequest {
|
||
return KnowledgeAPIGetKnowledgeGraphRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeGraphOut
|
||
func (a *KnowledgeAPIService) GetKnowledgeGraphExecute(r KnowledgeAPIGetKnowledgeGraphRequest) (*KnowledgeGraphOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeGraphOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.GetKnowledgeGraph")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/graph"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.project != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "project", r.project, "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 KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest) Execute() (*KnowledgeKbSyncOut, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeConnectorsByProviderSyncExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeConnectorsByProviderSync Pulls the provider's documents for the caller's org and files them as knowledge sources, which the store's own hook then indexes — so a synced document is retrievable exactly like a hand-written page.
|
||
|
||
Pulls the provider's documents for the caller's org and files
|
||
them as knowledge sources, which the store's own hook then indexes — so a
|
||
synced document is retrievable exactly like a hand-written page. The org is the
|
||
validated tenant and the credential is read from KMS, so an org can only ever
|
||
sync its own connection. A provider failure is reported honestly (502) and
|
||
recorded on the connector rather than silently swallowed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector to act on: github, slack, google or notion.
|
||
@return KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeConnectorsByProviderSync(ctx context.Context, provider string) KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest {
|
||
return KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeKbSyncOut
|
||
func (a *KnowledgeAPIService) PostKnowledgeConnectorsByProviderSyncExecute(r KnowledgeAPIPostKnowledgeConnectorsByProviderSyncRequest) (*KnowledgeKbSyncOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeKbSyncOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeConnectorsByProviderSync")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/connectors/{provider}/sync"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type KnowledgeAPIPostKnowledgeFilesRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
knowledgeFileIn *KnowledgeFileIn
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesRequest) KnowledgeFileIn(knowledgeFileIn KnowledgeFileIn) KnowledgeAPIPostKnowledgeFilesRequest {
|
||
r.knowledgeFileIn = &knowledgeFileIn
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesRequest) Execute() (*KnowledgeFile, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeFilesExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeFiles Makes an object in one of the caller's org buckets a workspace file.
|
||
|
||
Makes an object in one of the caller's org buckets a workspace
|
||
file. Upload the bytes first — POST /v1/s3/buckets/{bucket}/objects mints a
|
||
presigned PUT, POST /v1/s3/buckets/{bucket}/uploads starts a multipart upload
|
||
for a large one — then register the key here. The object's name, type and
|
||
size are read from the store. The file is recorded as queued, a file_stored
|
||
event is stated on the org's event plane, and a durable ingest is queued that
|
||
extracts its text and structure, summarizes its table of contents, cuts and
|
||
embeds its passages and links it into the org's graph. An archive (.zip) is
|
||
unpacked and every file inside becomes a workspace file of its own. Poll GET
|
||
/v1/knowledge/files/{id} for status. Registering an object again answers the
|
||
same file, and re-indexes it only when the object changed or its last ingest
|
||
failed.
|
||
|
||
Registering a changed object again changes its file, which only the person
|
||
who registered it or an admin of the org may do: anyone else is refused 403
|
||
and the file keeps its version. Registering an unchanged object is a read.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeFilesRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeFiles(ctx context.Context) KnowledgeAPIPostKnowledgeFilesRequest {
|
||
return KnowledgeAPIPostKnowledgeFilesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeFile
|
||
func (a *KnowledgeAPIService) PostKnowledgeFilesExecute(r KnowledgeAPIPostKnowledgeFilesRequest) (*KnowledgeFile, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeFiles")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.knowledgeFileIn == nil {
|
||
return localVarReturnValue, nil, reportError("knowledgeFileIn 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.knowledgeFileIn
|
||
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 KnowledgeAPIPostKnowledgeFilesRetrieveRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
knowledgeRetrieveIn *KnowledgeRetrieveIn
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesRetrieveRequest) KnowledgeRetrieveIn(knowledgeRetrieveIn KnowledgeRetrieveIn) KnowledgeAPIPostKnowledgeFilesRetrieveRequest {
|
||
r.knowledgeRetrieveIn = &knowledgeRetrieveIn
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesRetrieveRequest) Execute() (*KnowledgeRetrieveOut, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeFilesRetrieveExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeFilesRetrieve Grounds an answer in the caller's org files, table of contents first: candidate documents are found by searching their passages; a model reads their tables of contents — titles and one-line summaries — and picks the sections the answer is in; hybrid search drills into the passages of those sections; and the graph expands to the sections they link to or name the same entities as, in any file of the workspace.
|
||
|
||
Grounds an answer in the caller's org files, table of contents
|
||
first: candidate documents are found by searching their passages; a model
|
||
reads their tables of contents — titles and one-line summaries — and picks
|
||
the sections the answer is in; hybrid search drills into the passages of
|
||
those sections; and the graph expands to the sections they link to or name
|
||
the same entities as, in any file of the workspace. Every passage cites its
|
||
file › section › paragraph, so an answer can say exactly where it came from.
|
||
This is what a chat runs before it answers about an attached file, and what
|
||
an agent runs before it answers about a workspace.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeFilesRetrieveRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeFilesRetrieve(ctx context.Context) KnowledgeAPIPostKnowledgeFilesRetrieveRequest {
|
||
return KnowledgeAPIPostKnowledgeFilesRetrieveRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeRetrieveOut
|
||
func (a *KnowledgeAPIService) PostKnowledgeFilesRetrieveExecute(r KnowledgeAPIPostKnowledgeFilesRetrieveRequest) (*KnowledgeRetrieveOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeRetrieveOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeFilesRetrieve")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/retrieve"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.knowledgeRetrieveIn == nil {
|
||
return localVarReturnValue, nil, reportError("knowledgeRetrieveIn 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.knowledgeRetrieveIn
|
||
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 KnowledgeAPIPostKnowledgeFilesSearchRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
knowledgeFileSearchIn *KnowledgeFileSearchIn
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesSearchRequest) KnowledgeFileSearchIn(knowledgeFileSearchIn KnowledgeFileSearchIn) KnowledgeAPIPostKnowledgeFilesSearchRequest {
|
||
r.knowledgeFileSearchIn = &knowledgeFileSearchIn
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeFilesSearchRequest) Execute() (*KnowledgeFileSearchOut, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeFilesSearchExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeFilesSearch Answers the passages of the caller's org files that match a query, each citing its file › section › paragraph: the search behind Drive's box, and the first step an agent takes across a workspace.
|
||
|
||
Answers the passages of the caller's org files that match a query,
|
||
each citing its file › section › paragraph: the search behind Drive's box,
|
||
and the first step an agent takes across a workspace. Name file ids to search
|
||
only those files; name none to search them all. A semantic leg compares the
|
||
query with every embedded passage and a full-text leg finds the passages
|
||
holding its words; the two are fused, so a passage both found comes first.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeFilesSearchRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeFilesSearch(ctx context.Context) KnowledgeAPIPostKnowledgeFilesSearchRequest {
|
||
return KnowledgeAPIPostKnowledgeFilesSearchRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeFileSearchOut
|
||
func (a *KnowledgeAPIService) PostKnowledgeFilesSearchExecute(r KnowledgeAPIPostKnowledgeFilesSearchRequest) (*KnowledgeFileSearchOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeFileSearchOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeFilesSearch")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/files/search"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.knowledgeFileSearchIn == nil {
|
||
return localVarReturnValue, nil, reportError("knowledgeFileSearchIn 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.knowledgeFileSearchIn
|
||
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 KnowledgeAPIPostKnowledgeImportRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeImportRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostKnowledgeImportExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeImport Import an Obsidian, Notion, Roam or Evernote export into the org's knowledge base
|
||
|
||
Ingests an uploaded export as a tree of kb.page documents with its link structure intact. `?format=` picks the normalizer — obsidian, notion, roam or evernote — and the export arrives as a multipart `file` part, or as the raw request body when there is no multipart part: an Obsidian or Notion vault zip, a Roam JSON (raw or inside the zip Roam downloads), or an Evernote .enex.
|
||
|
||
The pages are filed through the SAME ingest path a connector sync uses, so the kb.page hook indexes each one for retrieval AND extracts its `[[wikilinks]]` into kb.link edges — the imported vault is searchable and its graph is navigable without a second pass. Parents are filed before their children, and each page takes a slug unique within the org (suffixed -2, -3, … on collision), so a re-import adds pages rather than overwriting the ones already there.
|
||
|
||
Scoped to the caller's validated org; `?project=` narrows every imported page to one project. No validated principal is 403, and an org that has not installed the kb module is refused with the install call to make first. The bounds are 64 MB per upload, 5000 pages and 8 MB per archive entry: pages past the five-thousandth are dropped and a larger entry is truncated at its bound, and a page the store rejects is skipped — so the answer's `imported` count is what was actually filed, not what was sent.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeImportRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeImport(ctx context.Context) KnowledgeAPIPostKnowledgeImportRequest {
|
||
return KnowledgeAPIPostKnowledgeImportRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *KnowledgeAPIService) PostKnowledgeImportExecute(r KnowledgeAPIPostKnowledgeImportRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeImport")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/import"
|
||
|
||
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 KnowledgeAPIPostKnowledgeReindexRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeReindexRequest) Execute() (*KnowledgeReindexOut, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeReindexExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeReindex Rebuilds the caller org's retrieval from its documents: every passage is removed, and every page, memory and source is cut into passages and embedded again with the configured model; the lexical index is reconciled to the same documents.
|
||
|
||
Rebuilds the caller org's retrieval from its documents: every passage
|
||
is removed, and every page, memory and source is cut into passages and
|
||
embedded again with the configured model; the lexical index is reconciled to
|
||
the same documents. It is what an operator runs after the embedding model
|
||
changes — passages of another model are never compared with the query, so
|
||
until then they are unread — and what puts an org's retrieval right after an
|
||
outage of the ai plane. It requires ORG ADMIN and runs inline: an org's
|
||
knowledge is a few thousand documents, and the answer is the count.
|
||
|
||
The request has no body. Response: {"vectors": 412, "lexical": 412, "removed": 3, "failed": 0}
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeReindexRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeReindex(ctx context.Context) KnowledgeAPIPostKnowledgeReindexRequest {
|
||
return KnowledgeAPIPostKnowledgeReindexRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeReindexOut
|
||
func (a *KnowledgeAPIService) PostKnowledgeReindexExecute(r KnowledgeAPIPostKnowledgeReindexRequest) (*KnowledgeReindexOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeReindexOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeReindex")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/reindex"
|
||
|
||
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 KnowledgeAPIPostKnowledgeSearchRequest struct {
|
||
ctx context.Context
|
||
ApiService *KnowledgeAPIService
|
||
knowledgeSearchIn *KnowledgeSearchIn
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeSearchRequest) KnowledgeSearchIn(knowledgeSearchIn KnowledgeSearchIn) KnowledgeAPIPostKnowledgeSearchRequest {
|
||
r.knowledgeSearchIn = &knowledgeSearchIn
|
||
return r
|
||
}
|
||
|
||
func (r KnowledgeAPIPostKnowledgeSearchRequest) Execute() (*KnowledgeSearchOut, *http.Response, error) {
|
||
return r.ApiService.PostKnowledgeSearchExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostKnowledgeSearch Runs a hybrid search over the caller org's own knowledge — its wiki pages, its agent memories and everything its connectors have synced.
|
||
|
||
Runs a hybrid search over the caller org's own knowledge —
|
||
its wiki pages, its agent memories and everything its connectors have synced.
|
||
This is the RAG entry point: an agent asks "what does this org know about X"
|
||
and the org's OWN knowledge answers. Two legs run and are fused by reciprocal
|
||
rank: a semantic leg that embeds the query and compares it with every passage
|
||
of every document in reach (a document is cut into passages of about 2000
|
||
bytes, so a fact deep in a long page is found), and a keyword leg over the
|
||
org's knowledge index. The org comes from the validated principal and its
|
||
passages live in its own database, so cross-tenant retrieval is impossible. A
|
||
failed leg answers 200 with what the other leg found and degraded=true, never
|
||
a 5xx.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return KnowledgeAPIPostKnowledgeSearchRequest
|
||
*/
|
||
func (a *KnowledgeAPIService) PostKnowledgeSearch(ctx context.Context) KnowledgeAPIPostKnowledgeSearchRequest {
|
||
return KnowledgeAPIPostKnowledgeSearchRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return KnowledgeSearchOut
|
||
func (a *KnowledgeAPIService) PostKnowledgeSearchExecute(r KnowledgeAPIPostKnowledgeSearchRequest) (*KnowledgeSearchOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *KnowledgeSearchOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "KnowledgeAPIService.PostKnowledgeSearch")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/knowledge/search"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.knowledgeSearchIn == nil {
|
||
return localVarReturnValue, nil, reportError("knowledgeSearchIn 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.knowledgeSearchIn
|
||
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
|
||
}
|