mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1575 lines
53 KiB
Go
1575 lines
53 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"
|
|
)
|
|
|
|
// PatentAPIService PatentAPI service
|
|
type PatentAPIService service
|
|
|
|
type PatentAPIGetPatentApprovalsRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
disclosure *string
|
|
project *string
|
|
}
|
|
|
|
// Disclosure narrows to the decisions on one document.
|
|
func (r PatentAPIGetPatentApprovalsRequest) Disclosure(disclosure string) PatentAPIGetPatentApprovalsRequest {
|
|
r.disclosure = &disclosure
|
|
return r
|
|
}
|
|
|
|
// Project narrows to one project.
|
|
func (r PatentAPIGetPatentApprovalsRequest) Project(project string) PatentAPIGetPatentApprovalsRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentApprovalsRequest) Execute() (*PatentApprovalsOut, *http.Response, error) {
|
|
return r.ApiService.GetPatentApprovalsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentApprovals Returns the decision trail — each person's current word on each disclosure.
|
|
|
|
Returns the decision trail — each person's current word on
|
|
each disclosure. ?disclosure= narrows to one document.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentApprovalsRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentApprovals(ctx context.Context) PatentAPIGetPatentApprovalsRequest {
|
|
return PatentAPIGetPatentApprovalsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentApprovalsOut
|
|
func (a *PatentAPIService) GetPatentApprovalsExecute(r PatentAPIGetPatentApprovalsRequest) (*PatentApprovalsOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentApprovalsOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentApprovals")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/approvals"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.disclosure != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "disclosure", r.disclosure, "form", "")
|
|
}
|
|
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 PatentAPIGetPatentDisclosuresRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
id *string
|
|
status *string
|
|
project *string
|
|
}
|
|
|
|
// ID reads one disclosure.
|
|
func (r PatentAPIGetPatentDisclosuresRequest) Id(id string) PatentAPIGetPatentDisclosuresRequest {
|
|
r.id = &id
|
|
return r
|
|
}
|
|
|
|
// Status narrows to one status.
|
|
func (r PatentAPIGetPatentDisclosuresRequest) Status(status string) PatentAPIGetPatentDisclosuresRequest {
|
|
r.status = &status
|
|
return r
|
|
}
|
|
|
|
// Project narrows to one project.
|
|
func (r PatentAPIGetPatentDisclosuresRequest) Project(project string) PatentAPIGetPatentDisclosuresRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentDisclosuresRequest) Execute() (*PatentDiscsOut, *http.Response, error) {
|
|
return r.ApiService.GetPatentDisclosuresExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentDisclosures Returns the canonical disclosures, each carrying its current approvals.
|
|
|
|
Returns the canonical disclosures, each carrying its
|
|
current approvals.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentDisclosuresRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentDisclosures(ctx context.Context) PatentAPIGetPatentDisclosuresRequest {
|
|
return PatentAPIGetPatentDisclosuresRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentDiscsOut
|
|
func (a *PatentAPIService) GetPatentDisclosuresExecute(r PatentAPIGetPatentDisclosuresRequest) (*PatentDiscsOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentDiscsOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentDisclosures")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/disclosures"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.id != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "id", r.id, "form", "")
|
|
}
|
|
if r.status != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "status", r.status, "form", "")
|
|
}
|
|
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 PatentAPIGetPatentHealthRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
}
|
|
|
|
func (r PatentAPIGetPatentHealthRequest) Execute() (*PatentPatentHealth, *http.Response, error) {
|
|
return r.ApiService.GetPatentHealthExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentHealth Reports what this deployment actually guarantees about the records it keeps, in honest states.
|
|
|
|
Reports what this deployment actually guarantees about the
|
|
records it keeps, in honest states. Anchored and durable are the two that
|
|
change what a record is worth, and an unwired one reads as unwired rather than
|
|
as a green light.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentHealthRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentHealth(ctx context.Context) PatentAPIGetPatentHealthRequest {
|
|
return PatentAPIGetPatentHealthRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentHealth
|
|
func (a *PatentAPIService) GetPatentHealthExecute(r PatentAPIGetPatentHealthRequest) (*PatentPatentHealth, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentHealth
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentHealth")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/health"
|
|
|
|
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 PatentAPIGetPatentIdeasRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
id *string
|
|
kind *string
|
|
project *string
|
|
}
|
|
|
|
// ID reads one entry, which is how a single idea is addressed — there is no second route for it.
|
|
func (r PatentAPIGetPatentIdeasRequest) Id(id string) PatentAPIGetPatentIdeasRequest {
|
|
r.id = &id
|
|
return r
|
|
}
|
|
|
|
// Kind narrows to one kind of conception entry.
|
|
func (r PatentAPIGetPatentIdeasRequest) Kind(kind string) PatentAPIGetPatentIdeasRequest {
|
|
r.kind = &kind
|
|
return r
|
|
}
|
|
|
|
// Project narrows to one project; empty reads the org's whole set.
|
|
func (r PatentAPIGetPatentIdeasRequest) Project(project string) PatentAPIGetPatentIdeasRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentIdeasRequest) Execute() (*PatentIdeasOut, *http.Response, error) {
|
|
return r.ApiService.GetPatentIdeasExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentIdeas Returns the caller org's canonical conception entries, oldest appended first, which is the order the log says they were thought.
|
|
|
|
Returns the caller org's canonical conception entries, oldest
|
|
appended first, which is the order the log says they were thought. ?id= narrows
|
|
to one, ?kind= to one kind, ?project= to one project.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentIdeasRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentIdeas(ctx context.Context) PatentAPIGetPatentIdeasRequest {
|
|
return PatentAPIGetPatentIdeasRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentIdeasOut
|
|
func (a *PatentAPIService) GetPatentIdeasExecute(r PatentAPIGetPatentIdeasRequest) (*PatentIdeasOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentIdeasOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentIdeas")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/ideas"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.id != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "id", r.id, "form", "")
|
|
}
|
|
if r.kind != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "kind", r.kind, "form", "")
|
|
}
|
|
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 PatentAPIGetPatentImplementationsRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
id *string
|
|
idea *string
|
|
project *string
|
|
}
|
|
|
|
// ID reads one implementation.
|
|
func (r PatentAPIGetPatentImplementationsRequest) Id(id string) PatentAPIGetPatentImplementationsRequest {
|
|
r.id = &id
|
|
return r
|
|
}
|
|
|
|
// Idea narrows to implementations citing one conception entry — which is how a correction finds every artifact built on the idea it invalidates.
|
|
func (r PatentAPIGetPatentImplementationsRequest) Idea(idea string) PatentAPIGetPatentImplementationsRequest {
|
|
r.idea = &idea
|
|
return r
|
|
}
|
|
|
|
// Project narrows to one project.
|
|
func (r PatentAPIGetPatentImplementationsRequest) Project(project string) PatentAPIGetPatentImplementationsRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentImplementationsRequest) Execute() (*PatentImplsOut, *http.Response, error) {
|
|
return r.ApiService.GetPatentImplementationsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentImplementations Returns the canonical implementation records with their citations.
|
|
|
|
Returns the canonical implementation records with
|
|
their citations. ?idea= is the query the record exists to answer: which
|
|
artifacts rest on this one conception entry.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentImplementationsRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentImplementations(ctx context.Context) PatentAPIGetPatentImplementationsRequest {
|
|
return PatentAPIGetPatentImplementationsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentImplsOut
|
|
func (a *PatentAPIService) GetPatentImplementationsExecute(r PatentAPIGetPatentImplementationsRequest) (*PatentImplsOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentImplsOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentImplementations")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/implementations"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.id != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "id", r.id, "form", "")
|
|
}
|
|
if r.idea != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "idea", r.idea, "form", "")
|
|
}
|
|
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 PatentAPIGetPatentProofRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
disclosure *string
|
|
idea *string
|
|
project *string
|
|
}
|
|
|
|
// Disclosure folds the record set one document rests on, and reports on that set alone — which is what an attorney asks for.
|
|
func (r PatentAPIGetPatentProofRequest) Disclosure(disclosure string) PatentAPIGetPatentProofRequest {
|
|
r.disclosure = &disclosure
|
|
return r
|
|
}
|
|
|
|
// Idea narrows to the one entry and the artifacts citing it.
|
|
func (r PatentAPIGetPatentProofRequest) Idea(idea string) PatentAPIGetPatentProofRequest {
|
|
r.idea = &idea
|
|
return r
|
|
}
|
|
|
|
// Project narrows inside the org; empty reads the caller's scope.
|
|
func (r PatentAPIGetPatentProofRequest) Project(project string) PatentAPIGetPatentProofRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentProofRequest) Execute() (*PatentPatentProof, *http.Response, error) {
|
|
return r.ApiService.GetPatentProofExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentProof Folds the caller's record set and answers the ordering question over it.
|
|
|
|
Folds the caller's record set and answers the ordering question
|
|
over it.
|
|
|
|
?disclosure= proves one document's set, ?idea= proves one entry and everything
|
|
citing it, and neither proves the whole org. The answer is computed per request
|
|
and writes nothing.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentProofRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentProof(ctx context.Context) PatentAPIGetPatentProofRequest {
|
|
return PatentAPIGetPatentProofRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentProof
|
|
func (a *PatentAPIService) GetPatentProofExecute(r PatentAPIGetPatentProofRequest) (*PatentPatentProof, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentProof
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentProof")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/proof"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.disclosure != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "disclosure", r.disclosure, "form", "")
|
|
}
|
|
if r.idea != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "idea", r.idea, "form", "")
|
|
}
|
|
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 PatentAPIGetPatentTimelineRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
id *string
|
|
kind *string
|
|
project *string
|
|
}
|
|
|
|
// ID is the entry's stable id. Required.
|
|
func (r PatentAPIGetPatentTimelineRequest) Id(id string) PatentAPIGetPatentTimelineRequest {
|
|
r.id = &id
|
|
return r
|
|
}
|
|
|
|
// Kind is idea, implementation or disclosure — which log to read.
|
|
func (r PatentAPIGetPatentTimelineRequest) Kind(kind string) PatentAPIGetPatentTimelineRequest {
|
|
r.kind = &kind
|
|
return r
|
|
}
|
|
|
|
// Project narrows inside the org; empty is the caller's own scope.
|
|
func (r PatentAPIGetPatentTimelineRequest) Project(project string) PatentAPIGetPatentTimelineRequest {
|
|
r.project = &project
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIGetPatentTimelineRequest) Execute() (*PatentPatentTimeline, *http.Response, error) {
|
|
return r.ApiService.GetPatentTimelineExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatentTimeline Returns every retained version of one entry, in append order.
|
|
|
|
Returns every retained version of one entry, in append
|
|
order. ?id= names it and ?kind= says which log; a retraction is shown as the
|
|
withdrawal it is rather than hidden.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIGetPatentTimelineRequest
|
|
*/
|
|
func (a *PatentAPIService) GetPatentTimeline(ctx context.Context) PatentAPIGetPatentTimelineRequest {
|
|
return PatentAPIGetPatentTimelineRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentTimeline
|
|
func (a *PatentAPIService) GetPatentTimelineExecute(r PatentAPIGetPatentTimelineRequest) (*PatentPatentTimeline, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentTimeline
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.GetPatentTimeline")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/timeline"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.id != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "id", r.id, "form", "")
|
|
}
|
|
if r.kind != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "kind", r.kind, "form", "")
|
|
}
|
|
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 PatentAPIPostPatentApprovalsRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
patentApprovalBatch *PatentApprovalBatch
|
|
}
|
|
|
|
func (r PatentAPIPostPatentApprovalsRequest) PatentApprovalBatch(patentApprovalBatch PatentApprovalBatch) PatentAPIPostPatentApprovalsRequest {
|
|
r.patentApprovalBatch = &patentApprovalBatch
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIPostPatentApprovalsRequest) Execute() (*PatentPatentWriteOut, *http.Response, error) {
|
|
return r.ApiService.PostPatentApprovalsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatentApprovals Appends one person's decision about one disclosure.
|
|
|
|
Appends one person's decision about one disclosure. The
|
|
approver is the validated principal and nothing else, so no caller records a
|
|
sign-off on someone else's behalf — which is the only way this field would be
|
|
worth reading.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIPostPatentApprovalsRequest
|
|
*/
|
|
func (a *PatentAPIService) PostPatentApprovals(ctx context.Context) PatentAPIPostPatentApprovalsRequest {
|
|
return PatentAPIPostPatentApprovalsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentWriteOut
|
|
func (a *PatentAPIService) PostPatentApprovalsExecute(r PatentAPIPostPatentApprovalsRequest) (*PatentPatentWriteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentWriteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.PostPatentApprovals")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/approvals"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patentApprovalBatch == nil {
|
|
return localVarReturnValue, nil, reportError("patentApprovalBatch 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.patentApprovalBatch
|
|
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 PatentAPIPostPatentDisclosuresRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
patentDisclosureBatch *PatentDisclosureBatch
|
|
}
|
|
|
|
func (r PatentAPIPostPatentDisclosuresRequest) PatentDisclosureBatch(patentDisclosureBatch PatentDisclosureBatch) PatentAPIPostPatentDisclosuresRequest {
|
|
r.patentDisclosureBatch = &patentDisclosureBatch
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIPostPatentDisclosuresRequest) Execute() (*PatentPatentWriteOut, *http.Response, error) {
|
|
return r.ApiService.PostPatentDisclosuresExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatentDisclosures Appends the assembled document and the record ids it rests on.
|
|
|
|
Appends the assembled document and the record ids it
|
|
rests on. The document is a rendering of what the log already holds, and its
|
|
citations are what let a reader check it instead of taking it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIPostPatentDisclosuresRequest
|
|
*/
|
|
func (a *PatentAPIService) PostPatentDisclosures(ctx context.Context) PatentAPIPostPatentDisclosuresRequest {
|
|
return PatentAPIPostPatentDisclosuresRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentWriteOut
|
|
func (a *PatentAPIService) PostPatentDisclosuresExecute(r PatentAPIPostPatentDisclosuresRequest) (*PatentPatentWriteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentWriteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.PostPatentDisclosures")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/disclosures"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patentDisclosureBatch == nil {
|
|
return localVarReturnValue, nil, reportError("patentDisclosureBatch 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.patentDisclosureBatch
|
|
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 PatentAPIPostPatentGrantsRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
patentGrantIn *PatentGrantIn
|
|
}
|
|
|
|
func (r PatentAPIPostPatentGrantsRequest) PatentGrantIn(patentGrantIn PatentGrantIn) PatentAPIPostPatentGrantsRequest {
|
|
r.patentGrantIn = &patentGrantIn
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIPostPatentGrantsRequest) Execute() (*PatentPatentGrantOut, *http.Response, error) {
|
|
return r.ApiService.PostPatentGrantsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatentGrants Makes the decision a recording never implied: whether an idea, implementation or disclosure stays private to its author's project, opens to the org, or goes public.
|
|
|
|
Makes the decision a recording never implied: whether an
|
|
idea, implementation or disclosure stays private to its author's project, opens
|
|
to the org, or goes public. Publication of a conception entry is a
|
|
disclosure under 35 U.S.C. §102 in every jurisdiction that reads it that way,
|
|
so it is always a separate call and never a side effect of writing one down.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIPostPatentGrantsRequest
|
|
*/
|
|
func (a *PatentAPIService) PostPatentGrants(ctx context.Context) PatentAPIPostPatentGrantsRequest {
|
|
return PatentAPIPostPatentGrantsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentGrantOut
|
|
func (a *PatentAPIService) PostPatentGrantsExecute(r PatentAPIPostPatentGrantsRequest) (*PatentPatentGrantOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentGrantOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.PostPatentGrants")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/grants"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patentGrantIn == nil {
|
|
return localVarReturnValue, nil, reportError("patentGrantIn 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.patentGrantIn
|
|
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 PatentAPIPostPatentIdeasRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
patentIdeaBatch *PatentIdeaBatch
|
|
}
|
|
|
|
func (r PatentAPIPostPatentIdeasRequest) PatentIdeaBatch(patentIdeaBatch PatentIdeaBatch) PatentAPIPostPatentIdeasRequest {
|
|
r.patentIdeaBatch = &patentIdeaBatch
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIPostPatentIdeasRequest) Execute() (*PatentPatentWriteOut, *http.Response, error) {
|
|
return r.ApiService.PostPatentIdeasExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatentIdeas Appends conception entries.
|
|
|
|
Appends conception entries. A write states the idea and
|
|
nothing else: the project, the author, the clock, the append order and the
|
|
content digest are all the server's, and a correction appends a version rather
|
|
than editing the entry — which is the property that makes any of it usable as
|
|
evidence at all.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIPostPatentIdeasRequest
|
|
*/
|
|
func (a *PatentAPIService) PostPatentIdeas(ctx context.Context) PatentAPIPostPatentIdeasRequest {
|
|
return PatentAPIPostPatentIdeasRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentWriteOut
|
|
func (a *PatentAPIService) PostPatentIdeasExecute(r PatentAPIPostPatentIdeasRequest) (*PatentPatentWriteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentWriteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.PostPatentIdeas")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/ideas"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patentIdeaBatch == nil {
|
|
return localVarReturnValue, nil, reportError("patentIdeaBatch 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.patentIdeaBatch
|
|
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 PatentAPIPostPatentImplementationsRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatentAPIService
|
|
patentImplBatch *PatentImplBatch
|
|
}
|
|
|
|
func (r PatentAPIPostPatentImplementationsRequest) PatentImplBatch(patentImplBatch PatentImplBatch) PatentAPIPostPatentImplementationsRequest {
|
|
r.patentImplBatch = &patentImplBatch
|
|
return r
|
|
}
|
|
|
|
func (r PatentAPIPostPatentImplementationsRequest) Execute() (*PatentPatentWriteOut, *http.Response, error) {
|
|
return r.ApiService.PostPatentImplementationsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatentImplementations Appends the machine's half of the record, and the idea citation is the load-bearing field: it is what lets a reader see that the conception came first.
|
|
|
|
Appends the machine's half of the record, and the
|
|
idea citation is the load-bearing field: it is what lets a reader see that the
|
|
conception came first. An entry citing no idea is refused rather than filed.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatentAPIPostPatentImplementationsRequest
|
|
*/
|
|
func (a *PatentAPIService) PostPatentImplementations(ctx context.Context) PatentAPIPostPatentImplementationsRequest {
|
|
return PatentAPIPostPatentImplementationsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatentPatentWriteOut
|
|
func (a *PatentAPIService) PostPatentImplementationsExecute(r PatentAPIPostPatentImplementationsRequest) (*PatentPatentWriteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatentPatentWriteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatentAPIService.PostPatentImplementations")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patent/implementations"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patentImplBatch == nil {
|
|
return localVarReturnValue, nil, reportError("patentImplBatch 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.patentImplBatch
|
|
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
|
|
}
|