jocall3

package module
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 23, 2025 License: Apache-2.0 Imports: 15 Imported by: 0

README

Jocall3 Go API Library

Go Reference

The Jocall3 Go library provides convenient access to the Jocall3 REST API from applications written in Go.

It is generated with Stainless.

Installation

import (
	"github.com/jocall3/cli" // imported as jocall3
)

Or to pin the version:

go get -u 'github.com/jocall3/[email protected]'

Requirements

This library requires Go 1.22+.

Usage

The full API of this library can be found in api.md.

package main

import (
	"context"
	"fmt"

	"github.com/jocall3/cli"
)

func main() {
	client := jocall3.NewClient()
	user, err := client.Users.Register(context.TODO(), jocall3.UserRegisterParams{
		Email:    jocall3.F[any]("[email protected]"),
		Name:     jocall3.F[any]("Alice Wonderland"),
		Password: jocall3.F[any]("SecureP@ssw0rd2024!"),
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", user.ID)
}
Request fields

All request parameters are wrapped in a generic Field type, which we use to distinguish zero values from null or omitted fields.

This prevents accidentally sending a zero value if you forget a required parameter, and enables explicitly sending null, false, '', or 0 on optional parameters. Any field not specified is not sent.

To construct fields with values, use the helpers String(), Int(), Float(), or most commonly, the generic F[T](). To send a null, use Null[T](), and to send a nonconforming value, use Raw[T](any). For example:

params := FooParams{
	Name: jocall3.F("hello"),

	// Explicitly send `"description": null`
	Description: jocall3.Null[string](),

	Point: jocall3.F(jocall3.Point{
		X: jocall3.Int(0),
		Y: jocall3.Int(1),

		// In cases where the API specifies a given type,
		// but you want to send something else, use `Raw`:
		Z: jocall3.Raw[int64](0.01), // sends a float
	}),
}
Response objects

All fields in response structs are value types (not pointers or wrappers).

If a given field is null, not present, or invalid, the corresponding field will simply be its zero value.

All response structs also include a special JSON field, containing more detailed information about each property, which you can use like so:

if res.Name == "" {
	// true if `"name"` is either not present or explicitly null
	res.JSON.Name.IsNull()

	// true if the `"name"` key was not present in the response JSON at all
	res.JSON.Name.IsMissing()

	// When the API returns data that cannot be coerced to the expected type:
	if res.JSON.Name.IsInvalid() {
		raw := res.JSON.Name.Raw()

		legacyName := struct{
			First string `json:"first"`
			Last  string `json:"last"`
		}{}
		json.Unmarshal([]byte(raw), &legacyName)
		name = legacyName.First + " " + legacyName.Last
	}
}

These .JSON structs also include an Extras map containing any properties in the json response that were not specified in the struct. This can be useful for API features not yet present in the SDK.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
RequestOptions

This library uses the functional options pattern. Functions defined in the option package return a RequestOption, which is a closure that mutates a RequestConfig. These options can be supplied to the client or at individual requests. For example:

client := jocall3.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Users.Register(context.TODO(), ...,
	// Override the header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Add an undocumented field to the request body, using sjson syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

See the full list of request options.

Pagination

This library provides some conveniences for working with paginated list endpoints.

You can use .ListAutoPaging() methods to iterate through items across all pages:

Or you can use simple .List() methods to fetch a single page and receive a standard response object with additional helper methods like .GetNextPage(), e.g.:

Errors

When the API returns a non-success status code, we return an error with type *jocall3.Error. This contains the StatusCode, *http.Request, and *http.Response values of the request, as well as the JSON of the error body (much like other response objects in the SDK).

To handle errors, we recommend that you use the errors.As pattern:

_, err := client.Users.Register(context.TODO(), jocall3.UserRegisterParams{
	Email:    jocall3.F[any]("[email protected]"),
	Name:     jocall3.F[any]("Alice Wonderland"),
	Password: jocall3.F[any]("SecureP@ssw0rd2024!"),
})
if err != nil {
	var apierr *jocall3.Error
	if errors.As(err, &apierr) {
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // GET "/users/register": 400 Bad Request { ... }
}

When other errors occur, they are returned unwrapped; for example, if HTTP transport fails, you might receive *url.Error wrapping *net.OpError.

Timeouts

Requests do not time out by default; use context to configure a timeout for a request lifecycle.

Note that if a request is retried, the context timeout does not start over. To set a per-retry timeout, use option.WithRequestTimeout().

// This sets the timeout for the request, including all the retries.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
client.Users.Register(
	ctx,
	jocall3.UserRegisterParams{
		Email:    jocall3.F[any]("[email protected]"),
		Name:     jocall3.F[any]("Alice Wonderland"),
		Password: jocall3.F[any]("SecureP@ssw0rd2024!"),
	},
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

Request parameters that correspond to file uploads in multipart requests are typed as param.Field[io.Reader]. The contents of the io.Reader will by default be sent as a multipart form part with the file name of "anonymous_file" and content-type of "application/octet-stream".

The file name and content-type can be customized by implementing Name() string or ContentType() string on the run-time type of io.Reader. Note that os.File implements Name() string, so a file returned by os.Open will be sent with the file name on disk.

We also provide a helper jocall3.FileParam(reader io.Reader, filename string, contentType string) which can be used to wrap any io.Reader with the appropriate file name and content type.

Retries

Certain errors will be automatically retried 2 times by default, with a short exponential backoff. We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors.

You can use the WithMaxRetries option to configure or disable this:

// Configure the default for all requests:
client := jocall3.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Users.Register(
	context.TODO(),
	jocall3.UserRegisterParams{
		Email:    jocall3.F[any]("[email protected]"),
		Name:     jocall3.F[any]("Alice Wonderland"),
		Password: jocall3.F[any]("SecureP@ssw0rd2024!"),
	},
	option.WithMaxRetries(5),
)
Accessing raw response data (e.g. response headers)

You can access the raw HTTP response data by using the option.WithResponseInto() request option. This is useful when you need to examine response headers, status codes, or other details.

// Create a variable to store the HTTP response
var response *http.Response
user, err := client.Users.Register(
	context.TODO(),
	jocall3.UserRegisterParams{
		Email:    jocall3.F[any]("[email protected]"),
		Name:     jocall3.F[any]("Alice Wonderland"),
		Password: jocall3.F[any]("SecureP@ssw0rd2024!"),
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", user)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)
Making custom/undocumented requests

This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, params, or response properties, the library can still be used.

Undocumented endpoints

To make requests to undocumented endpoints, you can use client.Get, client.Post, and other HTTP verbs. RequestOptions on the client, such as retries, will be respected when making these requests.

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]interface{}

    // result can be an []byte, *http.Response, a encoding/json deserializable object,
    // or a model defined in this library.
    result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
    …
}
Undocumented request params

To make requests using undocumented parameters, you may use either the option.WithQuerySet() or the option.WithJSONSet() methods.

params := FooNewParams{
    ID:   jocall3.F("id_xxxx"),
    Data: jocall3.F(FooNewParamsData{
        FirstName: jocall3.F("John"),
    }),
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
Undocumented response properties

To access undocumented response properties, you may either access the raw JSON of the response as a string with result.JSON.RawJSON(), or get the raw JSON of a particular field on the result with result.JSON.Foo.Raw().

Any fields that are not present on the response struct will be saved and can be accessed by result.JSON.ExtraFields() which returns the extra fields as a map[string]Field.

Middleware

We provide option.WithMiddleware which applies the given middleware to requests.

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	LogReq(req)

	// Forward the request to the next handler
	res, err = next(req)

	// Handle stuff after the request
	end := time.Now()
	LogRes(res, err, start - end)

    return res, err
}

client := jocall3.NewClient(
	option.WithMiddleware(Logger),
)

When multiple middlewares are provided as variadic arguments, the middlewares are applied left to right. If option.WithMiddleware is given multiple times, for example first in the client then the method, the middleware in the client will run first and the middleware given in the method will run next.

You may also replace the default http.Client with option.WithHTTPClient(client). Only one http client is accepted (this overwrites any previous client) and receives requests after any middleware has been applied.

Semantic versioning

This package generally follows SemVer conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes to library internals which are technically public but not intended or documented for external use. (Please open a GitHub issue to let us know if you are relying on such internals.)
  2. Changes that we do not expect to impact the vast majority of users in practice.

We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

We are keen for your feedback; please open an issue with questions, bugs, or suggestions.

Contributing

See the contributing documentation.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool 

func Bool(value bool) param.Field[bool]

Bool is a param field helper which helps specify bools.

func DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

DefaultClientOptions read from the environment (1231_API_KEY, 1231_BIOMETRIC_TOKEN, JOCALL3_BASE_URL). This should be used to initialize new clients.

func F 

func F[T any](value T) param.Field[T]

F is a param field helper used to initialize a param.Field generic struct. This helps specify null, zero values, and overrides, as well as normal values. You can read more about this in our README.

func FileParam 

func FileParam(reader io.Reader, filename string, contentType string) param.Field[io.Reader]

FileParam is a param field helper which helps files with a mime content-type.

func Float 

func Float(value float64) param.Field[float64]

Float is a param field helper which helps specify floats.

func Int 

func Int(value int64) param.Field[int64]

Int is a param field helper which helps specify integers. This is particularly helpful when specifying integer constants for fields.

func Null 

func Null[T any]() param.Field[T]

Null is a param field helper which explicitly sends null to the API.

func Raw 

func Raw[T any](value any) param.Field[T]

Raw is a param field helper for specifying values for fields when the type you are looking to send is different from the type that is specified in the SDK. For example, if the type of the field is an integer, but you want to send a float, you could do that by setting the corresponding field with Raw[int](0.5).

func String 

func String(value string) param.Field[string]

String is a param field helper which helps specify strings.

Types

type AIAdGenerateAdvancedParams 

type AIAdGenerateAdvancedParams struct {
	// Desired length of the video in seconds.
	LengthSeconds param.Field[interface{}] `json:"lengthSeconds,required"`
	// The textual prompt to guide the AI video generation.
	Prompt param.Field[interface{}] `json:"prompt,required"`
	// Artistic style of the video.
	Style param.Field[AIAdGenerateAdvancedParamsStyle] `json:"style,required"`
	// Aspect ratio of the video (e.g., 16:9 for widescreen, 9:16 for vertical shorts).
	AspectRatio param.Field[AIAdGenerateAdvancedParamsAspectRatio] `json:"aspectRatio"`
	// Target audience for the ad, influencing tone and visuals.
	AudienceTarget param.Field[AIAdGenerateAdvancedParamsAudienceTarget] `json:"audienceTarget"`
	// Genre of background music.
	BackgroundMusicGenre param.Field[AIAdGenerateAdvancedParamsBackgroundMusicGenre] `json:"backgroundMusicGenre"`
	// URLs to brand assets (e.g., logos, specific imagery) to be incorporated.
	BrandAssets param.Field[[]interface{}] `json:"brandAssets"`
	// Optional: Hex color codes to influence the video's aesthetic.
	BrandColors param.Field[[]interface{}] `json:"brandColors"`
	// Call-to-action text and URL to be displayed.
	CallToAction param.Field[AIAdGenerateAdvancedParamsCallToAction] `json:"callToAction"`
	// Optional: Additional keywords to guide the AI's content generation.
	Keywords param.Field[[]interface{}] `json:"keywords"`
	// Style/tone for the AI voiceover.
	VoiceoverStyle param.Field[AIAdGenerateAdvancedParamsVoiceoverStyle] `json:"voiceoverStyle"`
	// Optional: Text for an AI-generated voiceover.
	VoiceoverText param.Field[interface{}] `json:"voiceoverText"`
}

func (AIAdGenerateAdvancedParams) MarshalJSON 

func (r AIAdGenerateAdvancedParams) MarshalJSON() (data []byte, err error)

type AIAdGenerateAdvancedParamsAspectRatio 

type AIAdGenerateAdvancedParamsAspectRatio string

Aspect ratio of the video (e.g., 16:9 for widescreen, 9:16 for vertical shorts). 

const (
	AIAdGenerateAdvancedParamsAspectRatio16_9 AIAdGenerateAdvancedParamsAspectRatio = "16:9"
	AIAdGenerateAdvancedParamsAspectRatio9_16 AIAdGenerateAdvancedParamsAspectRatio = "9:16"
	AIAdGenerateAdvancedParamsAspectRatio1_1  AIAdGenerateAdvancedParamsAspectRatio = "1:1"
)

func (AIAdGenerateAdvancedParamsAspectRatio) IsKnown 

func (r AIAdGenerateAdvancedParamsAspectRatio) IsKnown() bool

type AIAdGenerateAdvancedParamsAudienceTarget 

type AIAdGenerateAdvancedParamsAudienceTarget string

Target audience for the ad, influencing tone and visuals. 

const (
	AIAdGenerateAdvancedParamsAudienceTargetGeneral   AIAdGenerateAdvancedParamsAudienceTarget = "general"
	AIAdGenerateAdvancedParamsAudienceTargetCorporate AIAdGenerateAdvancedParamsAudienceTarget = "corporate"
	AIAdGenerateAdvancedParamsAudienceTargetInvestor  AIAdGenerateAdvancedParamsAudienceTarget = "investor"
	AIAdGenerateAdvancedParamsAudienceTargetYouth     AIAdGenerateAdvancedParamsAudienceTarget = "youth"
)

func (AIAdGenerateAdvancedParamsAudienceTarget) IsKnown 

func (r AIAdGenerateAdvancedParamsAudienceTarget) IsKnown() bool

type AIAdGenerateAdvancedParamsBackgroundMusicGenre 

type AIAdGenerateAdvancedParamsBackgroundMusicGenre string

Genre of background music. 

const (
	AIAdGenerateAdvancedParamsBackgroundMusicGenreCorporate AIAdGenerateAdvancedParamsBackgroundMusicGenre = "corporate"
	AIAdGenerateAdvancedParamsBackgroundMusicGenreUplifting AIAdGenerateAdvancedParamsBackgroundMusicGenre = "uplifting"
	AIAdGenerateAdvancedParamsBackgroundMusicGenreAmbient   AIAdGenerateAdvancedParamsBackgroundMusicGenre = "ambient"
	AIAdGenerateAdvancedParamsBackgroundMusicGenreCinematic AIAdGenerateAdvancedParamsBackgroundMusicGenre = "cinematic"
	AIAdGenerateAdvancedParamsBackgroundMusicGenreNone      AIAdGenerateAdvancedParamsBackgroundMusicGenre = "none"
)

func (AIAdGenerateAdvancedParamsBackgroundMusicGenre) IsKnown 

func (r AIAdGenerateAdvancedParamsBackgroundMusicGenre) IsKnown() bool

type AIAdGenerateAdvancedParamsCallToAction 

type AIAdGenerateAdvancedParamsCallToAction struct {
	DisplayTimeSeconds param.Field[interface{}] `json:"displayTimeSeconds"`
	Text               param.Field[interface{}] `json:"text"`
	URL                param.Field[interface{}] `json:"url"`
}

Call-to-action text and URL to be displayed.

func (AIAdGenerateAdvancedParamsCallToAction) MarshalJSON 

func (r AIAdGenerateAdvancedParamsCallToAction) MarshalJSON() (data []byte, err error)

type AIAdGenerateAdvancedParamsStyle 

type AIAdGenerateAdvancedParamsStyle string

Artistic style of the video. 

const (
	AIAdGenerateAdvancedParamsStyleCinematic   AIAdGenerateAdvancedParamsStyle = "Cinematic"
	AIAdGenerateAdvancedParamsStyleExplainer   AIAdGenerateAdvancedParamsStyle = "Explainer"
	AIAdGenerateAdvancedParamsStyleDocumentary AIAdGenerateAdvancedParamsStyle = "Documentary"
	AIAdGenerateAdvancedParamsStyleAbstract    AIAdGenerateAdvancedParamsStyle = "Abstract"
	AIAdGenerateAdvancedParamsStyleMinimalist  AIAdGenerateAdvancedParamsStyle = "Minimalist"
)

func (AIAdGenerateAdvancedParamsStyle) IsKnown 

func (r AIAdGenerateAdvancedParamsStyle) IsKnown() bool

type AIAdGenerateAdvancedParamsVoiceoverStyle 

type AIAdGenerateAdvancedParamsVoiceoverStyle string

Style/tone for the AI voiceover. 

const (
	AIAdGenerateAdvancedParamsVoiceoverStyleMaleProfessional AIAdGenerateAdvancedParamsVoiceoverStyle = "male_professional"
	AIAdGenerateAdvancedParamsVoiceoverStyleFemaleFriendly   AIAdGenerateAdvancedParamsVoiceoverStyle = "female_friendly"
	AIAdGenerateAdvancedParamsVoiceoverStyleNeutralCalm      AIAdGenerateAdvancedParamsVoiceoverStyle = "neutral_calm"
)

func (AIAdGenerateAdvancedParamsVoiceoverStyle) IsKnown 

func (r AIAdGenerateAdvancedParamsVoiceoverStyle) IsKnown() bool

type AIAdGenerateAdvancedResponse 

type AIAdGenerateAdvancedResponse struct {
	// Estimated time until advanced video generation is complete. May be longer than
	// standard generation.
	EstimatedCompletionTimeSeconds interface{} `json:"estimatedCompletionTimeSeconds"`
	// The unique identifier for the advanced video generation operation.
	OperationID interface{}                      `json:"operationId"`
	JSON        aiAdGenerateAdvancedResponseJSON `json:"-"`
}

func (*AIAdGenerateAdvancedResponse) UnmarshalJSON 

func (r *AIAdGenerateAdvancedResponse) UnmarshalJSON(data []byte) (err error)

type AIAdGenerateService 

type AIAdGenerateService struct {
	Options []option.RequestOption
}

AIAdGenerateService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIAdGenerateService method instead.

func NewAIAdGenerateService 

func NewAIAdGenerateService(opts ...option.RequestOption) (r *AIAdGenerateService)

NewAIAdGenerateService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIAdGenerateService) Advanced 

func (r *AIAdGenerateService) Advanced(ctx context.Context, body AIAdGenerateAdvancedParams, opts ...option.RequestOption) (res *AIAdGenerateAdvancedResponse, err error)

Submits a highly customized request to generate a video ad, allowing fine-grained control over artistic style, aspect ratio, voiceover, background music, target audience, and call-to-action elements for professional-grade productions.

func (*AIAdGenerateService) Standard 

func (r *AIAdGenerateService) Standard(ctx context.Context, body AIAdGenerateStandardParams, opts ...option.RequestOption) (res *AIAdGenerateStandardResponse, err error)

Submits a request to generate a high-quality video ad using the advanced Veo 2.0 generative AI model. This is an asynchronous operation, suitable for standard ad content creation.

type AIAdGenerateStandardParams 

type AIAdGenerateStandardParams struct {
	GenerateVideo GenerateVideoParam `json:"generate_video,required"`
}

func (AIAdGenerateStandardParams) MarshalJSON 

func (r AIAdGenerateStandardParams) MarshalJSON() (data []byte, err error)

type AIAdGenerateStandardResponse 

type AIAdGenerateStandardResponse struct {
	// Estimated time until video generation is complete.
	EstimatedCompletionTimeSeconds interface{} `json:"estimatedCompletionTimeSeconds"`
	// The unique identifier for the video generation operation.
	OperationID interface{}                      `json:"operationId"`
	JSON        aiAdGenerateStandardResponseJSON `json:"-"`
}

func (*AIAdGenerateStandardResponse) UnmarshalJSON 

func (r *AIAdGenerateStandardResponse) UnmarshalJSON(data []byte) (err error)

type AIAdListGeneratedParams 

type AIAdListGeneratedParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Filter ads by their generation status.
	Status param.Field[AIAdListGeneratedParamsStatus] `query:"status"`
}

func (AIAdListGeneratedParams) URLQuery 

func (r AIAdListGeneratedParams) URLQuery() (v url.Values)

URLQuery serializes AIAdListGeneratedParams's query parameters as `url.Values`.

type AIAdListGeneratedParamsStatus 

type AIAdListGeneratedParamsStatus string

Filter ads by their generation status. 

const (
	AIAdListGeneratedParamsStatusQueued     AIAdListGeneratedParamsStatus = "queued"
	AIAdListGeneratedParamsStatusGenerating AIAdListGeneratedParamsStatus = "generating"
	AIAdListGeneratedParamsStatusDone       AIAdListGeneratedParamsStatus = "done"
	AIAdListGeneratedParamsStatusError      AIAdListGeneratedParamsStatus = "error"
)

func (AIAdListGeneratedParamsStatus) IsKnown 

func (r AIAdListGeneratedParamsStatus) IsKnown() bool

type AIAdListGeneratedResponse 

type AIAdListGeneratedResponse struct {
	Data []VideoOperationStatus        `json:"data"`
	JSON aiAdListGeneratedResponseJSON `json:"-"`
	PaginatedList
}

func (*AIAdListGeneratedResponse) UnmarshalJSON 

func (r *AIAdListGeneratedResponse) UnmarshalJSON(data []byte) (err error)

type AIAdService 

type AIAdService struct {
	Options  []option.RequestOption
	Generate *AIAdGenerateService
}

AIAdService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIAdService method instead.

func NewAIAdService 

func NewAIAdService(opts ...option.RequestOption) (r *AIAdService)

NewAIAdService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIAdService) GetStatus 

func (r *AIAdService) GetStatus(ctx context.Context, operationID interface{}, opts ...option.RequestOption) (res *VideoOperationStatus, err error)

Polls the real-time status of an asynchronous video generation operation. Once complete ('done'), the response includes a temporary, signed URL to access and download the generated video asset.

func (*AIAdService) ListGenerated 

func (r *AIAdService) ListGenerated(ctx context.Context, query AIAdListGeneratedParams, opts ...option.RequestOption) (res *AIAdListGeneratedResponse, err error)

Retrieves a list of all video advertisements previously generated by the user in the AI Ad Studio.

type AIAdvisorChatGetHistoryParams 

type AIAdvisorChatGetHistoryParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Optional: Filter history by a specific session ID. If omitted, recent
	// conversations will be returned.
	SessionID param.Field[interface{}] `query:"sessionId"`
}

func (AIAdvisorChatGetHistoryParams) URLQuery 

func (r AIAdvisorChatGetHistoryParams) URLQuery() (v url.Values)

URLQuery serializes AIAdvisorChatGetHistoryParams's query parameters as `url.Values`.

type AIAdvisorChatGetHistoryResponse 

type AIAdvisorChatGetHistoryResponse struct {
	Data []AIAdvisorChatGetHistoryResponseData `json:"data"`
	JSON aiAdvisorChatGetHistoryResponseJSON   `json:"-"`
	PaginatedList
}

func (*AIAdvisorChatGetHistoryResponse) UnmarshalJSON 

func (r *AIAdvisorChatGetHistoryResponse) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatGetHistoryResponseData 

type AIAdvisorChatGetHistoryResponseData struct {
	// The textual content of the message.
	Content interface{} `json:"content,required"`
	// Role of the speaker (user, assistant, or tool interaction).
	Role AIAdvisorChatGetHistoryResponseDataRole `json:"role,required"`
	// Timestamp of the message.
	Timestamp interface{} `json:"timestamp,required"`
	// If role is 'tool_call', details of the tool function called by the AI.
	FunctionCall AIAdvisorChatGetHistoryResponseDataFunctionCall `json:"functionCall"`
	// If role is 'tool_response', the output from the tool function.
	FunctionResponse AIAdvisorChatGetHistoryResponseDataFunctionResponse `json:"functionResponse"`
	JSON             aiAdvisorChatGetHistoryResponseDataJSON             `json:"-"`
}

func (*AIAdvisorChatGetHistoryResponseData) UnmarshalJSON 

func (r *AIAdvisorChatGetHistoryResponseData) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatGetHistoryResponseDataFunctionCall 

type AIAdvisorChatGetHistoryResponseDataFunctionCall struct {
	Args interface{}                                         `json:"args"`
	Name interface{}                                         `json:"name"`
	JSON aiAdvisorChatGetHistoryResponseDataFunctionCallJSON `json:"-"`
}

If role is 'tool_call', details of the tool function called by the AI.

func (*AIAdvisorChatGetHistoryResponseDataFunctionCall) UnmarshalJSON 

func (r *AIAdvisorChatGetHistoryResponseDataFunctionCall) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatGetHistoryResponseDataFunctionResponse 

type AIAdvisorChatGetHistoryResponseDataFunctionResponse struct {
	Name     interface{}                                             `json:"name"`
	Response interface{}                                             `json:"response"`
	JSON     aiAdvisorChatGetHistoryResponseDataFunctionResponseJSON `json:"-"`
}

If role is 'tool_response', the output from the tool function.

func (*AIAdvisorChatGetHistoryResponseDataFunctionResponse) UnmarshalJSON 

func (r *AIAdvisorChatGetHistoryResponseDataFunctionResponse) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatGetHistoryResponseDataRole 

type AIAdvisorChatGetHistoryResponseDataRole string

Role of the speaker (user, assistant, or tool interaction). 

const (
	AIAdvisorChatGetHistoryResponseDataRoleUser         AIAdvisorChatGetHistoryResponseDataRole = "user"
	AIAdvisorChatGetHistoryResponseDataRoleAssistant    AIAdvisorChatGetHistoryResponseDataRole = "assistant"
	AIAdvisorChatGetHistoryResponseDataRoleToolCall     AIAdvisorChatGetHistoryResponseDataRole = "tool_call"
	AIAdvisorChatGetHistoryResponseDataRoleToolResponse AIAdvisorChatGetHistoryResponseDataRole = "tool_response"
)

func (AIAdvisorChatGetHistoryResponseDataRole) IsKnown 

func (r AIAdvisorChatGetHistoryResponseDataRole) IsKnown() bool

type AIAdvisorChatSendMessageParams 

type AIAdvisorChatSendMessageParams struct {
	// Optional: The output from a tool function that the AI previously requested to be
	// executed.
	FunctionResponse param.Field[AIAdvisorChatSendMessageParamsFunctionResponse] `json:"functionResponse"`
	// The user's textual input to the AI Advisor.
	Message param.Field[interface{}] `json:"message"`
	// Optional: Session ID to continue a conversation. If omitted, a new session is
	// started.
	SessionID param.Field[interface{}] `json:"sessionId"`
}

func (AIAdvisorChatSendMessageParams) MarshalJSON 

func (r AIAdvisorChatSendMessageParams) MarshalJSON() (data []byte, err error)

type AIAdvisorChatSendMessageParamsFunctionResponse 

type AIAdvisorChatSendMessageParamsFunctionResponse struct {
	// The name of the tool function for which this is a response.
	Name param.Field[interface{}] `json:"name"`
	// The JSON output from the execution of the tool function.
	Response param.Field[interface{}] `json:"response"`
}

Optional: The output from a tool function that the AI previously requested to be executed.

func (AIAdvisorChatSendMessageParamsFunctionResponse) MarshalJSON 

func (r AIAdvisorChatSendMessageParamsFunctionResponse) MarshalJSON() (data []byte, err error)

type AIAdvisorChatSendMessageResponse 

type AIAdvisorChatSendMessageResponse struct {
	// The active conversation session ID.
	SessionID interface{} `json:"sessionId,required"`
	// A list of tool functions the AI wants the system to execute.
	FunctionCalls []AIAdvisorChatSendMessageResponseFunctionCall `json:"functionCalls,nullable"`
	// A list of proactive AI insights or recommendations generated by Quantum.
	ProactiveInsights []AIInsight `json:"proactiveInsights,nullable"`
	// Indicates if the AI's response implies that the user needs to take a specific
	// action (e.g., provide more input, confirm a tool call).
	RequiresUserAction interface{} `json:"requiresUserAction"`
	// The AI Advisor's textual response.
	Text interface{}                          `json:"text"`
	JSON aiAdvisorChatSendMessageResponseJSON `json:"-"`
}

func (*AIAdvisorChatSendMessageResponse) UnmarshalJSON 

func (r *AIAdvisorChatSendMessageResponse) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatSendMessageResponseFunctionCall 

type AIAdvisorChatSendMessageResponseFunctionCall struct {
	// Unique ID for this tool call, used to link with `functionResponse`.
	ID interface{} `json:"id"`
	// Key-value pairs representing the arguments to pass to the tool function.
	Args interface{} `json:"args"`
	// The name of the tool function to call.
	Name interface{}                                      `json:"name"`
	JSON aiAdvisorChatSendMessageResponseFunctionCallJSON `json:"-"`
}

func (*AIAdvisorChatSendMessageResponseFunctionCall) UnmarshalJSON 

func (r *AIAdvisorChatSendMessageResponseFunctionCall) UnmarshalJSON(data []byte) (err error)

type AIAdvisorChatService 

type AIAdvisorChatService struct {
	Options []option.RequestOption
}

AIAdvisorChatService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIAdvisorChatService method instead.

func NewAIAdvisorChatService 

func NewAIAdvisorChatService(opts ...option.RequestOption) (r *AIAdvisorChatService)

NewAIAdvisorChatService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIAdvisorChatService) GetHistory 

func (r *AIAdvisorChatService) GetHistory(ctx context.Context, query AIAdvisorChatGetHistoryParams, opts ...option.RequestOption) (res *AIAdvisorChatGetHistoryResponse, err error)

Fetches the full conversation history with the Quantum AI Advisor for a given session or user.

func (*AIAdvisorChatService) SendMessage 

func (r *AIAdvisorChatService) SendMessage(ctx context.Context, body AIAdvisorChatSendMessageParams, opts ...option.RequestOption) (res *AIAdvisorChatSendMessageResponse, err error)

Initiates or continues a sophisticated conversation with Quantum, the AI Advisor. Quantum can provide advanced financial insights, execute complex tasks via an expanding suite of intelligent tools, and learn from user interactions to offer hyper-personalized guidance.

type AIAdvisorListToolsParams 

type AIAdvisorListToolsParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (AIAdvisorListToolsParams) URLQuery 

func (r AIAdvisorListToolsParams) URLQuery() (v url.Values)

URLQuery serializes AIAdvisorListToolsParams's query parameters as `url.Values`.

type AIAdvisorListToolsResponse 

type AIAdvisorListToolsResponse struct {
	Data []AIAdvisorListToolsResponseData `json:"data"`
	JSON aiAdvisorListToolsResponseJSON   `json:"-"`
	PaginatedList
}

func (*AIAdvisorListToolsResponse) UnmarshalJSON 

func (r *AIAdvisorListToolsResponse) UnmarshalJSON(data []byte) (err error)

type AIAdvisorListToolsResponseData 

type AIAdvisorListToolsResponseData struct {
	// The OAuth2 scope required to execute this tool.
	AccessScope interface{} `json:"accessScope,required"`
	// A description of what the tool does.
	Description interface{} `json:"description,required"`
	// The unique name of the AI tool (function name).
	Name interface{} `json:"name,required"`
	// OpenAPI schema object defining the input parameters for the tool function.
	Parameters AIAdvisorListToolsResponseDataParameters `json:"parameters,required"`
	JSON       aiAdvisorListToolsResponseDataJSON       `json:"-"`
}

func (*AIAdvisorListToolsResponseData) UnmarshalJSON 

func (r *AIAdvisorListToolsResponseData) UnmarshalJSON(data []byte) (err error)

type AIAdvisorListToolsResponseDataParameters 

type AIAdvisorListToolsResponseDataParameters struct {
	Properties interface{}                                  `json:"properties"`
	Required   []interface{}                                `json:"required"`
	Type       AIAdvisorListToolsResponseDataParametersType `json:"type"`
	JSON       aiAdvisorListToolsResponseDataParametersJSON `json:"-"`
}

OpenAPI schema object defining the input parameters for the tool function.

func (*AIAdvisorListToolsResponseDataParameters) UnmarshalJSON 

func (r *AIAdvisorListToolsResponseDataParameters) UnmarshalJSON(data []byte) (err error)

type AIAdvisorListToolsResponseDataParametersType 

type AIAdvisorListToolsResponseDataParametersType string
const (
	AIAdvisorListToolsResponseDataParametersTypeObject AIAdvisorListToolsResponseDataParametersType = "object"
)

func (AIAdvisorListToolsResponseDataParametersType) IsKnown 

func (r AIAdvisorListToolsResponseDataParametersType) IsKnown() bool

type AIAdvisorService 

type AIAdvisorService struct {
	Options []option.RequestOption
	Chat    *AIAdvisorChatService
}

AIAdvisorService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIAdvisorService method instead.

func NewAIAdvisorService 

func NewAIAdvisorService(opts ...option.RequestOption) (r *AIAdvisorService)

NewAIAdvisorService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIAdvisorService) ListTools 

func (r *AIAdvisorService) ListTools(ctx context.Context, query AIAdvisorListToolsParams, opts ...option.RequestOption) (res *AIAdvisorListToolsResponse, err error)

Retrieves a dynamic manifest of all integrated AI tools that Quantum can invoke and execute, providing details on their capabilities, parameters, and access requirements.

type AIIncubatorListPitchesParams 

type AIIncubatorListPitchesParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Filter pitches by their current stage.
	Status param.Field[AIIncubatorListPitchesParamsStatus] `query:"status"`
}

func (AIIncubatorListPitchesParams) URLQuery 

func (r AIIncubatorListPitchesParams) URLQuery() (v url.Values)

URLQuery serializes AIIncubatorListPitchesParams's query parameters as `url.Values`.

type AIIncubatorListPitchesParamsStatus 

type AIIncubatorListPitchesParamsStatus string

Filter pitches by their current stage. 

const (
	AIIncubatorListPitchesParamsStatusSubmitted          AIIncubatorListPitchesParamsStatus = "submitted"
	AIIncubatorListPitchesParamsStatusInitialReview      AIIncubatorListPitchesParamsStatus = "initial_review"
	AIIncubatorListPitchesParamsStatusAIAnalysis         AIIncubatorListPitchesParamsStatus = "ai_analysis"
	AIIncubatorListPitchesParamsStatusFeedbackRequired   AIIncubatorListPitchesParamsStatus = "feedback_required"
	AIIncubatorListPitchesParamsStatusTestPhase          AIIncubatorListPitchesParamsStatus = "test_phase"
	AIIncubatorListPitchesParamsStatusFinalReview        AIIncubatorListPitchesParamsStatus = "final_review"
	AIIncubatorListPitchesParamsStatusApprovedForFunding AIIncubatorListPitchesParamsStatus = "approved_for_funding"
	AIIncubatorListPitchesParamsStatusRejected           AIIncubatorListPitchesParamsStatus = "rejected"
	AIIncubatorListPitchesParamsStatusIncubatedGraduated AIIncubatorListPitchesParamsStatus = "incubated_graduated"
)

func (AIIncubatorListPitchesParamsStatus) IsKnown 

func (r AIIncubatorListPitchesParamsStatus) IsKnown() bool

type AIIncubatorListPitchesResponse 

type AIIncubatorListPitchesResponse struct {
	Data []QuantumWeaverState               `json:"data"`
	JSON aiIncubatorListPitchesResponseJSON `json:"-"`
	PaginatedList
}

func (*AIIncubatorListPitchesResponse) UnmarshalJSON 

func (r *AIIncubatorListPitchesResponse) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponse 

type AIIncubatorPitchGetDetailsResponse struct {
	// AI-generated coaching plan for the entrepreneur.
	AICoachingPlan AIIncubatorPitchGetDetailsResponseAICoachingPlan `json:"aiCoachingPlan,nullable"`
	// AI's detailed financial model analysis.
	AIFinancialModel AIIncubatorPitchGetDetailsResponseAIFinancialModel `json:"aiFinancialModel,nullable"`
	// AI's detailed market analysis.
	AIMarketAnalysis AIIncubatorPitchGetDetailsResponseAIMarketAnalysis `json:"aiMarketAnalysis,nullable"`
	// AI's assessment of risks associated with the venture.
	AIRiskAssessment AIIncubatorPitchGetDetailsResponseAIRiskAssessment `json:"aiRiskAssessment,nullable"`
	// AI's score for how well the pitch matches potential investors in the network
	// (0-1).
	InvestorMatchScore interface{}                            `json:"investorMatchScore"`
	JSON               aiIncubatorPitchGetDetailsResponseJSON `json:"-"`
	QuantumWeaverState
}

func (*AIIncubatorPitchGetDetailsResponse) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponse) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAICoachingPlan 

type AIIncubatorPitchGetDetailsResponseAICoachingPlan struct {
	Steps   []AIIncubatorPitchGetDetailsResponseAICoachingPlanStep `json:"steps"`
	Summary interface{}                                            `json:"summary"`
	Title   interface{}                                            `json:"title"`
	JSON    aiIncubatorPitchGetDetailsResponseAICoachingPlanJSON   `json:"-"`
}

AI-generated coaching plan for the entrepreneur.

func (*AIIncubatorPitchGetDetailsResponseAICoachingPlan) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAICoachingPlan) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStep 

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStep struct {
	Description interface{}                                                     `json:"description"`
	Resources   []AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsResource `json:"resources"`
	Status      AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus     `json:"status"`
	Timeline    interface{}                                                     `json:"timeline"`
	Title       interface{}                                                     `json:"title"`
	JSON        aiIncubatorPitchGetDetailsResponseAICoachingPlanStepJSON        `json:"-"`
}

func (*AIIncubatorPitchGetDetailsResponseAICoachingPlanStep) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAICoachingPlanStep) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsResource 

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsResource struct {
	Name interface{}                                                       `json:"name"`
	URL  interface{}                                                       `json:"url"`
	JSON aiIncubatorPitchGetDetailsResponseAICoachingPlanStepsResourceJSON `json:"-"`
}

func (*AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsResource) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsResource) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus 

type AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus string
const (
	AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatusPending    AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus = "pending"
	AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatusInProgress AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus = "in_progress"
	AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatusCompleted  AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus = "completed"
)

func (AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus) IsKnown 

func (r AIIncubatorPitchGetDetailsResponseAICoachingPlanStepsStatus) IsKnown() bool

type AIIncubatorPitchGetDetailsResponseAIFinancialModel 

type AIIncubatorPitchGetDetailsResponseAIFinancialModel struct {
	BreakevenPoint        interface{}                                                             `json:"breakevenPoint"`
	CapitalRequirements   interface{}                                                             `json:"capitalRequirements"`
	CostStructureAnalysis interface{}                                                             `json:"costStructureAnalysis"`
	RevenueBreakdown      interface{}                                                             `json:"revenueBreakdown"`
	SensitivityAnalysis   []AIIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysis `json:"sensitivityAnalysis"`
	JSON                  aiIncubatorPitchGetDetailsResponseAIFinancialModelJSON                  `json:"-"`
}

AI's detailed financial model analysis.

func (*AIIncubatorPitchGetDetailsResponseAIFinancialModel) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAIFinancialModel) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysis 

type AIIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysis struct {
	ProjectedIrr  interface{}                                                               `json:"projectedIRR"`
	Scenario      interface{}                                                               `json:"scenario"`
	TerminalValue interface{}                                                               `json:"terminalValue"`
	JSON          aiIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysisJSON `json:"-"`
}

func (*AIIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysis) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAIFinancialModelSensitivityAnalysis) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAIMarketAnalysis 

type AIIncubatorPitchGetDetailsResponseAIMarketAnalysis struct {
	CompetitiveAdvantages []interface{}                                          `json:"competitiveAdvantages"`
	GrowthOpportunities   interface{}                                            `json:"growthOpportunities"`
	RiskFactors           interface{}                                            `json:"riskFactors"`
	TargetMarketSize      interface{}                                            `json:"targetMarketSize"`
	JSON                  aiIncubatorPitchGetDetailsResponseAIMarketAnalysisJSON `json:"-"`
}

AI's detailed market analysis.

func (*AIIncubatorPitchGetDetailsResponseAIMarketAnalysis) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAIMarketAnalysis) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchGetDetailsResponseAIRiskAssessment 

type AIIncubatorPitchGetDetailsResponseAIRiskAssessment struct {
	MarketRisk    interface{}                                            `json:"marketRisk"`
	TeamRisk      interface{}                                            `json:"teamRisk"`
	TechnicalRisk interface{}                                            `json:"technicalRisk"`
	JSON          aiIncubatorPitchGetDetailsResponseAIRiskAssessmentJSON `json:"-"`
}

AI's assessment of risks associated with the venture.

func (*AIIncubatorPitchGetDetailsResponseAIRiskAssessment) UnmarshalJSON 

func (r *AIIncubatorPitchGetDetailsResponseAIRiskAssessment) UnmarshalJSON(data []byte) (err error)

type AIIncubatorPitchService 

type AIIncubatorPitchService struct {
	Options []option.RequestOption
}

AIIncubatorPitchService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIIncubatorPitchService method instead.

func NewAIIncubatorPitchService 

func NewAIIncubatorPitchService(opts ...option.RequestOption) (r *AIIncubatorPitchService)

NewAIIncubatorPitchService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIIncubatorPitchService) GetDetails 

func (r *AIIncubatorPitchService) GetDetails(ctx context.Context, pitchID interface{}, opts ...option.RequestOption) (res *AIIncubatorPitchGetDetailsResponse, err error)

Retrieves the granular AI-driven analysis, strategic feedback, market validation results, and any outstanding questions from Quantum Weaver for a specific business pitch.

func (*AIIncubatorPitchService) Submit 

func (r *AIIncubatorPitchService) Submit(ctx context.Context, body AIIncubatorPitchSubmitParams, opts ...option.RequestOption) (res *QuantumWeaverState, err error)

Submits a detailed business plan to the Quantum Weaver AI for rigorous analysis, market validation, and seed funding consideration. This initiates the AI-driven incubation journey, aiming to transform innovative ideas into commercially successful ventures.

func (*AIIncubatorPitchService) SubmitFeedback 

func (r *AIIncubatorPitchService) SubmitFeedback(ctx context.Context, pitchID interface{}, body AIIncubatorPitchSubmitFeedbackParams, opts ...option.RequestOption) (res *QuantumWeaverState, err error)

Allows the entrepreneur to respond to specific questions or provide additional details requested by Quantum Weaver, moving the pitch forward in the incubation process.

type AIIncubatorPitchSubmitFeedbackParams 

type AIIncubatorPitchSubmitFeedbackParams struct {
	Answers param.Field[[]AIIncubatorPitchSubmitFeedbackParamsAnswer] `json:"answers"`
	// General textual feedback or additional details for Quantum Weaver.
	Feedback param.Field[interface{}] `json:"feedback"`
}

func (AIIncubatorPitchSubmitFeedbackParams) MarshalJSON 

func (r AIIncubatorPitchSubmitFeedbackParams) MarshalJSON() (data []byte, err error)

type AIIncubatorPitchSubmitFeedbackParamsAnswer 

type AIIncubatorPitchSubmitFeedbackParamsAnswer struct {
	// The answer to the specific question.
	Answer param.Field[interface{}] `json:"answer,required"`
	// The ID of the question being answered.
	QuestionID param.Field[interface{}] `json:"questionId,required"`
}

func (AIIncubatorPitchSubmitFeedbackParamsAnswer) MarshalJSON 

func (r AIIncubatorPitchSubmitFeedbackParamsAnswer) MarshalJSON() (data []byte, err error)

type AIIncubatorPitchSubmitParams 

type AIIncubatorPitchSubmitParams struct {
	// The user's detailed narrative business plan (e.g., executive summary, vision,
	// strategy).
	BusinessPlan param.Field[interface{}] `json:"businessPlan,required"`
	// Key financial metrics and projections for the next 3-5 years.
	FinancialProjections param.Field[AIIncubatorPitchSubmitParamsFinancialProjections] `json:"financialProjections,required"`
	// Key profiles and expertise of the founding team members.
	FoundingTeam param.Field[[]AIIncubatorPitchSubmitParamsFoundingTeam] `json:"foundingTeam,required"`
	// Detailed analysis of the target market, problem statement, and proposed
	// solution's unique value proposition.
	MarketOpportunity param.Field[interface{}] `json:"marketOpportunity,required"`
}

func (AIIncubatorPitchSubmitParams) MarshalJSON 

func (r AIIncubatorPitchSubmitParams) MarshalJSON() (data []byte, err error)

type AIIncubatorPitchSubmitParamsFinancialProjections 

type AIIncubatorPitchSubmitParamsFinancialProjections struct {
	// Estimated time to profitability.
	ProfitabilityEstimate param.Field[interface{}] `json:"profitabilityEstimate"`
	// Number of years for financial projections.
	ProjectionYears param.Field[interface{}]   `json:"projectionYears"`
	RevenueForecast param.Field[[]interface{}] `json:"revenueForecast"`
	// Requested seed funding in USD.
	SeedRoundAmount param.Field[interface{}] `json:"seedRoundAmount"`
	// Pre-money valuation in USD.
	ValuationPreMoney param.Field[interface{}] `json:"valuationPreMoney"`
}

Key financial metrics and projections for the next 3-5 years.

func (AIIncubatorPitchSubmitParamsFinancialProjections) MarshalJSON 

func (r AIIncubatorPitchSubmitParamsFinancialProjections) MarshalJSON() (data []byte, err error)

type AIIncubatorPitchSubmitParamsFoundingTeam 

type AIIncubatorPitchSubmitParamsFoundingTeam struct {
	// Relevant experience.
	Experience param.Field[interface{}] `json:"experience"`
	// Name of the team member.
	Name param.Field[interface{}] `json:"name"`
	// Role of the team member.
	Role param.Field[interface{}] `json:"role"`
}

func (AIIncubatorPitchSubmitParamsFoundingTeam) MarshalJSON 

func (r AIIncubatorPitchSubmitParamsFoundingTeam) MarshalJSON() (data []byte, err error)

type AIIncubatorService 

type AIIncubatorService struct {
	Options []option.RequestOption
	Pitch   *AIIncubatorPitchService
}

AIIncubatorService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIIncubatorService method instead.

func NewAIIncubatorService 

func NewAIIncubatorService(opts ...option.RequestOption) (r *AIIncubatorService)

NewAIIncubatorService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIIncubatorService) ListPitches 

func (r *AIIncubatorService) ListPitches(ctx context.Context, query AIIncubatorListPitchesParams, opts ...option.RequestOption) (res *AIIncubatorListPitchesResponse, err error)

Retrieves a summary list of all business pitches submitted by the authenticated user to Quantum Weaver.

type AIInsight 

type AIInsight struct {
	// Unique identifier for the AI insight.
	ID interface{} `json:"id,required"`
	// Category of the insight (e.g., spending, saving, investing).
	Category AIInsightCategory `json:"category,required"`
	// Detailed explanation of the insight.
	Description interface{} `json:"description,required"`
	// AI-assessed severity or importance of the insight.
	Severity AIInsightSeverity `json:"severity,required"`
	// Timestamp when the insight was generated.
	Timestamp interface{} `json:"timestamp,required"`
	// A concise title for the insight.
	Title interface{} `json:"title,required"`
	// Optional: A concrete action the user can take based on the insight.
	ActionableRecommendation interface{} `json:"actionableRecommendation"`
	// Optional: A programmatic trigger or deep link to initiate the recommended
	// action.
	ActionTrigger interface{}   `json:"actionTrigger"`
	JSON          aiInsightJSON `json:"-"`
}

An AI-generated insight, alert, or recommendation.

func (*AIInsight) UnmarshalJSON 

func (r *AIInsight) UnmarshalJSON(data []byte) (err error)

type AIInsightCategory 

type AIInsightCategory string

Category of the insight (e.g., spending, saving, investing). 

const (
	AIInsightCategorySpending          AIInsightCategory = "spending"
	AIInsightCategorySaving            AIInsightCategory = "saving"
	AIInsightCategoryInvesting         AIInsightCategory = "investing"
	AIInsightCategoryBudgeting         AIInsightCategory = "budgeting"
	AIInsightCategorySecurity          AIInsightCategory = "security"
	AIInsightCategoryFinancialGoals    AIInsightCategory = "financial_goals"
	AIInsightCategorySustainability    AIInsightCategory = "sustainability"
	AIInsightCategoryCorporateTreasury AIInsightCategory = "corporate_treasury"
	AIInsightCategoryCompliance        AIInsightCategory = "compliance"
	AIInsightCategoryOther             AIInsightCategory = "other"
)

func (AIInsightCategory) IsKnown 

func (r AIInsightCategory) IsKnown() bool

type AIInsightSeverity 

type AIInsightSeverity string

AI-assessed severity or importance of the insight. 

const (
	AIInsightSeverityLow      AIInsightSeverity = "low"
	AIInsightSeverityMedium   AIInsightSeverity = "medium"
	AIInsightSeverityHigh     AIInsightSeverity = "high"
	AIInsightSeverityCritical AIInsightSeverity = "critical"
)

func (AIInsightSeverity) IsKnown 

func (r AIInsightSeverity) IsKnown() bool

type AIOracleService 

type AIOracleService struct {
	Options     []option.RequestOption
	Simulate    *AIOracleSimulateService
	Simulations *AIOracleSimulationService
}

AIOracleService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIOracleService method instead.

func NewAIOracleService 

func NewAIOracleService(opts ...option.RequestOption) (r *AIOracleService)

NewAIOracleService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type AIOracleSimulateRunAdvancedParams 

type AIOracleSimulateRunAdvancedParams struct {
	// A natural language prompt describing the complex, multi-variable scenario.
	Prompt    param.Field[interface{}]                                 `json:"prompt,required"`
	Scenarios param.Field[[]AIOracleSimulateRunAdvancedParamsScenario] `json:"scenarios,required"`
	// Optional: Global economic conditions to apply to all scenarios.
	GlobalEconomicFactors param.Field[AIOracleSimulateRunAdvancedParamsGlobalEconomicFactors] `json:"globalEconomicFactors"`
	// Optional: Personal financial assumptions to override defaults.
	PersonalAssumptions param.Field[AIOracleSimulateRunAdvancedParamsPersonalAssumptions] `json:"personalAssumptions"`
}

func (AIOracleSimulateRunAdvancedParams) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParams) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunAdvancedParamsGlobalEconomicFactors 

type AIOracleSimulateRunAdvancedParamsGlobalEconomicFactors struct {
	InflationRate        param.Field[interface{}] `json:"inflationRate"`
	InterestRateBaseline param.Field[interface{}] `json:"interestRateBaseline"`
}

Optional: Global economic conditions to apply to all scenarios.

func (AIOracleSimulateRunAdvancedParamsGlobalEconomicFactors) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParamsGlobalEconomicFactors) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunAdvancedParamsPersonalAssumptions 

type AIOracleSimulateRunAdvancedParamsPersonalAssumptions struct {
	AnnualSavingsRate param.Field[interface{}]                                                       `json:"annualSavingsRate"`
	RiskTolerance     param.Field[AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance] `json:"riskTolerance"`
}

Optional: Personal financial assumptions to override defaults.

func (AIOracleSimulateRunAdvancedParamsPersonalAssumptions) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParamsPersonalAssumptions) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance 

type AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance string
const (
	AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskToleranceConservative AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance = "conservative"
	AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskToleranceModerate     AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance = "moderate"
	AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskToleranceAggressive   AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance = "aggressive"
)

func (AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance) IsKnown 

func (r AIOracleSimulateRunAdvancedParamsPersonalAssumptionsRiskTolerance) IsKnown() bool

type AIOracleSimulateRunAdvancedParamsScenario 

type AIOracleSimulateRunAdvancedParamsScenario struct {
	// The duration in years over which this scenario is simulated.
	DurationYears param.Field[interface{}] `json:"durationYears,required"`
	// A list of discrete or continuous events that define this scenario.
	Events param.Field[[]AIOracleSimulateRunAdvancedParamsScenariosEvent] `json:"events,required"`
	// A descriptive name for this specific scenario.
	Name param.Field[interface{}] `json:"name,required"`
	// Parameters for multi-variable sensitivity analysis within this scenario.
	SensitivityAnalysisParams param.Field[[]AIOracleSimulateRunAdvancedParamsScenariosSensitivityAnalysisParam] `json:"sensitivityAnalysisParams"`
}

func (AIOracleSimulateRunAdvancedParamsScenario) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParamsScenario) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunAdvancedParamsScenariosEvent 

type AIOracleSimulateRunAdvancedParamsScenariosEvent struct {
	// Specific parameters for the event (e.g., durationMonths, impactPercentage).
	Details param.Field[interface{}]                                          `json:"details"`
	Type    param.Field[AIOracleSimulateRunAdvancedParamsScenariosEventsType] `json:"type"`
}

func (AIOracleSimulateRunAdvancedParamsScenariosEvent) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParamsScenariosEvent) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunAdvancedParamsScenariosEventsType 

type AIOracleSimulateRunAdvancedParamsScenariosEventsType string
const (
	AIOracleSimulateRunAdvancedParamsScenariosEventsTypeJobLoss          AIOracleSimulateRunAdvancedParamsScenariosEventsType = "job_loss"
	AIOracleSimulateRunAdvancedParamsScenariosEventsTypeMarketDownturn   AIOracleSimulateRunAdvancedParamsScenariosEventsType = "market_downturn"
	AIOracleSimulateRunAdvancedParamsScenariosEventsTypeLargePurchase    AIOracleSimulateRunAdvancedParamsScenariosEventsType = "large_purchase"
	AIOracleSimulateRunAdvancedParamsScenariosEventsTypeIncomeIncrease   AIOracleSimulateRunAdvancedParamsScenariosEventsType = "income_increase"
	AIOracleSimulateRunAdvancedParamsScenariosEventsTypeMedicalEmergency AIOracleSimulateRunAdvancedParamsScenariosEventsType = "medical_emergency"
)

func (AIOracleSimulateRunAdvancedParamsScenariosEventsType) IsKnown 

func (r AIOracleSimulateRunAdvancedParamsScenariosEventsType) IsKnown() bool

type AIOracleSimulateRunAdvancedParamsScenariosSensitivityAnalysisParam 

type AIOracleSimulateRunAdvancedParamsScenariosSensitivityAnalysisParam struct {
	// Maximum value for the parameter.
	Max param.Field[interface{}] `json:"max"`
	// Minimum value for the parameter.
	Min param.Field[interface{}] `json:"min"`
	// The name of the parameter to vary for sensitivity analysis (e.g.,
	// 'interestRate', 'inflationRate', 'marketRecoveryRate').
	ParamName param.Field[interface{}] `json:"paramName"`
	// Step increment for varying the parameter.
	Step param.Field[interface{}] `json:"step"`
}

func (AIOracleSimulateRunAdvancedParamsScenariosSensitivityAnalysisParam) MarshalJSON 

func (r AIOracleSimulateRunAdvancedParamsScenariosSensitivityAnalysisParam) MarshalJSON() (data []byte, err error)

type AIOracleSimulateRunStandardParams 

type AIOracleSimulateRunStandardParams struct {
	// A natural language prompt describing the 'what-if' scenario.
	Prompt param.Field[interface{}] `json:"prompt,required"`
	// Optional structured parameters to guide the simulation (e.g., duration, amount,
	// risk tolerance).
	Parameters param.Field[interface{}] `json:"parameters"`
}

func (AIOracleSimulateRunStandardParams) MarshalJSON 

func (r AIOracleSimulateRunStandardParams) MarshalJSON() (data []byte, err error)

type AIOracleSimulateService 

type AIOracleSimulateService struct {
	Options []option.RequestOption
}

AIOracleSimulateService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIOracleSimulateService method instead.

func NewAIOracleSimulateService 

func NewAIOracleSimulateService(opts ...option.RequestOption) (r *AIOracleSimulateService)

NewAIOracleSimulateService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIOracleSimulateService) RunAdvanced 

func (r *AIOracleSimulateService) RunAdvanced(ctx context.Context, body AIOracleSimulateRunAdvancedParams, opts ...option.RequestOption) (res *AdvancedSimulationResponse, err error)

Engages the Quantum Oracle for highly complex, multi-variable simulations, allowing precise control over numerous financial parameters, market conditions, and personal events to generate deep, predictive insights and sensitivity analysis.

func (*AIOracleSimulateService) RunStandard 

func (r *AIOracleSimulateService) RunStandard(ctx context.Context, body AIOracleSimulateRunStandardParams, opts ...option.RequestOption) (res *SimulationResponse, err error)

Submits a hypothetical scenario to the Quantum Oracle AI for standard financial impact analysis. The AI simulates the effect on the user's current financial state and provides a summary.

type AIOracleSimulationGetResponse 

type AIOracleSimulationGetResponse struct {
	// This field can have the runtime type of [interface{}].
	SimulationID interface{} `json:"simulationId,required"`
	// This field can have the runtime type of [[]SimulationResponseKeyImpact].
	KeyImpacts interface{} `json:"keyImpacts"`
	// This field can have the runtime type of [interface{}].
	NarrativeSummary interface{} `json:"narrativeSummary"`
	// This field can have the runtime type of [interface{}].
	OverallSummary interface{} `json:"overallSummary"`
	// This field can have the runtime type of [[]AIInsight].
	Recommendations interface{} `json:"recommendations"`
	// This field can have the runtime type of [SimulationResponseRiskAnalysis].
	RiskAnalysis interface{} `json:"riskAnalysis"`
	// This field can have the runtime type of
	// [[]AdvancedSimulationResponseScenarioResult].
	ScenarioResults interface{} `json:"scenarioResults"`
	// This field can have the runtime type of [[]AIInsight].
	StrategicRecommendations interface{} `json:"strategicRecommendations"`
	// This field can have the runtime type of [[]SimulationResponseVisualization].
	Visualizations interface{}                       `json:"visualizations"`
	JSON           aiOracleSimulationGetResponseJSON `json:"-"`
	// contains filtered or unexported fields
}

func (AIOracleSimulationGetResponse) AsUnion 

func (r AIOracleSimulationGetResponse) AsUnion() AIOracleSimulationGetResponseUnion

AsUnion returns a AIOracleSimulationGetResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are SimulationResponse, AdvancedSimulationResponse.

func (*AIOracleSimulationGetResponse) UnmarshalJSON 

func (r *AIOracleSimulationGetResponse) UnmarshalJSON(data []byte) (err error)

type AIOracleSimulationGetResponseUnion 

type AIOracleSimulationGetResponseUnion interface {
	// contains filtered or unexported methods
}

Union satisfied by SimulationResponse or AdvancedSimulationResponse.

type AIOracleSimulationListParams 

type AIOracleSimulationListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (AIOracleSimulationListParams) URLQuery 

func (r AIOracleSimulationListParams) URLQuery() (v url.Values)

URLQuery serializes AIOracleSimulationListParams's query parameters as `url.Values`.

type AIOracleSimulationListResponse 

type AIOracleSimulationListResponse struct {
	Data []AIOracleSimulationListResponseData `json:"data"`
	JSON aiOracleSimulationListResponseJSON   `json:"-"`
	PaginatedList
}

func (*AIOracleSimulationListResponse) UnmarshalJSON 

func (r *AIOracleSimulationListResponse) UnmarshalJSON(data []byte) (err error)

type AIOracleSimulationListResponseData 

type AIOracleSimulationListResponseData struct {
	// Timestamp when the simulation was initiated.
	CreationDate interface{} `json:"creationDate,required"`
	// Timestamp when the simulation status or results were last updated.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Unique identifier for the simulation.
	SimulationID interface{} `json:"simulationId,required"`
	// Current status of the simulation.
	Status AIOracleSimulationListResponseDataStatus `json:"status,required"`
	// A brief summary of what the simulation evaluated.
	Summary interface{} `json:"summary,required"`
	// A user-friendly title for the simulation.
	Title interface{}                            `json:"title,required"`
	JSON  aiOracleSimulationListResponseDataJSON `json:"-"`
}

func (*AIOracleSimulationListResponseData) UnmarshalJSON 

func (r *AIOracleSimulationListResponseData) UnmarshalJSON(data []byte) (err error)

type AIOracleSimulationListResponseDataStatus 

type AIOracleSimulationListResponseDataStatus string

Current status of the simulation. 

const (
	AIOracleSimulationListResponseDataStatusProcessing AIOracleSimulationListResponseDataStatus = "processing"
	AIOracleSimulationListResponseDataStatusCompleted  AIOracleSimulationListResponseDataStatus = "completed"
	AIOracleSimulationListResponseDataStatusFailed     AIOracleSimulationListResponseDataStatus = "failed"
)

func (AIOracleSimulationListResponseDataStatus) IsKnown 

func (r AIOracleSimulationListResponseDataStatus) IsKnown() bool

type AIOracleSimulationService 

type AIOracleSimulationService struct {
	Options []option.RequestOption
}

AIOracleSimulationService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIOracleSimulationService method instead.

func NewAIOracleSimulationService 

func NewAIOracleSimulationService(opts ...option.RequestOption) (r *AIOracleSimulationService)

NewAIOracleSimulationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AIOracleSimulationService) Delete 

func (r *AIOracleSimulationService) Delete(ctx context.Context, simulationID interface{}, opts ...option.RequestOption) (err error)

Deletes a previously run financial simulation and its results.

func (*AIOracleSimulationService) Get 

func (r *AIOracleSimulationService) Get(ctx context.Context, simulationID interface{}, opts ...option.RequestOption) (res *AIOracleSimulationGetResponse, err error)

Retrieves the full, detailed results of a specific financial simulation by its ID.

func (*AIOracleSimulationService) List 

func (r *AIOracleSimulationService) List(ctx context.Context, query AIOracleSimulationListParams, opts ...option.RequestOption) (res *AIOracleSimulationListResponse, err error)

Retrieves a list of all financial simulations previously run by the user, including their status and summaries.

type AIService 

type AIService struct {
	Options   []option.RequestOption
	Advisor   *AIAdvisorService
	Oracle    *AIOracleService
	Incubator *AIIncubatorService
	Ads       *AIAdService
}

AIService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAIService method instead.

func NewAIService 

func NewAIService(opts ...option.RequestOption) (r *AIService)

NewAIService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type APIKey 

type APIKey struct {
	// Unique identifier for the API key.
	ID interface{} `json:"id,required"`
	// Timestamp when the API key was created.
	CreatedAt interface{} `json:"createdAt,required"`
	// The non-secret prefix of the API key, used for identification.
	Prefix interface{} `json:"prefix,required"`
	// List of permissions granted to this API key.
	Scopes []interface{} `json:"scopes,required"`
	// Current status of the API key.
	Status APIKeyStatus `json:"status,required"`
	// Timestamp when the API key will expire, if set.
	ExpiresAt interface{} `json:"expiresAt"`
	// Timestamp of the last time this API key was used.
	LastUsed interface{} `json:"lastUsed"`
	JSON     apiKeyJSON  `json:"-"`
}

func (*APIKey) UnmarshalJSON 

func (r *APIKey) UnmarshalJSON(data []byte) (err error)

type APIKeyStatus 

type APIKeyStatus string

Current status of the API key. 

const (
	APIKeyStatusActive  APIKeyStatus = "active"
	APIKeyStatusRevoked APIKeyStatus = "revoked"
	APIKeyStatusExpired APIKeyStatus = "expired"
)

func (APIKeyStatus) IsKnown 

func (r APIKeyStatus) IsKnown() bool

type AccountGetDetailsResponse 

type AccountGetDetailsResponse struct {
	// Name of the primary holder for this account.
	AccountHolder interface{} `json:"accountHolder"`
	// Historical daily balance data.
	BalanceHistory []AccountGetDetailsResponseBalanceHistory `json:"balanceHistory"`
	// Annual interest rate (if applicable).
	InterestRate interface{} `json:"interestRate"`
	// Date the account was opened.
	OpenedDate        interface{}                                `json:"openedDate"`
	ProjectedCashFlow AccountGetDetailsResponseProjectedCashFlow `json:"projectedCashFlow"`
	// Total number of transactions in this account.
	TransactionsCount interface{}                   `json:"transactionsCount"`
	JSON              accountGetDetailsResponseJSON `json:"-"`
	LinkedAccount
}

Summary information for a linked financial account.

func (*AccountGetDetailsResponse) UnmarshalJSON 

func (r *AccountGetDetailsResponse) UnmarshalJSON(data []byte) (err error)

type AccountGetDetailsResponseBalanceHistory 

type AccountGetDetailsResponseBalanceHistory struct {
	Balance interface{}                                 `json:"balance"`
	Date    interface{}                                 `json:"date"`
	JSON    accountGetDetailsResponseBalanceHistoryJSON `json:"-"`
}

func (*AccountGetDetailsResponseBalanceHistory) UnmarshalJSON 

func (r *AccountGetDetailsResponseBalanceHistory) UnmarshalJSON(data []byte) (err error)

type AccountGetDetailsResponseProjectedCashFlow 

type AccountGetDetailsResponseProjectedCashFlow struct {
	// AI confidence score for the cash flow projection (0-100).
	ConfidenceScore interface{} `json:"confidenceScore"`
	// Projected cash flow for the next 30 days.
	Days30 interface{} `json:"days30"`
	// Projected cash flow for the next 90 days.
	Days90 interface{}                                    `json:"days90"`
	JSON   accountGetDetailsResponseProjectedCashFlowJSON `json:"-"`
}

func (*AccountGetDetailsResponseProjectedCashFlow) UnmarshalJSON 

func (r *AccountGetDetailsResponseProjectedCashFlow) UnmarshalJSON(data []byte) (err error)

type AccountGetMeParams 

type AccountGetMeParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (AccountGetMeParams) URLQuery 

func (r AccountGetMeParams) URLQuery() (v url.Values)

URLQuery serializes AccountGetMeParams's query parameters as `url.Values`.

type AccountGetMeResponse 

type AccountGetMeResponse struct {
	Data []LinkedAccount          `json:"data"`
	JSON accountGetMeResponseJSON `json:"-"`
	PaginatedList
}

func (*AccountGetMeResponse) UnmarshalJSON 

func (r *AccountGetMeResponse) UnmarshalJSON(data []byte) (err error)

type AccountGetStatementsParams 

type AccountGetStatementsParams struct {
	// Month for the statement (1-12).
	Month param.Field[interface{}] `query:"month,required"`
	// Year for the statement.
	Year param.Field[interface{}] `query:"year,required"`
	// Desired format for the statement. Use 'application/json' Accept header for
	// download links.
	Format param.Field[AccountGetStatementsParamsFormat] `query:"format"`
}

func (AccountGetStatementsParams) URLQuery 

func (r AccountGetStatementsParams) URLQuery() (v url.Values)

URLQuery serializes AccountGetStatementsParams's query parameters as `url.Values`.

type AccountGetStatementsParamsFormat 

type AccountGetStatementsParamsFormat string

Desired format for the statement. Use 'application/json' Accept header for download links. 

const (
	AccountGetStatementsParamsFormatPdf AccountGetStatementsParamsFormat = "pdf"
	AccountGetStatementsParamsFormatCsv AccountGetStatementsParamsFormat = "csv"
)

func (AccountGetStatementsParamsFormat) IsKnown 

func (r AccountGetStatementsParamsFormat) IsKnown() bool

type AccountGetStatementsResponse 

type AccountGetStatementsResponse struct {
	// The account ID the statement belongs to.
	AccountID interface{} `json:"accountId,required"`
	// Map of available download URLs for different formats.
	DownloadURLs AccountGetStatementsResponseDownloadURLs `json:"downloadUrls,required"`
	// The period covered by the statement.
	Period interface{} `json:"period,required"`
	// Unique identifier for the statement.
	StatementID interface{}                      `json:"statementId,required"`
	JSON        accountGetStatementsResponseJSON `json:"-"`
}

func (*AccountGetStatementsResponse) UnmarshalJSON 

func (r *AccountGetStatementsResponse) UnmarshalJSON(data []byte) (err error)

type AccountGetStatementsResponseDownloadURLs 

type AccountGetStatementsResponseDownloadURLs struct {
	// Signed URL to download the statement in CSV format.
	Csv interface{} `json:"csv"`
	// Signed URL to download the statement in PDF format.
	Pdf  interface{}                                  `json:"pdf"`
	JSON accountGetStatementsResponseDownloadURLsJSON `json:"-"`
}

Map of available download URLs for different formats.

func (*AccountGetStatementsResponseDownloadURLs) UnmarshalJSON 

func (r *AccountGetStatementsResponseDownloadURLs) UnmarshalJSON(data []byte) (err error)

type AccountLinkParams 

type AccountLinkParams struct {
	// Two-letter ISO country code of the institution.
	CountryCode param.Field[interface{}] `json:"countryCode,required"`
	// Name of the financial institution to link.
	InstitutionName param.Field[interface{}] `json:"institutionName,required"`
	// Optional: Specific identifier for a third-party linking provider (e.g., 'plaid',
	// 'finicity').
	ProviderIdentifier param.Field[interface{}] `json:"providerIdentifier"`
	// Optional: URI to redirect the user after completing the external authentication
	// flow.
	RedirectUri param.Field[interface{}] `json:"redirectUri"`
}

func (AccountLinkParams) MarshalJSON 

func (r AccountLinkParams) MarshalJSON() (data []byte, err error)

type AccountLinkResponse 

type AccountLinkResponse struct {
	// The URI to redirect the user to complete authentication with the external
	// institution.
	AuthUri interface{} `json:"authUri,required"`
	// Unique session ID for the account linking process.
	LinkSessionID interface{} `json:"linkSessionId,required"`
	// Current status of the linking process.
	Status AccountLinkResponseStatus `json:"status,required"`
	// A descriptive message regarding the next steps.
	Message interface{}             `json:"message"`
	JSON    accountLinkResponseJSON `json:"-"`
}

func (*AccountLinkResponse) UnmarshalJSON 

func (r *AccountLinkResponse) UnmarshalJSON(data []byte) (err error)

type AccountLinkResponseStatus 

type AccountLinkResponseStatus string

Current status of the linking process. 

const (
	AccountLinkResponseStatusPendingUserAction AccountLinkResponseStatus = "pending_user_action"
	AccountLinkResponseStatusCompleted         AccountLinkResponseStatus = "completed"
	AccountLinkResponseStatusFailed            AccountLinkResponseStatus = "failed"
)

func (AccountLinkResponseStatus) IsKnown 

func (r AccountLinkResponseStatus) IsKnown() bool

type AccountOverdraftSettingService 

type AccountOverdraftSettingService struct {
	Options []option.RequestOption
}

AccountOverdraftSettingService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAccountOverdraftSettingService method instead.

func NewAccountOverdraftSettingService 

func NewAccountOverdraftSettingService(opts ...option.RequestOption) (r *AccountOverdraftSettingService)

NewAccountOverdraftSettingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AccountOverdraftSettingService) GetOverdraftSettings 

func (r *AccountOverdraftSettingService) GetOverdraftSettings(ctx context.Context, accountID interface{}, opts ...option.RequestOption) (res *OverdraftSettings, err error)

Retrieves the current overdraft protection settings for a specific account.

func (*AccountOverdraftSettingService) UpdateOverdraftSettings 

func (r *AccountOverdraftSettingService) UpdateOverdraftSettings(ctx context.Context, accountID interface{}, body AccountOverdraftSettingUpdateOverdraftSettingsParams, opts ...option.RequestOption) (res *OverdraftSettings, err error)

Updates the overdraft protection settings for a specific account, enabling or disabling protection and configuring preferences.

type AccountOverdraftSettingUpdateOverdraftSettingsParams 

type AccountOverdraftSettingUpdateOverdraftSettingsParams struct {
	// Enable or disable overdraft protection.
	Enabled param.Field[interface{}] `json:"enabled"`
	// New preference for how overdraft fees are handled.
	FeePreference param.Field[AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference] `json:"feePreference"`
	// New ID of the linked savings account, if `linkToSavings` is true. Set to null to
	// unlink.
	LinkedSavingsAccountID param.Field[interface{}] `json:"linkedSavingsAccountId"`
	// Enable or disable linking to a savings account for overdraft coverage.
	LinkToSavings param.Field[interface{}] `json:"linkToSavings"`
	// New maximum amount for overdraft protection. Set to null to remove limit.
	ProtectionLimit param.Field[interface{}] `json:"protectionLimit"`
}

func (AccountOverdraftSettingUpdateOverdraftSettingsParams) MarshalJSON 

func (r AccountOverdraftSettingUpdateOverdraftSettingsParams) MarshalJSON() (data []byte, err error)

type AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference 

type AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference string

New preference for how overdraft fees are handled. 

const (
	AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreferenceAlwaysPay          AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference = "always_pay"
	AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreferenceDeclineIfOverLimit AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference = "decline_if_over_limit"
	AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreferenceAskMeFirst         AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference = "ask_me_first"
)

func (AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference) IsKnown 

func (r AccountOverdraftSettingUpdateOverdraftSettingsParamsFeePreference) IsKnown() bool

type AccountService 

type AccountService struct {
	Options           []option.RequestOption
	Transactions      *AccountTransactionService
	OverdraftSettings *AccountOverdraftSettingService
}

AccountService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAccountService method instead.

func NewAccountService 

func NewAccountService(opts ...option.RequestOption) (r *AccountService)

NewAccountService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AccountService) GetDetails 

func (r *AccountService) GetDetails(ctx context.Context, accountID interface{}, opts ...option.RequestOption) (res *AccountGetDetailsResponse, err error)

Retrieves comprehensive analytics for a specific financial account, including historical balance trends, projected cash flow, and AI-driven insights into spending patterns.

func (*AccountService) GetMe 

func (r *AccountService) GetMe(ctx context.Context, query AccountGetMeParams, opts ...option.RequestOption) (res *AccountGetMeResponse, err error)

Fetches a comprehensive, real-time list of all external financial accounts linked to the user's profile, including consolidated balances and institutional details.

func (*AccountService) GetStatements 

func (r *AccountService) GetStatements(ctx context.Context, accountID interface{}, query AccountGetStatementsParams, opts ...option.RequestOption) (res *AccountGetStatementsResponse, err error)

Fetches digital statements for a specific account, allowing filtering by date range and format. 

func (r *AccountService) Link(ctx context.Context, body AccountLinkParams, opts ...option.RequestOption) (res *AccountLinkResponse, err error)

Begins the secure process of linking a new external financial institution (e.g., another bank, investment platform) to the user's profile, typically involving a third-party tokenized flow.

type AccountTransactionGetPendingParams 

type AccountTransactionGetPendingParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (AccountTransactionGetPendingParams) URLQuery 

func (r AccountTransactionGetPendingParams) URLQuery() (v url.Values)

URLQuery serializes AccountTransactionGetPendingParams's query parameters as `url.Values`.

type AccountTransactionGetPendingResponse 

type AccountTransactionGetPendingResponse struct {
	Data []Transaction                            `json:"data"`
	JSON accountTransactionGetPendingResponseJSON `json:"-"`
	PaginatedList
}

func (*AccountTransactionGetPendingResponse) UnmarshalJSON 

func (r *AccountTransactionGetPendingResponse) UnmarshalJSON(data []byte) (err error)

type AccountTransactionService 

type AccountTransactionService struct {
	Options []option.RequestOption
}

AccountTransactionService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAccountTransactionService method instead.

func NewAccountTransactionService 

func NewAccountTransactionService(opts ...option.RequestOption) (r *AccountTransactionService)

NewAccountTransactionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AccountTransactionService) GetPending 

func (r *AccountTransactionService) GetPending(ctx context.Context, accountID interface{}, query AccountTransactionGetPendingParams, opts ...option.RequestOption) (res *AccountTransactionGetPendingResponse, err error)

Retrieves a list of pending transactions that have not yet cleared for a specific financial account.

type Address 

type Address struct {
	City    interface{} `json:"city"`
	Country interface{} `json:"country"`
	State   interface{} `json:"state"`
	Street  interface{} `json:"street"`
	Zip     interface{} `json:"zip"`
	JSON    addressJSON `json:"-"`
}

func (*Address) UnmarshalJSON 

func (r *Address) UnmarshalJSON(data []byte) (err error)

type AddressParam 

type AddressParam struct {
	City    param.Field[interface{}] `json:"city"`
	Country param.Field[interface{}] `json:"country"`
	State   param.Field[interface{}] `json:"state"`
	Street  param.Field[interface{}] `json:"street"`
	Zip     param.Field[interface{}] `json:"zip"`
}

func (AddressParam) MarshalJSON 

func (r AddressParam) MarshalJSON() (data []byte, err error)

type AdvancedSimulationResponse 

type AdvancedSimulationResponse struct {
	// A high-level summary of findings across all scenarios.
	OverallSummary  interface{}                                `json:"overallSummary,required"`
	ScenarioResults []AdvancedSimulationResponseScenarioResult `json:"scenarioResults,required"`
	// Unique identifier for the completed advanced simulation.
	SimulationID interface{} `json:"simulationId,required"`
	// Overarching strategic recommendations derived from the comparison of scenarios.
	StrategicRecommendations []AIInsight                    `json:"strategicRecommendations,nullable"`
	JSON                     advancedSimulationResponseJSON `json:"-"`
}

func (*AdvancedSimulationResponse) UnmarshalJSON 

func (r *AdvancedSimulationResponse) UnmarshalJSON(data []byte) (err error)

type AdvancedSimulationResponseScenarioResult 

type AdvancedSimulationResponseScenarioResult struct {
	// Summary of results for this specific scenario.
	NarrativeSummary interface{} `json:"narrativeSummary,required"`
	// Name of the individual scenario.
	ScenarioName interface{} `json:"scenarioName,required"`
	// Specific AI insights for this scenario.
	AIInsights []AIInsight `json:"aiInsights,nullable"`
	// Projected net worth at the end of the simulation period for this scenario.
	FinalNetWorthProjected interface{}                                               `json:"finalNetWorthProjected"`
	LiquidityMetrics       AdvancedSimulationResponseScenarioResultsLiquidityMetrics `json:"liquidityMetrics,nullable"`
	// Data for generating sensitivity analysis charts (e.g., how net worth changes as
	// a variable is adjusted).
	SensitivityAnalysisGraphs []AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraph `json:"sensitivityAnalysisGraphs,nullable"`
	JSON                      advancedSimulationResponseScenarioResultJSON                        `json:"-"`
}

func (*AdvancedSimulationResponseScenarioResult) UnmarshalJSON 

func (r *AdvancedSimulationResponseScenarioResult) UnmarshalJSON(data []byte) (err error)

type AdvancedSimulationResponseScenarioResultsLiquidityMetrics 

type AdvancedSimulationResponseScenarioResultsLiquidityMetrics struct {
	// Minimum cash balance reached during the scenario.
	MinCashBalance interface{} `json:"minCashBalance"`
	// Time in months to recover to pre-event financial state.
	RecoveryTimeMonths interface{}                                                   `json:"recoveryTimeMonths"`
	JSON               advancedSimulationResponseScenarioResultsLiquidityMetricsJSON `json:"-"`
}

func (*AdvancedSimulationResponseScenarioResultsLiquidityMetrics) UnmarshalJSON 

func (r *AdvancedSimulationResponseScenarioResultsLiquidityMetrics) UnmarshalJSON(data []byte) (err error)

type AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraph 

type AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraph struct {
	Data      []AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsData `json:"data"`
	ParamName interface{}                                                              `json:"paramName"`
	JSON      advancedSimulationResponseScenarioResultsSensitivityAnalysisGraphJSON    `json:"-"`
}

func (*AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraph) UnmarshalJSON 

func (r *AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraph) UnmarshalJSON(data []byte) (err error)

type AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsData 

type AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsData struct {
	OutcomeValue interface{}                                                                `json:"outcomeValue"`
	ParamValue   interface{}                                                                `json:"paramValue"`
	JSON         advancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsDataJSON `json:"-"`
}

func (*AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsData) UnmarshalJSON 

func (r *AdvancedSimulationResponseScenarioResultsSensitivityAnalysisGraphsData) UnmarshalJSON(data []byte) (err error)

type BiometricStatus 

type BiometricStatus struct {
	// Overall status indicating if any biometrics are enrolled.
	BiometricsEnrolled interface{} `json:"biometricsEnrolled,required"`
	// List of specific biometric types and devices enrolled.
	EnrolledBiometrics []BiometricStatusEnrolledBiometric `json:"enrolledBiometrics,required"`
	// Timestamp of the last successful biometric authentication.
	LastUsed interface{}         `json:"lastUsed"`
	JSON     biometricStatusJSON `json:"-"`
}

Current biometric enrollment status for a user.

func (*BiometricStatus) UnmarshalJSON 

func (r *BiometricStatus) UnmarshalJSON(data []byte) (err error)

type BiometricStatusEnrolledBiometric 

type BiometricStatusEnrolledBiometric struct {
	DeviceID       interface{}                           `json:"deviceId"`
	EnrollmentDate interface{}                           `json:"enrollmentDate"`
	Type           BiometricStatusEnrolledBiometricsType `json:"type"`
	JSON           biometricStatusEnrolledBiometricJSON  `json:"-"`
}

func (*BiometricStatusEnrolledBiometric) UnmarshalJSON 

func (r *BiometricStatusEnrolledBiometric) UnmarshalJSON(data []byte) (err error)

type BiometricStatusEnrolledBiometricsType 

type BiometricStatusEnrolledBiometricsType string
const (
	BiometricStatusEnrolledBiometricsTypeFingerprint       BiometricStatusEnrolledBiometricsType = "fingerprint"
	BiometricStatusEnrolledBiometricsTypeFacialRecognition BiometricStatusEnrolledBiometricsType = "facial_recognition"
	BiometricStatusEnrolledBiometricsTypeVoiceRecognition  BiometricStatusEnrolledBiometricsType = "voice_recognition"
)

func (BiometricStatusEnrolledBiometricsType) IsKnown 

func (r BiometricStatusEnrolledBiometricsType) IsKnown() bool

type Budget 

type Budget struct {
	// Unique identifier for the budget.
	ID interface{} `json:"id,required"`
	// Percentage threshold at which an alert is triggered (e.g., 80% spent).
	AlertThreshold interface{} `json:"alertThreshold,required"`
	// Breakdown of the budget by categories.
	Categories []BudgetCategory `json:"categories,required"`
	// End date of the budget period.
	EndDate interface{} `json:"endDate,required"`
	// Name of the budget.
	Name interface{} `json:"name,required"`
	// The frequency or period of the budget.
	Period BudgetPeriod `json:"period,required"`
	// Remaining amount in the budget.
	RemainingAmount interface{} `json:"remainingAmount,required"`
	// Total amount spent against this budget so far.
	SpentAmount interface{} `json:"spentAmount,required"`
	// Start date of the budget period.
	StartDate interface{} `json:"startDate,required"`
	// Current status of the budget.
	Status BudgetStatus `json:"status,required"`
	// Total amount allocated for the entire budget.
	TotalAmount interface{} `json:"totalAmount,required"`
	// AI-driven recommendations related to this budget.
	AIRecommendations []AIInsight `json:"aiRecommendations,nullable"`
	JSON              budgetJSON  `json:"-"`
}

func (*Budget) UnmarshalJSON 

func (r *Budget) UnmarshalJSON(data []byte) (err error)

type BudgetCategory 

type BudgetCategory struct {
	// Amount allocated to this category.
	Allocated interface{} `json:"allocated,required"`
	// Name of the budget category.
	Name interface{} `json:"name,required"`
	// Remaining amount in this category.
	Remaining interface{} `json:"remaining,required"`
	// Amount spent in this category so far.
	Spent interface{}        `json:"spent,required"`
	JSON  budgetCategoryJSON `json:"-"`
}

func (*BudgetCategory) UnmarshalJSON 

func (r *BudgetCategory) UnmarshalJSON(data []byte) (err error)

type BudgetListParams 

type BudgetListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (BudgetListParams) URLQuery 

func (r BudgetListParams) URLQuery() (v url.Values)

URLQuery serializes BudgetListParams's query parameters as `url.Values`.

type BudgetListResponse 

type BudgetListResponse struct {
	Data []Budget               `json:"data"`
	JSON budgetListResponseJSON `json:"-"`
	PaginatedList
}

func (*BudgetListResponse) UnmarshalJSON 

func (r *BudgetListResponse) UnmarshalJSON(data []byte) (err error)

type BudgetNewParams 

type BudgetNewParams struct {
	// End date of the budget period.
	EndDate param.Field[interface{}] `json:"endDate,required"`
	// Name of the new budget.
	Name param.Field[interface{}] `json:"name,required"`
	// The frequency or period of the budget.
	Period param.Field[BudgetNewParamsPeriod] `json:"period,required"`
	// Start date of the budget period.
	StartDate param.Field[interface{}] `json:"startDate,required"`
	// Total amount allocated for the entire budget.
	TotalAmount param.Field[interface{}] `json:"totalAmount,required"`
	// If true, AI will automatically populate categories and amounts based on
	// historical spending.
	AIAutoPopulate param.Field[interface{}] `json:"aiAutoPopulate"`
	// Percentage threshold at which an alert is triggered.
	AlertThreshold param.Field[interface{}] `json:"alertThreshold"`
	// Initial breakdown of the budget by categories.
	Categories param.Field[[]BudgetNewParamsCategory] `json:"categories"`
}

func (BudgetNewParams) MarshalJSON 

func (r BudgetNewParams) MarshalJSON() (data []byte, err error)

type BudgetNewParamsCategory 

type BudgetNewParamsCategory struct {
	Allocated param.Field[interface{}] `json:"allocated"`
	Name      param.Field[interface{}] `json:"name"`
}

func (BudgetNewParamsCategory) MarshalJSON 

func (r BudgetNewParamsCategory) MarshalJSON() (data []byte, err error)

type BudgetNewParamsPeriod 

type BudgetNewParamsPeriod string

The frequency or period of the budget. 

const (
	BudgetNewParamsPeriodWeekly    BudgetNewParamsPeriod = "weekly"
	BudgetNewParamsPeriodBiWeekly  BudgetNewParamsPeriod = "bi_weekly"
	BudgetNewParamsPeriodMonthly   BudgetNewParamsPeriod = "monthly"
	BudgetNewParamsPeriodQuarterly BudgetNewParamsPeriod = "quarterly"
	BudgetNewParamsPeriodAnnually  BudgetNewParamsPeriod = "annually"
	BudgetNewParamsPeriodCustom    BudgetNewParamsPeriod = "custom"
)

func (BudgetNewParamsPeriod) IsKnown 

func (r BudgetNewParamsPeriod) IsKnown() bool

type BudgetPeriod 

type BudgetPeriod string

The frequency or period of the budget. 

const (
	BudgetPeriodWeekly    BudgetPeriod = "weekly"
	BudgetPeriodBiWeekly  BudgetPeriod = "bi_weekly"
	BudgetPeriodMonthly   BudgetPeriod = "monthly"
	BudgetPeriodQuarterly BudgetPeriod = "quarterly"
	BudgetPeriodAnnually  BudgetPeriod = "annually"
	BudgetPeriodCustom    BudgetPeriod = "custom"
)

func (BudgetPeriod) IsKnown 

func (r BudgetPeriod) IsKnown() bool

type BudgetService 

type BudgetService struct {
	Options []option.RequestOption
}

BudgetService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewBudgetService method instead.

func NewBudgetService 

func NewBudgetService(opts ...option.RequestOption) (r *BudgetService)

NewBudgetService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*BudgetService) Delete 

func (r *BudgetService) Delete(ctx context.Context, budgetID interface{}, opts ...option.RequestOption) (err error)

Deletes a specific budget from the user's profile.

func (*BudgetService) Get 

func (r *BudgetService) Get(ctx context.Context, budgetID interface{}, opts ...option.RequestOption) (res *Budget, err error)

Retrieves detailed information for a specific budget, including current spending, remaining amounts, and AI recommendations.

func (*BudgetService) List 

func (r *BudgetService) List(ctx context.Context, query BudgetListParams, opts ...option.RequestOption) (res *BudgetListResponse, err error)

Retrieves a list of all active and historical budgets for the authenticated user.

func (*BudgetService) New 

func (r *BudgetService) New(ctx context.Context, body BudgetNewParams, opts ...option.RequestOption) (res *Budget, err error)

Creates a new financial budget for the user, with optional AI auto-population of categories and amounts.

func (*BudgetService) Update 

func (r *BudgetService) Update(ctx context.Context, budgetID interface{}, body BudgetUpdateParams, opts ...option.RequestOption) (res *Budget, err error)

Updates the parameters of an existing budget, such as total amount, dates, or categories.

type BudgetStatus 

type BudgetStatus string

Current status of the budget. 

const (
	BudgetStatusActive   BudgetStatus = "active"
	BudgetStatusArchived BudgetStatus = "archived"
	BudgetStatusEnded    BudgetStatus = "ended"
)

func (BudgetStatus) IsKnown 

func (r BudgetStatus) IsKnown() bool

type BudgetUpdateParams 

type BudgetUpdateParams struct {
	// Updated percentage threshold for alerts.
	AlertThreshold param.Field[interface{}] `json:"alertThreshold"`
	// Updated breakdown of the budget by categories. Existing categories will be
	// updated, new ones added.
	Categories param.Field[[]BudgetUpdateParamsCategory] `json:"categories"`
	// Updated end date of the budget period.
	EndDate param.Field[interface{}] `json:"endDate"`
	// Updated name of the budget.
	Name param.Field[interface{}] `json:"name"`
	// Updated start date of the budget period.
	StartDate param.Field[interface{}] `json:"startDate"`
	// Updated status of the budget.
	Status param.Field[BudgetUpdateParamsStatus] `json:"status"`
	// Updated total amount for the entire budget.
	TotalAmount param.Field[interface{}] `json:"totalAmount"`
}

func (BudgetUpdateParams) MarshalJSON 

func (r BudgetUpdateParams) MarshalJSON() (data []byte, err error)

type BudgetUpdateParamsCategory 

type BudgetUpdateParamsCategory struct {
	Allocated param.Field[interface{}] `json:"allocated"`
	Name      param.Field[interface{}] `json:"name"`
}

func (BudgetUpdateParamsCategory) MarshalJSON 

func (r BudgetUpdateParamsCategory) MarshalJSON() (data []byte, err error)

type BudgetUpdateParamsStatus 

type BudgetUpdateParamsStatus string

Updated status of the budget. 

const (
	BudgetUpdateParamsStatusActive   BudgetUpdateParamsStatus = "active"
	BudgetUpdateParamsStatusArchived BudgetUpdateParamsStatus = "archived"
	BudgetUpdateParamsStatusEnded    BudgetUpdateParamsStatus = "ended"
)

func (BudgetUpdateParamsStatus) IsKnown 

func (r BudgetUpdateParamsStatus) IsKnown() bool

type Client 

type Client struct {
	Options        []option.RequestOption
	Users          *UserService
	Accounts       *AccountService
	Transactions   *TransactionService
	Budgets        *BudgetService
	Investments    *InvestmentService
	AI             *AIService
	Corporate      *CorporateService
	Web3           *Web3Service
	Payments       *PaymentService
	Sustainability *SustainabilityService
	Lending        *LendingService
	Developers     *DeveloperService
	Identity       *IdentityService
	Goals          *GoalService
	Notifications  *NotificationService
	Marketplace    *MarketplaceService
}

Client creates a struct with services and top level methods that help with interacting with the jocall3 API. You should not instantiate this client directly, and instead use the NewClient method instead.

func NewClient 

func NewClient(opts ...option.RequestOption) (r *Client)

NewClient generates a new client with the default option read from the environment (1231_API_KEY, 1231_BIOMETRIC_TOKEN, JOCALL3_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete 

func (r *Client) Delete(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Delete makes a DELETE request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Execute 

func (r *Client) Execute(ctx context.Context, method string, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Execute makes a request with the given context, method, URL, request params, response, and request options. This is useful for hitting undocumented endpoints while retaining the base URL, auth, retries, and other options from the client.

If a byte slice or an io.Reader is supplied to params, it will be used as-is for the request body.

The params is by default serialized into the body using encoding/json. If your type implements a MarshalJSON function, it will be used instead to serialize the request. If a URLQuery method is implemented, the returned url.Values will be used as query strings to the url.

If your params struct uses param.Field, you must provide either [MarshalJSON], [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a struct uses param.Field without specifying how it is serialized.

Any "…Params" object defined in this library can be used as the request argument. Note that 'path' arguments will not be forwarded into the url.

The response body will be deserialized into the res variable, depending on its type:

  • A pointer to a *http.Response is populated by the raw response.
  • A pointer to a byte array will be populated with the contents of the request body.
  • A pointer to any other type uses this library's default JSON decoding, which respects UnmarshalJSON if it is defined on the type.
  • A nil value will not read the response body.

For even greater flexibility, see option.WithResponseInto and option.WithResponseBodyInto.

func (*Client) Get 

func (r *Client) Get(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Get makes a GET request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Patch 

func (r *Client) Patch(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Patch makes a PATCH request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Post 

func (r *Client) Post(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Post makes a POST request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Put 

func (r *Client) Put(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Put makes a PUT request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

type CorporateAnomalyListParams 

type CorporateAnomalyListParams struct {
	// End date for filtering results (inclusive, YYYY-MM-DD).
	EndDate param.Field[interface{}] `query:"endDate"`
	// Filter anomalies by the type of financial entity they are related to.
	EntityType param.Field[CorporateAnomalyListParamsEntityType] `query:"entityType"`
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Filter anomalies by their AI-assessed severity level.
	Severity param.Field[CorporateAnomalyListParamsSeverity] `query:"severity"`
	// Start date for filtering results (inclusive, YYYY-MM-DD).
	StartDate param.Field[interface{}] `query:"startDate"`
	// Filter anomalies by their current review status.
	Status param.Field[CorporateAnomalyListParamsStatus] `query:"status"`
}

func (CorporateAnomalyListParams) URLQuery 

func (r CorporateAnomalyListParams) URLQuery() (v url.Values)

URLQuery serializes CorporateAnomalyListParams's query parameters as `url.Values`.

type CorporateAnomalyListParamsEntityType 

type CorporateAnomalyListParamsEntityType string

Filter anomalies by the type of financial entity they are related to. 

const (
	CorporateAnomalyListParamsEntityTypePaymentOrder  CorporateAnomalyListParamsEntityType = "PaymentOrder"
	CorporateAnomalyListParamsEntityTypeTransaction   CorporateAnomalyListParamsEntityType = "Transaction"
	CorporateAnomalyListParamsEntityTypeCounterparty  CorporateAnomalyListParamsEntityType = "Counterparty"
	CorporateAnomalyListParamsEntityTypeCorporateCard CorporateAnomalyListParamsEntityType = "CorporateCard"
	CorporateAnomalyListParamsEntityTypeInvoice       CorporateAnomalyListParamsEntityType = "Invoice"
)

func (CorporateAnomalyListParamsEntityType) IsKnown 

func (r CorporateAnomalyListParamsEntityType) IsKnown() bool

type CorporateAnomalyListParamsSeverity 

type CorporateAnomalyListParamsSeverity string

Filter anomalies by their AI-assessed severity level. 

const (
	CorporateAnomalyListParamsSeverityLow      CorporateAnomalyListParamsSeverity = "Low"
	CorporateAnomalyListParamsSeverityMedium   CorporateAnomalyListParamsSeverity = "Medium"
	CorporateAnomalyListParamsSeverityHigh     CorporateAnomalyListParamsSeverity = "High"
	CorporateAnomalyListParamsSeverityCritical CorporateAnomalyListParamsSeverity = "Critical"
)

func (CorporateAnomalyListParamsSeverity) IsKnown 

func (r CorporateAnomalyListParamsSeverity) IsKnown() bool

type CorporateAnomalyListParamsStatus 

type CorporateAnomalyListParamsStatus string

Filter anomalies by their current review status. 

const (
	CorporateAnomalyListParamsStatusNew         CorporateAnomalyListParamsStatus = "New"
	CorporateAnomalyListParamsStatusUnderReview CorporateAnomalyListParamsStatus = "Under Review"
	CorporateAnomalyListParamsStatusEscalated   CorporateAnomalyListParamsStatus = "Escalated"
	CorporateAnomalyListParamsStatusDismissed   CorporateAnomalyListParamsStatus = "Dismissed"
	CorporateAnomalyListParamsStatusResolved    CorporateAnomalyListParamsStatus = "Resolved"
)

func (CorporateAnomalyListParamsStatus) IsKnown 

func (r CorporateAnomalyListParamsStatus) IsKnown() bool

type CorporateAnomalyListResponse 

type CorporateAnomalyListResponse struct {
	Data []FinancialAnomaly               `json:"data"`
	JSON corporateAnomalyListResponseJSON `json:"-"`
	PaginatedList
}

func (*CorporateAnomalyListResponse) UnmarshalJSON 

func (r *CorporateAnomalyListResponse) UnmarshalJSON(data []byte) (err error)

type CorporateAnomalyService 

type CorporateAnomalyService struct {
	Options []option.RequestOption
}

CorporateAnomalyService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateAnomalyService method instead.

func NewCorporateAnomalyService 

func NewCorporateAnomalyService(opts ...option.RequestOption) (r *CorporateAnomalyService)

NewCorporateAnomalyService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateAnomalyService) List 

func (r *CorporateAnomalyService) List(ctx context.Context, query CorporateAnomalyListParams, opts ...option.RequestOption) (res *CorporateAnomalyListResponse, err error)

Retrieves a comprehensive list of AI-detected financial anomalies across transactions, payments, and corporate cards that require immediate review and potential action to mitigate risk and ensure compliance.

func (*CorporateAnomalyService) UpdateStatus 

func (r *CorporateAnomalyService) UpdateStatus(ctx context.Context, anomalyID interface{}, body CorporateAnomalyUpdateStatusParams, opts ...option.RequestOption) (res *FinancialAnomaly, err error)

Updates the review status of a specific financial anomaly, allowing compliance officers to mark it as dismissed, resolved, or escalate for further investigation after thorough AI-assisted and human review.

type CorporateAnomalyUpdateStatusParams 

type CorporateAnomalyUpdateStatusParams struct {
	// The new status for the financial anomaly.
	Status param.Field[CorporateAnomalyUpdateStatusParamsStatus] `json:"status,required"`
	// Optional notes regarding the resolution or dismissal of the anomaly.
	ResolutionNotes param.Field[interface{}] `json:"resolutionNotes"`
}

func (CorporateAnomalyUpdateStatusParams) MarshalJSON 

func (r CorporateAnomalyUpdateStatusParams) MarshalJSON() (data []byte, err error)

type CorporateAnomalyUpdateStatusParamsStatus 

type CorporateAnomalyUpdateStatusParamsStatus string

The new status for the financial anomaly. 

const (
	CorporateAnomalyUpdateStatusParamsStatusDismissed   CorporateAnomalyUpdateStatusParamsStatus = "Dismissed"
	CorporateAnomalyUpdateStatusParamsStatusResolved    CorporateAnomalyUpdateStatusParamsStatus = "Resolved"
	CorporateAnomalyUpdateStatusParamsStatusUnderReview CorporateAnomalyUpdateStatusParamsStatus = "Under Review"
	CorporateAnomalyUpdateStatusParamsStatusEscalated   CorporateAnomalyUpdateStatusParamsStatus = "Escalated"
)

func (CorporateAnomalyUpdateStatusParamsStatus) IsKnown 

func (r CorporateAnomalyUpdateStatusParamsStatus) IsKnown() bool

type CorporateCard 

type CorporateCard struct {
	// Unique identifier for the corporate card.
	ID interface{} `json:"id,required"`
	// Masked card number for display purposes.
	CardNumberMask interface{} `json:"cardNumberMask,required"`
	// Type of the card (physical or virtual).
	CardType CorporateCardCardType `json:"cardType,required"`
	// Granular spending controls for a corporate card.
	Controls CorporateCardControls `json:"controls,required"`
	// Timestamp when the card was created.
	CreatedDate interface{} `json:"createdDate,required"`
	// Currency of the card's limits and transactions.
	Currency interface{} `json:"currency,required"`
	// Expiration date of the card (YYYY-MM-DD).
	ExpirationDate interface{} `json:"expirationDate,required"`
	// If true, the card is temporarily frozen and cannot be used.
	Frozen interface{} `json:"frozen,required"`
	// Name of the card holder.
	HolderName interface{} `json:"holderName,required"`
	// Current status of the card.
	Status CorporateCardStatus `json:"status,required"`
	// Optional: ID of the employee associated with this card.
	AssociatedEmployeeID interface{} `json:"associatedEmployeeId"`
	// Optional: ID of the overarching spending policy applied to this card.
	SpendingPolicyID interface{}       `json:"spendingPolicyId"`
	JSON             corporateCardJSON `json:"-"`
}

func (*CorporateCard) UnmarshalJSON 

func (r *CorporateCard) UnmarshalJSON(data []byte) (err error)

type CorporateCardCardType 

type CorporateCardCardType string

Type of the card (physical or virtual). 

const (
	CorporateCardCardTypePhysical CorporateCardCardType = "physical"
	CorporateCardCardTypeVirtual  CorporateCardCardType = "virtual"
)

func (CorporateCardCardType) IsKnown 

func (r CorporateCardCardType) IsKnown() bool

type CorporateCardControls 

type CorporateCardControls struct {
	// If true, ATM cash withdrawals are allowed.
	AtmWithdrawals interface{} `json:"atmWithdrawals"`
	// If true, contactless payments are allowed.
	ContactlessPayments interface{} `json:"contactlessPayments"`
	// Maximum spending limit per day (null for no limit).
	DailyLimit interface{} `json:"dailyLimit"`
	// If true, international transactions are allowed.
	InternationalTransactions interface{} `json:"internationalTransactions"`
	// List of allowed merchant categories. If empty, all are allowed unless explicitly
	// denied.
	MerchantCategoryRestrictions []interface{} `json:"merchantCategoryRestrictions,nullable"`
	// Maximum spending limit per month (null for no limit).
	MonthlyLimit interface{} `json:"monthlyLimit"`
	// If true, online transactions are allowed.
	OnlineTransactions interface{} `json:"onlineTransactions"`
	// Maximum amount for a single transaction (null for no limit).
	SingleTransactionLimit interface{} `json:"singleTransactionLimit"`
	// List of allowed vendors/merchants by name.
	VendorRestrictions []interface{}             `json:"vendorRestrictions,nullable"`
	JSON               corporateCardControlsJSON `json:"-"`
}

Granular spending controls for a corporate card.

func (*CorporateCardControls) UnmarshalJSON 

func (r *CorporateCardControls) UnmarshalJSON(data []byte) (err error)

type CorporateCardControlsParam 

type CorporateCardControlsParam struct {
	// If true, ATM cash withdrawals are allowed.
	AtmWithdrawals param.Field[interface{}] `json:"atmWithdrawals"`
	// If true, contactless payments are allowed.
	ContactlessPayments param.Field[interface{}] `json:"contactlessPayments"`
	// Maximum spending limit per day (null for no limit).
	DailyLimit param.Field[interface{}] `json:"dailyLimit"`
	// If true, international transactions are allowed.
	InternationalTransactions param.Field[interface{}] `json:"internationalTransactions"`
	// List of allowed merchant categories. If empty, all are allowed unless explicitly
	// denied.
	MerchantCategoryRestrictions param.Field[[]interface{}] `json:"merchantCategoryRestrictions"`
	// Maximum spending limit per month (null for no limit).
	MonthlyLimit param.Field[interface{}] `json:"monthlyLimit"`
	// If true, online transactions are allowed.
	OnlineTransactions param.Field[interface{}] `json:"onlineTransactions"`
	// Maximum amount for a single transaction (null for no limit).
	SingleTransactionLimit param.Field[interface{}] `json:"singleTransactionLimit"`
	// List of allowed vendors/merchants by name.
	VendorRestrictions param.Field[[]interface{}] `json:"vendorRestrictions"`
}

Granular spending controls for a corporate card.

func (CorporateCardControlsParam) MarshalJSON 

func (r CorporateCardControlsParam) MarshalJSON() (data []byte, err error)

type CorporateCardFreezeParams 

type CorporateCardFreezeParams struct {
	// Set to `true` to freeze the card, `false` to unfreeze.
	Freeze param.Field[interface{}] `json:"freeze,required"`
}

func (CorporateCardFreezeParams) MarshalJSON 

func (r CorporateCardFreezeParams) MarshalJSON() (data []byte, err error)

type CorporateCardListParams 

type CorporateCardListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (CorporateCardListParams) URLQuery 

func (r CorporateCardListParams) URLQuery() (v url.Values)

URLQuery serializes CorporateCardListParams's query parameters as `url.Values`.

type CorporateCardListResponse 

type CorporateCardListResponse struct {
	Data []CorporateCard               `json:"data"`
	JSON corporateCardListResponseJSON `json:"-"`
	PaginatedList
}

func (*CorporateCardListResponse) UnmarshalJSON 

func (r *CorporateCardListResponse) UnmarshalJSON(data []byte) (err error)

type CorporateCardListTransactionsParams 

type CorporateCardListTransactionsParams struct {
	// End date for filtering results (inclusive, YYYY-MM-DD).
	EndDate param.Field[interface{}] `query:"endDate"`
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Start date for filtering results (inclusive, YYYY-MM-DD).
	StartDate param.Field[interface{}] `query:"startDate"`
}

func (CorporateCardListTransactionsParams) URLQuery 

func (r CorporateCardListTransactionsParams) URLQuery() (v url.Values)

URLQuery serializes CorporateCardListTransactionsParams's query parameters as `url.Values`.

type CorporateCardNewVirtualParams 

type CorporateCardNewVirtualParams struct {
	// Granular spending controls for a corporate card.
	Controls param.Field[CorporateCardControlsParam] `json:"controls,required"`
	// Expiration date for the virtual card (YYYY-MM-DD).
	ExpirationDate param.Field[interface{}] `json:"expirationDate,required"`
	// Name to appear on the virtual card.
	HolderName param.Field[interface{}] `json:"holderName,required"`
	// Brief description of the virtual card's purpose.
	Purpose param.Field[interface{}] `json:"purpose,required"`
	// Optional: ID of the employee or department this card is for.
	AssociatedEmployeeID param.Field[interface{}] `json:"associatedEmployeeId"`
	// Optional: ID of a spending policy to link with this virtual card.
	SpendingPolicyID param.Field[interface{}] `json:"spendingPolicyId"`
}

func (CorporateCardNewVirtualParams) MarshalJSON 

func (r CorporateCardNewVirtualParams) MarshalJSON() (data []byte, err error)

type CorporateCardService 

type CorporateCardService struct {
	Options []option.RequestOption
}

CorporateCardService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateCardService method instead.

func NewCorporateCardService 

func NewCorporateCardService(opts ...option.RequestOption) (r *CorporateCardService)

NewCorporateCardService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateCardService) Freeze 

func (r *CorporateCardService) Freeze(ctx context.Context, cardID interface{}, body CorporateCardFreezeParams, opts ...option.RequestOption) (res *CorporateCard, err error)

Immediately changes the frozen status of a corporate card, preventing or allowing transactions in real-time, critical for security and expense management.

func (*CorporateCardService) List 

func (r *CorporateCardService) List(ctx context.Context, query CorporateCardListParams, opts ...option.RequestOption) (res *CorporateCardListResponse, err error)

Retrieves a comprehensive list of all physical and virtual corporate cards associated with the user's organization, including their status, assigned holder, and current spending controls.

func (*CorporateCardService) ListTransactions 

func (r *CorporateCardService) ListTransactions(ctx context.Context, cardID interface{}, query CorporateCardListTransactionsParams, opts ...option.RequestOption) (res *PaginatedTransactions, err error)

Retrieves a paginated list of transactions made with a specific corporate card, including AI categorization and compliance flags.

func (*CorporateCardService) NewVirtual 

func (r *CorporateCardService) NewVirtual(ctx context.Context, body CorporateCardNewVirtualParams, opts ...option.RequestOption) (res *CorporateCard, err error)

Creates and issues a new virtual corporate card with specified spending limits, merchant restrictions, and expiration dates, ideal for secure online purchases and temporary projects.

func (*CorporateCardService) UpdateControls 

func (r *CorporateCardService) UpdateControls(ctx context.Context, cardID interface{}, body CorporateCardUpdateControlsParams, opts ...option.RequestOption) (res *CorporateCard, err error)

Updates the sophisticated spending controls, limits, and policy overrides for a specific corporate card, enabling real-time adjustments for security and budget adherence.

type CorporateCardStatus 

type CorporateCardStatus string

Current status of the card. 

const (
	CorporateCardStatusActive            CorporateCardStatus = "Active"
	CorporateCardStatusSuspended         CorporateCardStatus = "Suspended"
	CorporateCardStatusDeactivated       CorporateCardStatus = "Deactivated"
	CorporateCardStatusPendingActivation CorporateCardStatus = "Pending Activation"
)

func (CorporateCardStatus) IsKnown 

func (r CorporateCardStatus) IsKnown() bool

type CorporateCardUpdateControlsParams 

type CorporateCardUpdateControlsParams struct {
	// Granular spending controls for a corporate card.
	CorporateCardControls CorporateCardControlsParam `json:"corporate_card_controls,required"`
}

func (CorporateCardUpdateControlsParams) MarshalJSON 

func (r CorporateCardUpdateControlsParams) MarshalJSON() (data []byte, err error)

type CorporateComplianceAuditGetReportResponse 

type CorporateComplianceAuditGetReportResponse struct {
	// Timestamp when the audit report was generated.
	AuditDate interface{} `json:"auditDate,required"`
	// Unique identifier for the compliance audit.
	AuditID interface{} `json:"auditId,required"`
	// Detailed findings, observations, and recommendations.
	Findings []CorporateComplianceAuditGetReportResponseFinding `json:"findings,required"`
	// Overall compliance score (0-100), higher is better.
	OverallComplianceScore interface{} `json:"overallComplianceScore,required"`
	// The period covered by this audit report.
	PeriodCovered CorporateComplianceAuditGetReportResponsePeriodCovered `json:"periodCovered,required"`
	// AI-generated actionable recommendations to improve compliance.
	RecommendedActions []AIInsight `json:"recommendedActions,required"`
	// Current status of the audit.
	Status CorporateComplianceAuditGetReportResponseStatus `json:"status,required"`
	// A high-level summary of the audit findings.
	Summary interface{}                                   `json:"summary,required"`
	JSON    corporateComplianceAuditGetReportResponseJSON `json:"-"`
}

func (*CorporateComplianceAuditGetReportResponse) UnmarshalJSON 

func (r *CorporateComplianceAuditGetReportResponse) UnmarshalJSON(data []byte) (err error)

type CorporateComplianceAuditGetReportResponseFinding 

type CorporateComplianceAuditGetReportResponseFinding struct {
	Description interface{} `json:"description"`
	// IDs of entities related to this finding (e.g., transaction IDs).
	RelatedEntities []interface{}                                             `json:"relatedEntities,nullable"`
	Severity        CorporateComplianceAuditGetReportResponseFindingsSeverity `json:"severity"`
	Type            CorporateComplianceAuditGetReportResponseFindingsType     `json:"type"`
	JSON            corporateComplianceAuditGetReportResponseFindingJSON      `json:"-"`
}

func (*CorporateComplianceAuditGetReportResponseFinding) UnmarshalJSON 

func (r *CorporateComplianceAuditGetReportResponseFinding) UnmarshalJSON(data []byte) (err error)

type CorporateComplianceAuditGetReportResponseFindingsSeverity 

type CorporateComplianceAuditGetReportResponseFindingsSeverity string
const (
	CorporateComplianceAuditGetReportResponseFindingsSeverityLow      CorporateComplianceAuditGetReportResponseFindingsSeverity = "Low"
	CorporateComplianceAuditGetReportResponseFindingsSeverityMedium   CorporateComplianceAuditGetReportResponseFindingsSeverity = "Medium"
	CorporateComplianceAuditGetReportResponseFindingsSeverityHigh     CorporateComplianceAuditGetReportResponseFindingsSeverity = "High"
	CorporateComplianceAuditGetReportResponseFindingsSeverityCritical CorporateComplianceAuditGetReportResponseFindingsSeverity = "Critical"
)

func (CorporateComplianceAuditGetReportResponseFindingsSeverity) IsKnown 

func (r CorporateComplianceAuditGetReportResponseFindingsSeverity) IsKnown() bool

type CorporateComplianceAuditGetReportResponseFindingsType 

type CorporateComplianceAuditGetReportResponseFindingsType string
const (
	CorporateComplianceAuditGetReportResponseFindingsTypeFinding        CorporateComplianceAuditGetReportResponseFindingsType = "finding"
	CorporateComplianceAuditGetReportResponseFindingsTypeObservation    CorporateComplianceAuditGetReportResponseFindingsType = "observation"
	CorporateComplianceAuditGetReportResponseFindingsTypeRecommendation CorporateComplianceAuditGetReportResponseFindingsType = "recommendation"
)

func (CorporateComplianceAuditGetReportResponseFindingsType) IsKnown 

func (r CorporateComplianceAuditGetReportResponseFindingsType) IsKnown() bool

type CorporateComplianceAuditGetReportResponsePeriodCovered 

type CorporateComplianceAuditGetReportResponsePeriodCovered struct {
	EndDate   interface{}                                                `json:"endDate"`
	StartDate interface{}                                                `json:"startDate"`
	JSON      corporateComplianceAuditGetReportResponsePeriodCoveredJSON `json:"-"`
}

The period covered by this audit report.

func (*CorporateComplianceAuditGetReportResponsePeriodCovered) UnmarshalJSON 

func (r *CorporateComplianceAuditGetReportResponsePeriodCovered) UnmarshalJSON(data []byte) (err error)

type CorporateComplianceAuditGetReportResponseStatus 

type CorporateComplianceAuditGetReportResponseStatus string

Current status of the audit. 

const (
	CorporateComplianceAuditGetReportResponseStatusProcessing CorporateComplianceAuditGetReportResponseStatus = "processing"
	CorporateComplianceAuditGetReportResponseStatusCompleted  CorporateComplianceAuditGetReportResponseStatus = "completed"
	CorporateComplianceAuditGetReportResponseStatusFailed     CorporateComplianceAuditGetReportResponseStatus = "failed"
)

func (CorporateComplianceAuditGetReportResponseStatus) IsKnown 

func (r CorporateComplianceAuditGetReportResponseStatus) IsKnown() bool

type CorporateComplianceAuditRequestParams 

type CorporateComplianceAuditRequestParams struct {
	// The scope of the audit (e.g., all transactions, specific accounts).
	AuditScope param.Field[CorporateComplianceAuditRequestParamsAuditScope] `json:"auditScope,required"`
	// End date for the audit period (inclusive).
	EndDate param.Field[interface{}] `json:"endDate,required"`
	// List of regulatory frameworks against which to audit.
	RegulatoryFrameworks param.Field[[]CorporateComplianceAuditRequestParamsRegulatoryFramework] `json:"regulatoryFrameworks,required"`
	// Start date for the audit period (inclusive).
	StartDate param.Field[interface{}] `json:"startDate,required"`
	// Optional: Any additional context or specific areas of concern for the AI.
	AdditionalContext param.Field[interface{}] `json:"additionalContext"`
}

func (CorporateComplianceAuditRequestParams) MarshalJSON 

func (r CorporateComplianceAuditRequestParams) MarshalJSON() (data []byte, err error)

type CorporateComplianceAuditRequestParamsAuditScope 

type CorporateComplianceAuditRequestParamsAuditScope string

The scope of the audit (e.g., all transactions, specific accounts). 

const (
	CorporateComplianceAuditRequestParamsAuditScopeAllTransactions  CorporateComplianceAuditRequestParamsAuditScope = "all_transactions"
	CorporateComplianceAuditRequestParamsAuditScopeSpecificAccounts CorporateComplianceAuditRequestParamsAuditScope = "specific_accounts"
	CorporateComplianceAuditRequestParamsAuditScopeSpecificCards    CorporateComplianceAuditRequestParamsAuditScope = "specific_cards"
	CorporateComplianceAuditRequestParamsAuditScopeAllUsers         CorporateComplianceAuditRequestParamsAuditScope = "all_users"
)

func (CorporateComplianceAuditRequestParamsAuditScope) IsKnown 

func (r CorporateComplianceAuditRequestParamsAuditScope) IsKnown() bool

type CorporateComplianceAuditRequestParamsRegulatoryFramework 

type CorporateComplianceAuditRequestParamsRegulatoryFramework string
const (
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkAml    CorporateComplianceAuditRequestParamsRegulatoryFramework = "AML"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkKYC    CorporateComplianceAuditRequestParamsRegulatoryFramework = "KYC"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkPciDss CorporateComplianceAuditRequestParamsRegulatoryFramework = "PCI-DSS"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkGdpr   CorporateComplianceAuditRequestParamsRegulatoryFramework = "GDPR"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkCcpa   CorporateComplianceAuditRequestParamsRegulatoryFramework = "CCPA"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkSox    CorporateComplianceAuditRequestParamsRegulatoryFramework = "SOX"
	CorporateComplianceAuditRequestParamsRegulatoryFrameworkOfac   CorporateComplianceAuditRequestParamsRegulatoryFramework = "OFAC"
)

func (CorporateComplianceAuditRequestParamsRegulatoryFramework) IsKnown 

func (r CorporateComplianceAuditRequestParamsRegulatoryFramework) IsKnown() bool

type CorporateComplianceAuditRequestResponse 

type CorporateComplianceAuditRequestResponse struct {
	// Unique identifier for the initiated audit.
	AuditID interface{} `json:"auditId"`
	// Current status of the audit.
	Status CorporateComplianceAuditRequestResponseStatus `json:"status"`
	JSON   corporateComplianceAuditRequestResponseJSON   `json:"-"`
}

func (*CorporateComplianceAuditRequestResponse) UnmarshalJSON 

func (r *CorporateComplianceAuditRequestResponse) UnmarshalJSON(data []byte) (err error)

type CorporateComplianceAuditRequestResponseStatus 

type CorporateComplianceAuditRequestResponseStatus string

Current status of the audit. 

const (
	CorporateComplianceAuditRequestResponseStatusInitiated  CorporateComplianceAuditRequestResponseStatus = "initiated"
	CorporateComplianceAuditRequestResponseStatusProcessing CorporateComplianceAuditRequestResponseStatus = "processing"
	CorporateComplianceAuditRequestResponseStatusCompleted  CorporateComplianceAuditRequestResponseStatus = "completed"
	CorporateComplianceAuditRequestResponseStatusFailed     CorporateComplianceAuditRequestResponseStatus = "failed"
)

func (CorporateComplianceAuditRequestResponseStatus) IsKnown 

func (r CorporateComplianceAuditRequestResponseStatus) IsKnown() bool

type CorporateComplianceAuditService 

type CorporateComplianceAuditService struct {
	Options []option.RequestOption
}

CorporateComplianceAuditService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateComplianceAuditService method instead.

func NewCorporateComplianceAuditService 

func NewCorporateComplianceAuditService(opts ...option.RequestOption) (r *CorporateComplianceAuditService)

NewCorporateComplianceAuditService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateComplianceAuditService) GetReport 

func (r *CorporateComplianceAuditService) GetReport(ctx context.Context, auditID interface{}, opts ...option.RequestOption) (res *CorporateComplianceAuditGetReportResponse, err error)

Retrieves the full report generated by an AI-driven compliance audit.

func (*CorporateComplianceAuditService) Request 

func (r *CorporateComplianceAuditService) Request(ctx context.Context, body CorporateComplianceAuditRequestParams, opts ...option.RequestOption) (res *CorporateComplianceAuditRequestResponse, err error)

Initiates an AI-powered compliance audit for a specific period or scope, generating a comprehensive report detailing adherence to regulatory frameworks, internal policies, and flagging potential risks.

type CorporateComplianceService 

type CorporateComplianceService struct {
	Options []option.RequestOption
	Audits  *CorporateComplianceAuditService
}

CorporateComplianceService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateComplianceService method instead.

func NewCorporateComplianceService 

func NewCorporateComplianceService(opts ...option.RequestOption) (r *CorporateComplianceService)

NewCorporateComplianceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type CorporatePerformSanctionScreeningParams 

type CorporatePerformSanctionScreeningParams struct {
	// Two-letter ISO country code related to the entity (e.g., country of residence,
	// registration).
	Country param.Field[interface{}] `json:"country,required"`
	// The type of entity being screened.
	EntityType param.Field[CorporatePerformSanctionScreeningParamsEntityType] `json:"entityType,required"`
	// Full name of the individual or organization to screen.
	Name    param.Field[interface{}]  `json:"name,required"`
	Address param.Field[AddressParam] `json:"address"`
	// Date of birth for individuals (YYYY-MM-DD).
	DateOfBirth param.Field[interface{}] `json:"dateOfBirth"`
	// Optional: Any government-issued identification number (e.g., passport, national
	// ID).
	IdentificationNumber param.Field[interface{}] `json:"identificationNumber"`
}

func (CorporatePerformSanctionScreeningParams) MarshalJSON 

func (r CorporatePerformSanctionScreeningParams) MarshalJSON() (data []byte, err error)

type CorporatePerformSanctionScreeningParamsEntityType 

type CorporatePerformSanctionScreeningParamsEntityType string

The type of entity being screened. 

const (
	CorporatePerformSanctionScreeningParamsEntityTypeIndividual   CorporatePerformSanctionScreeningParamsEntityType = "individual"
	CorporatePerformSanctionScreeningParamsEntityTypeOrganization CorporatePerformSanctionScreeningParamsEntityType = "organization"
)

func (CorporatePerformSanctionScreeningParamsEntityType) IsKnown 

func (r CorporatePerformSanctionScreeningParamsEntityType) IsKnown() bool

type CorporatePerformSanctionScreeningResponse 

type CorporatePerformSanctionScreeningResponse struct {
	// Details of any potential or exact matches found.
	MatchDetails []CorporatePerformSanctionScreeningResponseMatchDetail `json:"matchDetails,required"`
	// True if any potential matches were found on sanction lists.
	MatchFound interface{} `json:"matchFound,required"`
	// Unique identifier for this screening operation.
	ScreeningID interface{} `json:"screeningId,required"`
	// Timestamp when the screening was performed.
	ScreeningTimestamp interface{} `json:"screeningTimestamp,required"`
	// Overall status of the screening result.
	Status CorporatePerformSanctionScreeningResponseStatus `json:"status,required"`
	// An optional message providing more context on the status.
	Message interface{}                                   `json:"message"`
	JSON    corporatePerformSanctionScreeningResponseJSON `json:"-"`
}

func (*CorporatePerformSanctionScreeningResponse) UnmarshalJSON 

func (r *CorporatePerformSanctionScreeningResponse) UnmarshalJSON(data []byte) (err error)

type CorporatePerformSanctionScreeningResponseMatchDetail 

type CorporatePerformSanctionScreeningResponseMatchDetail struct {
	// Name of the sanction list where a match was found.
	ListName interface{} `json:"listName"`
	// The name on the sanction list that matched.
	MatchedName interface{} `json:"matchedName"`
	// Optional: URL to public record of the sanction list entry.
	PublicURL interface{} `json:"publicUrl"`
	// Reason for the match (e.g., exact name, alias, partial match).
	Reason interface{} `json:"reason"`
	// Match confidence score (0-1).
	Score interface{}                                              `json:"score"`
	JSON  corporatePerformSanctionScreeningResponseMatchDetailJSON `json:"-"`
}

func (*CorporatePerformSanctionScreeningResponseMatchDetail) UnmarshalJSON 

func (r *CorporatePerformSanctionScreeningResponseMatchDetail) UnmarshalJSON(data []byte) (err error)

type CorporatePerformSanctionScreeningResponseStatus 

type CorporatePerformSanctionScreeningResponseStatus string

Overall status of the screening result. 

const (
	CorporatePerformSanctionScreeningResponseStatusClear          CorporatePerformSanctionScreeningResponseStatus = "clear"
	CorporatePerformSanctionScreeningResponseStatusPotentialMatch CorporatePerformSanctionScreeningResponseStatus = "potential_match"
	CorporatePerformSanctionScreeningResponseStatusConfirmedMatch CorporatePerformSanctionScreeningResponseStatus = "confirmed_match"
	CorporatePerformSanctionScreeningResponseStatusError          CorporatePerformSanctionScreeningResponseStatus = "error"
)

func (CorporatePerformSanctionScreeningResponseStatus) IsKnown 

func (r CorporatePerformSanctionScreeningResponseStatus) IsKnown() bool

type CorporateRiskFraudRuleListParams 

type CorporateRiskFraudRuleListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (CorporateRiskFraudRuleListParams) URLQuery 

func (r CorporateRiskFraudRuleListParams) URLQuery() (v url.Values)

URLQuery serializes CorporateRiskFraudRuleListParams's query parameters as `url.Values`.

type CorporateRiskFraudRuleListResponse 

type CorporateRiskFraudRuleListResponse struct {
	Data []FraudRule                            `json:"data"`
	JSON corporateRiskFraudRuleListResponseJSON `json:"-"`
	PaginatedList
}

func (*CorporateRiskFraudRuleListResponse) UnmarshalJSON 

func (r *CorporateRiskFraudRuleListResponse) UnmarshalJSON(data []byte) (err error)

type CorporateRiskFraudRuleNewParams 

type CorporateRiskFraudRuleNewParams struct {
	// Action to take when a fraud rule is triggered.
	Action param.Field[FraudRuleActionParam] `json:"action,required"`
	// Criteria that define when a fraud rule should trigger.
	Criteria param.Field[FraudRuleCriteriaParam] `json:"criteria,required"`
	// Detailed description of what the rule detects.
	Description param.Field[interface{}] `json:"description,required"`
	// Name of the new fraud rule.
	Name param.Field[interface{}] `json:"name,required"`
	// Severity level when this rule is triggered.
	Severity param.Field[CorporateRiskFraudRuleNewParamsSeverity] `json:"severity,required"`
	// Initial status of the rule.
	Status param.Field[CorporateRiskFraudRuleNewParamsStatus] `json:"status,required"`
}

func (CorporateRiskFraudRuleNewParams) MarshalJSON 

func (r CorporateRiskFraudRuleNewParams) MarshalJSON() (data []byte, err error)

type CorporateRiskFraudRuleNewParamsSeverity 

type CorporateRiskFraudRuleNewParamsSeverity string

Severity level when this rule is triggered. 

const (
	CorporateRiskFraudRuleNewParamsSeverityLow      CorporateRiskFraudRuleNewParamsSeverity = "Low"
	CorporateRiskFraudRuleNewParamsSeverityMedium   CorporateRiskFraudRuleNewParamsSeverity = "Medium"
	CorporateRiskFraudRuleNewParamsSeverityHigh     CorporateRiskFraudRuleNewParamsSeverity = "High"
	CorporateRiskFraudRuleNewParamsSeverityCritical CorporateRiskFraudRuleNewParamsSeverity = "Critical"
)

func (CorporateRiskFraudRuleNewParamsSeverity) IsKnown 

func (r CorporateRiskFraudRuleNewParamsSeverity) IsKnown() bool

type CorporateRiskFraudRuleNewParamsStatus 

type CorporateRiskFraudRuleNewParamsStatus string

Initial status of the rule. 

const (
	CorporateRiskFraudRuleNewParamsStatusActive   CorporateRiskFraudRuleNewParamsStatus = "active"
	CorporateRiskFraudRuleNewParamsStatusInactive CorporateRiskFraudRuleNewParamsStatus = "inactive"
	CorporateRiskFraudRuleNewParamsStatusDraft    CorporateRiskFraudRuleNewParamsStatus = "draft"
)

func (CorporateRiskFraudRuleNewParamsStatus) IsKnown 

func (r CorporateRiskFraudRuleNewParamsStatus) IsKnown() bool

type CorporateRiskFraudRuleService 

type CorporateRiskFraudRuleService struct {
	Options []option.RequestOption
}

CorporateRiskFraudRuleService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateRiskFraudRuleService method instead.

func NewCorporateRiskFraudRuleService 

func NewCorporateRiskFraudRuleService(opts ...option.RequestOption) (r *CorporateRiskFraudRuleService)

NewCorporateRiskFraudRuleService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateRiskFraudRuleService) Delete 

func (r *CorporateRiskFraudRuleService) Delete(ctx context.Context, ruleID interface{}, opts ...option.RequestOption) (err error)

Deletes a specific custom AI-powered fraud detection rule.

func (*CorporateRiskFraudRuleService) List 

func (r *CorporateRiskFraudRuleService) List(ctx context.Context, query CorporateRiskFraudRuleListParams, opts ...option.RequestOption) (res *CorporateRiskFraudRuleListResponse, err error)

Retrieves a list of AI-powered fraud detection rules currently active for the organization, including their parameters, thresholds, and associated actions (e.g., flag, block, alert).

func (*CorporateRiskFraudRuleService) New 

func (r *CorporateRiskFraudRuleService) New(ctx context.Context, body CorporateRiskFraudRuleNewParams, opts ...option.RequestOption) (res *FraudRule, err error)

Creates a new custom AI-powered fraud detection rule, allowing organizations to define specific criteria, risk scores, and automated responses to evolving threat landscapes.

func (*CorporateRiskFraudRuleService) Update 

func (r *CorporateRiskFraudRuleService) Update(ctx context.Context, ruleID interface{}, body CorporateRiskFraudRuleUpdateParams, opts ...option.RequestOption) (res *FraudRule, err error)

Updates an existing custom AI-powered fraud detection rule, modifying its criteria, actions, or status.

type CorporateRiskFraudRuleUpdateParams 

type CorporateRiskFraudRuleUpdateParams struct {
	// Action to take when a fraud rule is triggered.
	Action param.Field[FraudRuleActionParam] `json:"action"`
	// Criteria that define when a fraud rule should trigger.
	Criteria param.Field[FraudRuleCriteriaParam] `json:"criteria"`
	// Updated description of what the rule detects.
	Description param.Field[interface{}] `json:"description"`
	// Updated name of the fraud rule.
	Name param.Field[interface{}] `json:"name"`
	// Updated severity level.
	Severity param.Field[CorporateRiskFraudRuleUpdateParamsSeverity] `json:"severity"`
	// Updated status of the rule.
	Status param.Field[CorporateRiskFraudRuleUpdateParamsStatus] `json:"status"`
}

func (CorporateRiskFraudRuleUpdateParams) MarshalJSON 

func (r CorporateRiskFraudRuleUpdateParams) MarshalJSON() (data []byte, err error)

type CorporateRiskFraudRuleUpdateParamsSeverity 

type CorporateRiskFraudRuleUpdateParamsSeverity string

Updated severity level. 

const (
	CorporateRiskFraudRuleUpdateParamsSeverityLow      CorporateRiskFraudRuleUpdateParamsSeverity = "Low"
	CorporateRiskFraudRuleUpdateParamsSeverityMedium   CorporateRiskFraudRuleUpdateParamsSeverity = "Medium"
	CorporateRiskFraudRuleUpdateParamsSeverityHigh     CorporateRiskFraudRuleUpdateParamsSeverity = "High"
	CorporateRiskFraudRuleUpdateParamsSeverityCritical CorporateRiskFraudRuleUpdateParamsSeverity = "Critical"
)

func (CorporateRiskFraudRuleUpdateParamsSeverity) IsKnown 

func (r CorporateRiskFraudRuleUpdateParamsSeverity) IsKnown() bool

type CorporateRiskFraudRuleUpdateParamsStatus 

type CorporateRiskFraudRuleUpdateParamsStatus string

Updated status of the rule. 

const (
	CorporateRiskFraudRuleUpdateParamsStatusActive   CorporateRiskFraudRuleUpdateParamsStatus = "active"
	CorporateRiskFraudRuleUpdateParamsStatusInactive CorporateRiskFraudRuleUpdateParamsStatus = "inactive"
	CorporateRiskFraudRuleUpdateParamsStatusDraft    CorporateRiskFraudRuleUpdateParamsStatus = "draft"
)

func (CorporateRiskFraudRuleUpdateParamsStatus) IsKnown 

func (r CorporateRiskFraudRuleUpdateParamsStatus) IsKnown() bool

type CorporateRiskFraudService 

type CorporateRiskFraudService struct {
	Options []option.RequestOption
	Rules   *CorporateRiskFraudRuleService
}

CorporateRiskFraudService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateRiskFraudService method instead.

func NewCorporateRiskFraudService 

func NewCorporateRiskFraudService(opts ...option.RequestOption) (r *CorporateRiskFraudService)

NewCorporateRiskFraudService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type CorporateRiskService 

type CorporateRiskService struct {
	Options []option.RequestOption
	Fraud   *CorporateRiskFraudService
}

CorporateRiskService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateRiskService method instead.

func NewCorporateRiskService 

func NewCorporateRiskService(opts ...option.RequestOption) (r *CorporateRiskService)

NewCorporateRiskService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type CorporateService 

type CorporateService struct {
	Options    []option.RequestOption
	Cards      *CorporateCardService
	Anomalies  *CorporateAnomalyService
	Compliance *CorporateComplianceService
	Treasury   *CorporateTreasuryService
	Risk       *CorporateRiskService
}

CorporateService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateService method instead.

func NewCorporateService 

func NewCorporateService(opts ...option.RequestOption) (r *CorporateService)

NewCorporateService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateService) PerformSanctionScreening 

func (r *CorporateService) PerformSanctionScreening(ctx context.Context, body CorporatePerformSanctionScreeningParams, opts ...option.RequestOption) (res *CorporatePerformSanctionScreeningResponse, err error)

Executes a real-time screening of an individual or entity against global sanction lists and watchlists.

type CorporateTreasuryCashFlowGetForecastParams 

type CorporateTreasuryCashFlowGetForecastParams struct {
	// The number of days into the future for which to generate the cash flow forecast
	// (e.g., 30, 90, 180).
	ForecastHorizonDays param.Field[interface{}] `query:"forecastHorizonDays"`
	// If true, the forecast will include best-case and worst-case scenario analysis
	// alongside the most likely projection.
	IncludeScenarioAnalysis param.Field[interface{}] `query:"includeScenarioAnalysis"`
}

func (CorporateTreasuryCashFlowGetForecastParams) URLQuery 

func (r CorporateTreasuryCashFlowGetForecastParams) URLQuery() (v url.Values)

URLQuery serializes CorporateTreasuryCashFlowGetForecastParams's query parameters as `url.Values`.

type CorporateTreasuryCashFlowGetForecastResponse 

type CorporateTreasuryCashFlowGetForecastResponse struct {
	// AI-generated recommendations for treasury optimization.
	AIRecommendations []AIInsight `json:"aiRecommendations,required"`
	// The currency of the forecast.
	Currency interface{} `json:"currency,required"`
	// Unique identifier for the cash flow forecast report.
	ForecastID interface{} `json:"forecastId,required"`
	// Forecast of cash inflows by source.
	InflowForecast CorporateTreasuryCashFlowGetForecastResponseInflowForecast `json:"inflowForecast,required"`
	// AI-assessed risk score for liquidity (0-100, lower is better).
	LiquidityRiskScore interface{} `json:"liquidityRiskScore,required"`
	// Forecast of cash outflows by category.
	OutflowForecast CorporateTreasuryCashFlowGetForecastResponseOutflowForecast `json:"outflowForecast,required"`
	// Overall assessment of the projected cash flow.
	OverallStatus CorporateTreasuryCashFlowGetForecastResponseOverallStatus `json:"overallStatus,required"`
	// The period covered by the forecast.
	Period interface{} `json:"period,required"`
	// Projected cash balances at key dates, potentially across different scenarios.
	ProjectedBalances []CorporateTreasuryCashFlowGetForecastResponseProjectedBalance `json:"projectedBalances,required"`
	JSON              corporateTreasuryCashFlowGetForecastResponseJSON               `json:"-"`
}

func (*CorporateTreasuryCashFlowGetForecastResponse) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponse) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseInflowForecast 

type CorporateTreasuryCashFlowGetForecastResponseInflowForecast struct {
	BySource       []CorporateTreasuryCashFlowGetForecastResponseInflowForecastBySource `json:"bySource"`
	TotalProjected interface{}                                                          `json:"totalProjected"`
	JSON           corporateTreasuryCashFlowGetForecastResponseInflowForecastJSON       `json:"-"`
}

Forecast of cash inflows by source.

func (*CorporateTreasuryCashFlowGetForecastResponseInflowForecast) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponseInflowForecast) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseInflowForecastBySource 

type CorporateTreasuryCashFlowGetForecastResponseInflowForecastBySource struct {
	Amount interface{}                                                            `json:"amount"`
	Source interface{}                                                            `json:"source"`
	JSON   corporateTreasuryCashFlowGetForecastResponseInflowForecastBySourceJSON `json:"-"`
}

func (*CorporateTreasuryCashFlowGetForecastResponseInflowForecastBySource) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponseInflowForecastBySource) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseOutflowForecast 

type CorporateTreasuryCashFlowGetForecastResponseOutflowForecast struct {
	ByCategory     []CorporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategory `json:"byCategory"`
	TotalProjected interface{}                                                             `json:"totalProjected"`
	JSON           corporateTreasuryCashFlowGetForecastResponseOutflowForecastJSON         `json:"-"`
}

Forecast of cash outflows by category.

func (*CorporateTreasuryCashFlowGetForecastResponseOutflowForecast) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponseOutflowForecast) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategory 

type CorporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategory struct {
	Amount   interface{}                                                               `json:"amount"`
	Category interface{}                                                               `json:"category"`
	JSON     corporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategoryJSON `json:"-"`
}

func (*CorporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategory) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponseOutflowForecastByCategory) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseOverallStatus 

type CorporateTreasuryCashFlowGetForecastResponseOverallStatus string

Overall assessment of the projected cash flow. 

const (
	CorporateTreasuryCashFlowGetForecastResponseOverallStatusPositiveOutlook CorporateTreasuryCashFlowGetForecastResponseOverallStatus = "positive_outlook"
	CorporateTreasuryCashFlowGetForecastResponseOverallStatusNegativeOutlook CorporateTreasuryCashFlowGetForecastResponseOverallStatus = "negative_outlook"
	CorporateTreasuryCashFlowGetForecastResponseOverallStatusStable          CorporateTreasuryCashFlowGetForecastResponseOverallStatus = "stable"
	CorporateTreasuryCashFlowGetForecastResponseOverallStatusUncertain       CorporateTreasuryCashFlowGetForecastResponseOverallStatus = "uncertain"
)

func (CorporateTreasuryCashFlowGetForecastResponseOverallStatus) IsKnown 

func (r CorporateTreasuryCashFlowGetForecastResponseOverallStatus) IsKnown() bool

type CorporateTreasuryCashFlowGetForecastResponseProjectedBalance 

type CorporateTreasuryCashFlowGetForecastResponseProjectedBalance struct {
	Date          interface{}                                                           `json:"date"`
	ProjectedCash interface{}                                                           `json:"projectedCash"`
	Scenario      CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario `json:"scenario"`
	JSON          corporateTreasuryCashFlowGetForecastResponseProjectedBalanceJSON      `json:"-"`
}

func (*CorporateTreasuryCashFlowGetForecastResponseProjectedBalance) UnmarshalJSON 

func (r *CorporateTreasuryCashFlowGetForecastResponseProjectedBalance) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario 

type CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario string
const (
	CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenarioMostLikely CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario = "most_likely"
	CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenarioBestCase   CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario = "best_case"
	CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenarioWorstCase  CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario = "worst_case"
)

func (CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario) IsKnown 

func (r CorporateTreasuryCashFlowGetForecastResponseProjectedBalancesScenario) IsKnown() bool

type CorporateTreasuryCashFlowService 

type CorporateTreasuryCashFlowService struct {
	Options []option.RequestOption
}

CorporateTreasuryCashFlowService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateTreasuryCashFlowService method instead.

func NewCorporateTreasuryCashFlowService 

func NewCorporateTreasuryCashFlowService(opts ...option.RequestOption) (r *CorporateTreasuryCashFlowService)

NewCorporateTreasuryCashFlowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateTreasuryCashFlowService) GetForecast 

func (r *CorporateTreasuryCashFlowService) GetForecast(ctx context.Context, query CorporateTreasuryCashFlowGetForecastParams, opts ...option.RequestOption) (res *CorporateTreasuryCashFlowGetForecastResponse, err error)

Retrieves an advanced AI-driven cash flow forecast for the organization, projecting liquidity, identifying potential surpluses or deficits, and providing recommendations for optimal treasury management.

type CorporateTreasuryGetLiquidityPositionsResponse 

type CorporateTreasuryGetLiquidityPositionsResponse struct {
	// Breakdown of liquid assets by account type.
	AccountTypeBreakdown []CorporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdown `json:"accountTypeBreakdown,required"`
	// AI's overall assessment of liquidity.
	AILiquidityAssessment CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessment `json:"aiLiquidityAssessment,required"`
	// AI-generated recommendations for liquidity management.
	AIRecommendations []AIInsight `json:"aiRecommendations,required"`
	// Breakdown of liquid assets by currency.
	CurrencyBreakdown []CorporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdown `json:"currencyBreakdown,required"`
	// Details on short-term investments contributing to liquidity.
	ShortTermInvestments CorporateTreasuryGetLiquidityPositionsResponseShortTermInvestments `json:"shortTermInvestments,required"`
	// Timestamp of the liquidity snapshot.
	SnapshotTime interface{} `json:"snapshotTime,required"`
	// Total value of all liquid assets across the organization.
	TotalLiquidAssets interface{}                                        `json:"totalLiquidAssets,required"`
	JSON              corporateTreasuryGetLiquidityPositionsResponseJSON `json:"-"`
}

func (*CorporateTreasuryGetLiquidityPositionsResponse) UnmarshalJSON 

func (r *CorporateTreasuryGetLiquidityPositionsResponse) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessment 

type CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessment struct {
	Message interface{}                                                               `json:"message"`
	Status  CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus `json:"status"`
	JSON    corporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentJSON   `json:"-"`
}

AI's overall assessment of liquidity.

func (*CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessment) UnmarshalJSON 

func (r *CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessment) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus 

type CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus string
const (
	CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatusOptimal    CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus = "optimal"
	CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatusSufficient CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus = "sufficient"
	CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatusTight      CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus = "tight"
	CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatusCritical   CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus = "critical"
)

func (CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus) IsKnown 

func (r CorporateTreasuryGetLiquidityPositionsResponseAILiquidityAssessmentStatus) IsKnown() bool

type CorporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdown 

type CorporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdown struct {
	Amount interface{}                                                            `json:"amount"`
	Type   interface{}                                                            `json:"type"`
	JSON   corporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdownJSON `json:"-"`
}

func (*CorporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdown) UnmarshalJSON 

func (r *CorporateTreasuryGetLiquidityPositionsResponseAccountTypeBreakdown) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdown 

type CorporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdown struct {
	Amount     interface{}                                                         `json:"amount"`
	Currency   interface{}                                                         `json:"currency"`
	Percentage interface{}                                                         `json:"percentage"`
	JSON       corporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdownJSON `json:"-"`
}

func (*CorporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdown) UnmarshalJSON 

func (r *CorporateTreasuryGetLiquidityPositionsResponseCurrencyBreakdown) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryGetLiquidityPositionsResponseShortTermInvestments 

type CorporateTreasuryGetLiquidityPositionsResponseShortTermInvestments struct {
	MaturingNext30Days interface{}                                                            `json:"maturingNext30Days"`
	TotalValue         interface{}                                                            `json:"totalValue"`
	JSON               corporateTreasuryGetLiquidityPositionsResponseShortTermInvestmentsJSON `json:"-"`
}

Details on short-term investments contributing to liquidity.

func (*CorporateTreasuryGetLiquidityPositionsResponseShortTermInvestments) UnmarshalJSON 

func (r *CorporateTreasuryGetLiquidityPositionsResponseShortTermInvestments) UnmarshalJSON(data []byte) (err error)

type CorporateTreasuryService 

type CorporateTreasuryService struct {
	Options  []option.RequestOption
	CashFlow *CorporateTreasuryCashFlowService
}

CorporateTreasuryService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCorporateTreasuryService method instead.

func NewCorporateTreasuryService 

func NewCorporateTreasuryService(opts ...option.RequestOption) (r *CorporateTreasuryService)

NewCorporateTreasuryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CorporateTreasuryService) GetLiquidityPositions 

func (r *CorporateTreasuryService) GetLiquidityPositions(ctx context.Context, opts ...option.RequestOption) (res *CorporateTreasuryGetLiquidityPositionsResponse, err error)

Provides a real-time overview of the organization's liquidity across all accounts, currencies, and short-term investments.

type CryptoWalletConnection 

type CryptoWalletConnection struct {
	// Unique identifier for this wallet connection.
	ID interface{} `json:"id,required"`
	// The blockchain network this wallet is primarily connected to (e.g., Ethereum,
	// Solana, Polygon).
	BlockchainNetwork interface{} `json:"blockchainNetwork,required"`
	// Timestamp when the wallet's data was last synchronized.
	LastSynced interface{} `json:"lastSynced,required"`
	// Indicates if read access (balances, NFTs) is granted.
	ReadAccessGranted interface{} `json:"readAccessGranted,required"`
	// Current status of the wallet connection.
	Status CryptoWalletConnectionStatus `json:"status,required"`
	// Public address of the connected cryptocurrency wallet.
	WalletAddress interface{} `json:"walletAddress,required"`
	// Name of the wallet provider (e.g., MetaMask, Ledger, Phantom).
	WalletProvider interface{} `json:"walletProvider,required"`
	// Indicates if write access (transactions) is granted. Requires higher
	// permission/security.
	WriteAccessGranted interface{}                `json:"writeAccessGranted,required"`
	JSON               cryptoWalletConnectionJSON `json:"-"`
}

func (*CryptoWalletConnection) UnmarshalJSON 

func (r *CryptoWalletConnection) UnmarshalJSON(data []byte) (err error)

type CryptoWalletConnectionStatus 

type CryptoWalletConnectionStatus string

Current status of the wallet connection. 

const (
	CryptoWalletConnectionStatusConnected           CryptoWalletConnectionStatus = "connected"
	CryptoWalletConnectionStatusDisconnected        CryptoWalletConnectionStatus = "disconnected"
	CryptoWalletConnectionStatusPendingVerification CryptoWalletConnectionStatus = "pending_verification"
	CryptoWalletConnectionStatusError               CryptoWalletConnectionStatus = "error"
)

func (CryptoWalletConnectionStatus) IsKnown 

func (r CryptoWalletConnectionStatus) IsKnown() bool

type DeveloperAPIKeyListParams 

type DeveloperAPIKeyListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (DeveloperAPIKeyListParams) URLQuery 

func (r DeveloperAPIKeyListParams) URLQuery() (v url.Values)

URLQuery serializes DeveloperAPIKeyListParams's query parameters as `url.Values`.

type DeveloperAPIKeyListResponse 

type DeveloperAPIKeyListResponse struct {
	Data []APIKey                        `json:"data"`
	JSON developerAPIKeyListResponseJSON `json:"-"`
	PaginatedList
}

func (*DeveloperAPIKeyListResponse) UnmarshalJSON 

func (r *DeveloperAPIKeyListResponse) UnmarshalJSON(data []byte) (err error)

type DeveloperAPIKeyNewParams 

type DeveloperAPIKeyNewParams struct {
	// A descriptive name for the API key.
	Name param.Field[interface{}] `json:"name,required"`
	// List of permissions to grant to this API key.
	Scopes param.Field[[]interface{}] `json:"scopes,required"`
	// Optional: Number of days until the API key expires. If omitted, it will not
	// expire.
	ExpiresInDays param.Field[interface{}] `json:"expiresInDays"`
}

func (DeveloperAPIKeyNewParams) MarshalJSON 

func (r DeveloperAPIKeyNewParams) MarshalJSON() (data []byte, err error)

type DeveloperAPIKeyService 

type DeveloperAPIKeyService struct {
	Options []option.RequestOption
}

DeveloperAPIKeyService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeveloperAPIKeyService method instead.

func NewDeveloperAPIKeyService 

func NewDeveloperAPIKeyService(opts ...option.RequestOption) (r *DeveloperAPIKeyService)

NewDeveloperAPIKeyService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeveloperAPIKeyService) List 

func (r *DeveloperAPIKeyService) List(ctx context.Context, query DeveloperAPIKeyListParams, opts ...option.RequestOption) (res *DeveloperAPIKeyListResponse, err error)

Retrieves a list of API keys issued to the authenticated developer application.

func (*DeveloperAPIKeyService) New 

func (r *DeveloperAPIKeyService) New(ctx context.Context, body DeveloperAPIKeyNewParams, opts ...option.RequestOption) (res *APIKey, err error)

Generates a new API key for the developer application with specified scopes and an optional expiration.

func (*DeveloperAPIKeyService) Revoke 

func (r *DeveloperAPIKeyService) Revoke(ctx context.Context, keyID interface{}, opts ...option.RequestOption) (err error)

Revokes an existing API key, disabling its access immediately.

type DeveloperService 

type DeveloperService struct {
	Options  []option.RequestOption
	Webhooks *DeveloperWebhookService
	APIKeys  *DeveloperAPIKeyService
}

DeveloperService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeveloperService method instead.

func NewDeveloperService 

func NewDeveloperService(opts ...option.RequestOption) (r *DeveloperService)

NewDeveloperService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type DeveloperWebhookListParams 

type DeveloperWebhookListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (DeveloperWebhookListParams) URLQuery 

func (r DeveloperWebhookListParams) URLQuery() (v url.Values)

URLQuery serializes DeveloperWebhookListParams's query parameters as `url.Values`.

type DeveloperWebhookListResponse 

type DeveloperWebhookListResponse struct {
	Data []WebhookSubscription            `json:"data"`
	JSON developerWebhookListResponseJSON `json:"-"`
	PaginatedList
}

func (*DeveloperWebhookListResponse) UnmarshalJSON 

func (r *DeveloperWebhookListResponse) UnmarshalJSON(data []byte) (err error)

type DeveloperWebhookNewParams 

type DeveloperWebhookNewParams struct {
	// The URL to which webhook events will be sent.
	CallbackURL param.Field[interface{}] `json:"callbackUrl,required"`
	// List of event types to subscribe to.
	Events param.Field[[]interface{}] `json:"events,required"`
	// Optional: A custom shared secret for verifying webhook payloads. If omitted, one
	// will be generated.
	Secret param.Field[interface{}] `json:"secret"`
}

func (DeveloperWebhookNewParams) MarshalJSON 

func (r DeveloperWebhookNewParams) MarshalJSON() (data []byte, err error)

type DeveloperWebhookService 

type DeveloperWebhookService struct {
	Options []option.RequestOption
}

DeveloperWebhookService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeveloperWebhookService method instead.

func NewDeveloperWebhookService 

func NewDeveloperWebhookService(opts ...option.RequestOption) (r *DeveloperWebhookService)

NewDeveloperWebhookService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeveloperWebhookService) Delete 

func (r *DeveloperWebhookService) Delete(ctx context.Context, subscriptionID interface{}, opts ...option.RequestOption) (err error)

Deletes an existing webhook subscription, stopping all future event notifications to the specified callback URL.

func (*DeveloperWebhookService) List 

func (r *DeveloperWebhookService) List(ctx context.Context, query DeveloperWebhookListParams, opts ...option.RequestOption) (res *DeveloperWebhookListResponse, err error)

Retrieves a list of all active webhook subscriptions for the authenticated developer application, detailing endpoint URLs, subscribed events, and current status.

func (*DeveloperWebhookService) New 

func (r *DeveloperWebhookService) New(ctx context.Context, body DeveloperWebhookNewParams, opts ...option.RequestOption) (res *WebhookSubscription, err error)

Establishes a new webhook subscription, allowing a developer application to receive real-time notifications for specified events (e.g., new transaction, account update) via a provided callback URL.

func (*DeveloperWebhookService) Update 

func (r *DeveloperWebhookService) Update(ctx context.Context, subscriptionID interface{}, body DeveloperWebhookUpdateParams, opts ...option.RequestOption) (res *WebhookSubscription, err error)

Modifies an existing webhook subscription, allowing changes to the callback URL, subscribed events, or activation status.

type DeveloperWebhookUpdateParams 

type DeveloperWebhookUpdateParams struct {
	// Updated URL where webhook events will be sent.
	CallbackURL param.Field[interface{}] `json:"callbackUrl"`
	// Updated list of event types subscribed to.
	Events param.Field[[]interface{}] `json:"events"`
	// Updated status of the webhook subscription.
	Status param.Field[DeveloperWebhookUpdateParamsStatus] `json:"status"`
}

func (DeveloperWebhookUpdateParams) MarshalJSON 

func (r DeveloperWebhookUpdateParams) MarshalJSON() (data []byte, err error)

type DeveloperWebhookUpdateParamsStatus 

type DeveloperWebhookUpdateParamsStatus string

Updated status of the webhook subscription. 

const (
	DeveloperWebhookUpdateParamsStatusActive    DeveloperWebhookUpdateParamsStatus = "active"
	DeveloperWebhookUpdateParamsStatusPaused    DeveloperWebhookUpdateParamsStatus = "paused"
	DeveloperWebhookUpdateParamsStatusSuspended DeveloperWebhookUpdateParamsStatus = "suspended"
)

func (DeveloperWebhookUpdateParamsStatus) IsKnown 

func (r DeveloperWebhookUpdateParamsStatus) IsKnown() bool

type Device 

type Device struct {
	// Unique identifier for the device.
	ID interface{} `json:"id,required"`
	// Last known IP address of the device.
	IPAddress interface{} `json:"ipAddress,required"`
	// Timestamp of the last activity from this device.
	LastActive interface{} `json:"lastActive,required"`
	// Model of the device.
	Model interface{} `json:"model,required"`
	// Operating system of the device.
	Os interface{} `json:"os,required"`
	// Security trust level of the device.
	TrustLevel DeviceTrustLevel `json:"trustLevel,required"`
	// Type of the device.
	Type DeviceType `json:"type,required"`
	// User-assigned name for the device.
	DeviceName interface{} `json:"deviceName"`
	// Push notification token for the device.
	PushToken interface{} `json:"pushToken"`
	JSON      deviceJSON  `json:"-"`
}

Information about a connected device.

func (*Device) UnmarshalJSON 

func (r *Device) UnmarshalJSON(data []byte) (err error)

type DeviceTrustLevel 

type DeviceTrustLevel string

Security trust level of the device. 

const (
	DeviceTrustLevelTrusted             DeviceTrustLevel = "trusted"
	DeviceTrustLevelPendingVerification DeviceTrustLevel = "pending_verification"
	DeviceTrustLevelUntrusted           DeviceTrustLevel = "untrusted"
	DeviceTrustLevelBlocked             DeviceTrustLevel = "blocked"
)

func (DeviceTrustLevel) IsKnown 

func (r DeviceTrustLevel) IsKnown() bool

type DeviceType 

type DeviceType string

Type of the device. 

const (
	DeviceTypeMobile     DeviceType = "mobile"
	DeviceTypeDesktop    DeviceType = "desktop"
	DeviceTypeTablet     DeviceType = "tablet"
	DeviceTypeSmartWatch DeviceType = "smart_watch"
)

func (DeviceType) IsKnown 

func (r DeviceType) IsKnown() bool

type Error 

type Error = apierror.Error

type FinancialAnomaly 

type FinancialAnomaly struct {
	// Unique identifier for the detected anomaly.
	ID interface{} `json:"id,required"`
	// AI's confidence in its detection of the anomaly (0-1).
	AIConfidenceScore interface{} `json:"aiConfidenceScore,required"`
	// A brief summary of the anomaly.
	Description interface{} `json:"description,required"`
	// The ID of the specific entity (e.g., transaction, user, card) the anomaly is
	// linked to.
	EntityID interface{} `json:"entityId,required"`
	// The type of financial entity related to the anomaly.
	EntityType FinancialAnomalyEntityType `json:"entityType,required"`
	// AI-recommended immediate action to address the anomaly.
	RecommendedAction interface{} `json:"recommendedAction,required"`
	// AI-assigned risk score (0-100), higher is more risky.
	RiskScore interface{} `json:"riskScore,required"`
	// AI-assessed severity of the anomaly.
	Severity FinancialAnomalySeverity `json:"severity,required"`
	// Current review status of the anomaly.
	Status FinancialAnomalyStatus `json:"status,required"`
	// Timestamp when the anomaly was detected.
	Timestamp interface{} `json:"timestamp,required"`
	// Detailed context and reasoning behind the anomaly detection.
	Details interface{} `json:"details"`
	// List of IDs of other transactions or entities related to this anomaly.
	RelatedTransactions []interface{} `json:"relatedTransactions,nullable"`
	// Notes recorded during the resolution or dismissal of the anomaly.
	ResolutionNotes interface{}          `json:"resolutionNotes"`
	JSON            financialAnomalyJSON `json:"-"`
}

func (*FinancialAnomaly) UnmarshalJSON 

func (r *FinancialAnomaly) UnmarshalJSON(data []byte) (err error)

type FinancialAnomalyEntityType 

type FinancialAnomalyEntityType string

The type of financial entity related to the anomaly. 

const (
	FinancialAnomalyEntityTypePaymentOrder  FinancialAnomalyEntityType = "PaymentOrder"
	FinancialAnomalyEntityTypeTransaction   FinancialAnomalyEntityType = "Transaction"
	FinancialAnomalyEntityTypeCounterparty  FinancialAnomalyEntityType = "Counterparty"
	FinancialAnomalyEntityTypeCorporateCard FinancialAnomalyEntityType = "CorporateCard"
	FinancialAnomalyEntityTypeUser          FinancialAnomalyEntityType = "User"
	FinancialAnomalyEntityTypeInvoice       FinancialAnomalyEntityType = "Invoice"
)

func (FinancialAnomalyEntityType) IsKnown 

func (r FinancialAnomalyEntityType) IsKnown() bool

type FinancialAnomalySeverity 

type FinancialAnomalySeverity string

AI-assessed severity of the anomaly. 

const (
	FinancialAnomalySeverityLow      FinancialAnomalySeverity = "Low"
	FinancialAnomalySeverityMedium   FinancialAnomalySeverity = "Medium"
	FinancialAnomalySeverityHigh     FinancialAnomalySeverity = "High"
	FinancialAnomalySeverityCritical FinancialAnomalySeverity = "Critical"
)

func (FinancialAnomalySeverity) IsKnown 

func (r FinancialAnomalySeverity) IsKnown() bool

type FinancialAnomalyStatus 

type FinancialAnomalyStatus string

Current review status of the anomaly. 

const (
	FinancialAnomalyStatusNew         FinancialAnomalyStatus = "New"
	FinancialAnomalyStatusUnderReview FinancialAnomalyStatus = "Under Review"
	FinancialAnomalyStatusEscalated   FinancialAnomalyStatus = "Escalated"
	FinancialAnomalyStatusDismissed   FinancialAnomalyStatus = "Dismissed"
	FinancialAnomalyStatusResolved    FinancialAnomalyStatus = "Resolved"
)

func (FinancialAnomalyStatus) IsKnown 

func (r FinancialAnomalyStatus) IsKnown() bool

type FinancialGoal 

type FinancialGoal struct {
	// Unique identifier for the financial goal.
	ID interface{} `json:"id,required"`
	// The current amount saved or invested towards the goal.
	CurrentAmount interface{} `json:"currentAmount,required"`
	// Timestamp when the goal's status or progress was last updated.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Name of the financial goal.
	Name interface{} `json:"name,required"`
	// Percentage completion of the goal.
	ProgressPercentage interface{} `json:"progressPercentage,required"`
	// Current status of the goal's progress.
	Status FinancialGoalStatus `json:"status,required"`
	// The target monetary amount for the goal.
	TargetAmount interface{} `json:"targetAmount,required"`
	// The target completion date for the goal.
	TargetDate interface{} `json:"targetDate,required"`
	// Type of financial goal.
	Type FinancialGoalType `json:"type,required"`
	// AI-driven insights and recommendations related to this goal.
	AIInsights []AIInsight `json:"aiInsights,nullable"`
	// AI-generated strategic plan for achieving the goal.
	AIStrategicPlan FinancialGoalAIStrategicPlan `json:"aiStrategicPlan"`
	// List of account IDs contributing to this goal.
	ContributingAccounts []interface{} `json:"contributingAccounts,nullable"`
	// Recommended or chosen risk tolerance for investments related to this goal.
	RiskTolerance FinancialGoalRiskTolerance `json:"riskTolerance,nullable"`
	JSON          financialGoalJSON          `json:"-"`
}

func (*FinancialGoal) UnmarshalJSON 

func (r *FinancialGoal) UnmarshalJSON(data []byte) (err error)

type FinancialGoalAIStrategicPlan 

type FinancialGoalAIStrategicPlan struct {
	PlanID  interface{}                        `json:"planId"`
	Steps   []FinancialGoalAIStrategicPlanStep `json:"steps"`
	Summary interface{}                        `json:"summary"`
	JSON    financialGoalAIStrategicPlanJSON   `json:"-"`
}

AI-generated strategic plan for achieving the goal.

func (*FinancialGoalAIStrategicPlan) UnmarshalJSON 

func (r *FinancialGoalAIStrategicPlan) UnmarshalJSON(data []byte) (err error)

type FinancialGoalAIStrategicPlanStep 

type FinancialGoalAIStrategicPlanStep struct {
	Description interface{}                             `json:"description"`
	Status      FinancialGoalAIStrategicPlanStepsStatus `json:"status"`
	Title       interface{}                             `json:"title"`
	JSON        financialGoalAIStrategicPlanStepJSON    `json:"-"`
}

func (*FinancialGoalAIStrategicPlanStep) UnmarshalJSON 

func (r *FinancialGoalAIStrategicPlanStep) UnmarshalJSON(data []byte) (err error)

type FinancialGoalAIStrategicPlanStepsStatus 

type FinancialGoalAIStrategicPlanStepsStatus string
const (
	FinancialGoalAIStrategicPlanStepsStatusPending    FinancialGoalAIStrategicPlanStepsStatus = "pending"
	FinancialGoalAIStrategicPlanStepsStatusInProgress FinancialGoalAIStrategicPlanStepsStatus = "in_progress"
	FinancialGoalAIStrategicPlanStepsStatusCompleted  FinancialGoalAIStrategicPlanStepsStatus = "completed"
)

func (FinancialGoalAIStrategicPlanStepsStatus) IsKnown 

func (r FinancialGoalAIStrategicPlanStepsStatus) IsKnown() bool

type FinancialGoalRiskTolerance 

type FinancialGoalRiskTolerance string

Recommended or chosen risk tolerance for investments related to this goal. 

const (
	FinancialGoalRiskToleranceConservative FinancialGoalRiskTolerance = "conservative"
	FinancialGoalRiskToleranceModerate     FinancialGoalRiskTolerance = "moderate"
	FinancialGoalRiskToleranceAggressive   FinancialGoalRiskTolerance = "aggressive"
)

func (FinancialGoalRiskTolerance) IsKnown 

func (r FinancialGoalRiskTolerance) IsKnown() bool

type FinancialGoalStatus 

type FinancialGoalStatus string

Current status of the goal's progress. 

const (
	FinancialGoalStatusOnTrack         FinancialGoalStatus = "on_track"
	FinancialGoalStatusBehindSchedule  FinancialGoalStatus = "behind_schedule"
	FinancialGoalStatusAheadOfSchedule FinancialGoalStatus = "ahead_of_schedule"
	FinancialGoalStatusCompleted       FinancialGoalStatus = "completed"
	FinancialGoalStatusPaused          FinancialGoalStatus = "paused"
	FinancialGoalStatusCancelled       FinancialGoalStatus = "cancelled"
)

func (FinancialGoalStatus) IsKnown 

func (r FinancialGoalStatus) IsKnown() bool

type FinancialGoalType 

type FinancialGoalType string

Type of financial goal. 

const (
	FinancialGoalTypeRetirement    FinancialGoalType = "retirement"
	FinancialGoalTypeHomePurchase  FinancialGoalType = "home_purchase"
	FinancialGoalTypeEducation     FinancialGoalType = "education"
	FinancialGoalTypeLargePurchase FinancialGoalType = "large_purchase"
	FinancialGoalTypeDebtReduction FinancialGoalType = "debt_reduction"
	FinancialGoalTypeOther         FinancialGoalType = "other"
)

func (FinancialGoalType) IsKnown 

func (r FinancialGoalType) IsKnown() bool

type FraudRule 

type FraudRule struct {
	// Unique identifier for the fraud detection rule.
	ID interface{} `json:"id,required"`
	// Action to take when a fraud rule is triggered.
	Action FraudRuleAction `json:"action,required"`
	// Timestamp when the rule was created.
	CreatedAt interface{} `json:"createdAt,required"`
	// Identifier of who created the rule (e.g., user ID, 'system:ai-risk-engine').
	CreatedBy interface{} `json:"createdBy,required"`
	// Criteria that define when a fraud rule should trigger.
	Criteria FraudRuleCriteria `json:"criteria,required"`
	// Detailed description of what the rule detects.
	Description interface{} `json:"description,required"`
	// Timestamp when the rule was last updated.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Name of the fraud rule.
	Name interface{} `json:"name,required"`
	// Severity level when this rule is triggered.
	Severity FraudRuleSeverity `json:"severity,required"`
	// Current status of the rule.
	Status FraudRuleStatus `json:"status,required"`
	JSON   fraudRuleJSON   `json:"-"`
}

func (*FraudRule) UnmarshalJSON 

func (r *FraudRule) UnmarshalJSON(data []byte) (err error)

type FraudRuleAction 

type FraudRuleAction struct {
	// Details or instructions for the action.
	Details interface{} `json:"details,required"`
	// Type of action to perform.
	Type FraudRuleActionType `json:"type,required"`
	// The team or department to notify for alerts/reviews.
	TargetTeam interface{}         `json:"targetTeam"`
	JSON       fraudRuleActionJSON `json:"-"`
}

Action to take when a fraud rule is triggered.

func (*FraudRuleAction) UnmarshalJSON 

func (r *FraudRuleAction) UnmarshalJSON(data []byte) (err error)

type FraudRuleActionParam 

type FraudRuleActionParam struct {
	// Details or instructions for the action.
	Details param.Field[interface{}] `json:"details,required"`
	// Type of action to perform.
	Type param.Field[FraudRuleActionType] `json:"type,required"`
	// The team or department to notify for alerts/reviews.
	TargetTeam param.Field[interface{}] `json:"targetTeam"`
}

Action to take when a fraud rule is triggered.

func (FraudRuleActionParam) MarshalJSON 

func (r FraudRuleActionParam) MarshalJSON() (data []byte, err error)

type FraudRuleActionType 

type FraudRuleActionType string

Type of action to perform. 

const (
	FraudRuleActionTypeBlock        FraudRuleActionType = "block"
	FraudRuleActionTypeAlert        FraudRuleActionType = "alert"
	FraudRuleActionTypeAutoReview   FraudRuleActionType = "auto_review"
	FraudRuleActionTypeManualReview FraudRuleActionType = "manual_review"
	FraudRuleActionTypeRequestMfa   FraudRuleActionType = "request_mfa"
)

func (FraudRuleActionType) IsKnown 

func (r FraudRuleActionType) IsKnown() bool

type FraudRuleCriteria 

type FraudRuleCriteria struct {
	// Number of days an account must be inactive for the rule to apply.
	AccountInactivityDays interface{} `json:"accountInactivityDays"`
	// List of ISO 2-letter country codes for transaction origin.
	CountryOfOrigin []interface{} `json:"countryOfOrigin,nullable"`
	// Minimum geographic distance (in km) from recent activity for anomaly.
	GeographicDistanceKm interface{} `json:"geographicDistanceKm"`
	// Number of days since last user login for anomaly detection.
	LastLoginDays interface{} `json:"lastLoginDays"`
	// If true, rule applies only if no prior travel notification was made.
	NoTravelNotification interface{} `json:"noTravelNotification"`
	// Minimum number of payments in a timeframe.
	PaymentCountMin interface{} `json:"paymentCountMin"`
	// List of risk levels for recipient countries.
	RecipientCountryRiskLevel []FraudRuleCriteriaRecipientCountryRiskLevel `json:"recipientCountryRiskLevel,nullable"`
	// If true, recipient must be a new payee.
	RecipientNew interface{} `json:"recipientNew"`
	// Timeframe in hours for payment count or other event aggregations.
	TimeframeHours interface{} `json:"timeframeHours"`
	// Minimum transaction amount to consider.
	TransactionAmountMin interface{} `json:"transactionAmountMin"`
	// Specific transaction type (e.g., debit, credit).
	TransactionType FraudRuleCriteriaTransactionType `json:"transactionType,nullable"`
	JSON            fraudRuleCriteriaJSON            `json:"-"`
}

Criteria that define when a fraud rule should trigger.

func (*FraudRuleCriteria) UnmarshalJSON 

func (r *FraudRuleCriteria) UnmarshalJSON(data []byte) (err error)

type FraudRuleCriteriaParam 

type FraudRuleCriteriaParam struct {
	// Number of days an account must be inactive for the rule to apply.
	AccountInactivityDays param.Field[interface{}] `json:"accountInactivityDays"`
	// List of ISO 2-letter country codes for transaction origin.
	CountryOfOrigin param.Field[[]interface{}] `json:"countryOfOrigin"`
	// Minimum geographic distance (in km) from recent activity for anomaly.
	GeographicDistanceKm param.Field[interface{}] `json:"geographicDistanceKm"`
	// Number of days since last user login for anomaly detection.
	LastLoginDays param.Field[interface{}] `json:"lastLoginDays"`
	// If true, rule applies only if no prior travel notification was made.
	NoTravelNotification param.Field[interface{}] `json:"noTravelNotification"`
	// Minimum number of payments in a timeframe.
	PaymentCountMin param.Field[interface{}] `json:"paymentCountMin"`
	// List of risk levels for recipient countries.
	RecipientCountryRiskLevel param.Field[[]FraudRuleCriteriaRecipientCountryRiskLevel] `json:"recipientCountryRiskLevel"`
	// If true, recipient must be a new payee.
	RecipientNew param.Field[interface{}] `json:"recipientNew"`
	// Timeframe in hours for payment count or other event aggregations.
	TimeframeHours param.Field[interface{}] `json:"timeframeHours"`
	// Minimum transaction amount to consider.
	TransactionAmountMin param.Field[interface{}] `json:"transactionAmountMin"`
	// Specific transaction type (e.g., debit, credit).
	TransactionType param.Field[FraudRuleCriteriaTransactionType] `json:"transactionType"`
}

Criteria that define when a fraud rule should trigger.

func (FraudRuleCriteriaParam) MarshalJSON 

func (r FraudRuleCriteriaParam) MarshalJSON() (data []byte, err error)

type FraudRuleCriteriaRecipientCountryRiskLevel 

type FraudRuleCriteriaRecipientCountryRiskLevel string
const (
	FraudRuleCriteriaRecipientCountryRiskLevelLow      FraudRuleCriteriaRecipientCountryRiskLevel = "Low"
	FraudRuleCriteriaRecipientCountryRiskLevelMedium   FraudRuleCriteriaRecipientCountryRiskLevel = "Medium"
	FraudRuleCriteriaRecipientCountryRiskLevelHigh     FraudRuleCriteriaRecipientCountryRiskLevel = "High"
	FraudRuleCriteriaRecipientCountryRiskLevelVeryHigh FraudRuleCriteriaRecipientCountryRiskLevel = "Very High"
)

func (FraudRuleCriteriaRecipientCountryRiskLevel) IsKnown 

func (r FraudRuleCriteriaRecipientCountryRiskLevel) IsKnown() bool

type FraudRuleCriteriaTransactionType 

type FraudRuleCriteriaTransactionType string

Specific transaction type (e.g., debit, credit). 

const (
	FraudRuleCriteriaTransactionTypeDebit  FraudRuleCriteriaTransactionType = "debit"
	FraudRuleCriteriaTransactionTypeCredit FraudRuleCriteriaTransactionType = "credit"
)

func (FraudRuleCriteriaTransactionType) IsKnown 

func (r FraudRuleCriteriaTransactionType) IsKnown() bool

type FraudRuleSeverity 

type FraudRuleSeverity string

Severity level when this rule is triggered. 

const (
	FraudRuleSeverityLow      FraudRuleSeverity = "Low"
	FraudRuleSeverityMedium   FraudRuleSeverity = "Medium"
	FraudRuleSeverityHigh     FraudRuleSeverity = "High"
	FraudRuleSeverityCritical FraudRuleSeverity = "Critical"
)

func (FraudRuleSeverity) IsKnown 

func (r FraudRuleSeverity) IsKnown() bool

type FraudRuleStatus 

type FraudRuleStatus string

Current status of the rule. 

const (
	FraudRuleStatusActive   FraudRuleStatus = "active"
	FraudRuleStatusInactive FraudRuleStatus = "inactive"
	FraudRuleStatusDraft    FraudRuleStatus = "draft"
)

func (FraudRuleStatus) IsKnown 

func (r FraudRuleStatus) IsKnown() bool

type GenerateVideoAspectRatio 

type GenerateVideoAspectRatio string

Aspect ratio of the video (e.g., 16:9 for widescreen, 9:16 for vertical shorts). 

const (
	GenerateVideoAspectRatio16_9 GenerateVideoAspectRatio = "16:9"
	GenerateVideoAspectRatio9_16 GenerateVideoAspectRatio = "9:16"
	GenerateVideoAspectRatio1_1  GenerateVideoAspectRatio = "1:1"
)

func (GenerateVideoAspectRatio) IsKnown 

func (r GenerateVideoAspectRatio) IsKnown() bool

type GenerateVideoParam 

type GenerateVideoParam struct {
	// Desired length of the video in seconds.
	LengthSeconds param.Field[interface{}] `json:"lengthSeconds,required"`
	// The textual prompt to guide the AI video generation.
	Prompt param.Field[interface{}] `json:"prompt,required"`
	// Artistic style of the video.
	Style param.Field[GenerateVideoStyle] `json:"style,required"`
	// Aspect ratio of the video (e.g., 16:9 for widescreen, 9:16 for vertical shorts).
	AspectRatio param.Field[GenerateVideoAspectRatio] `json:"aspectRatio"`
	// Optional: Hex color codes to influence the video's aesthetic.
	BrandColors param.Field[[]interface{}] `json:"brandColors"`
	// Optional: Additional keywords to guide the AI's content generation.
	Keywords param.Field[[]interface{}] `json:"keywords"`
}

func (GenerateVideoParam) MarshalJSON 

func (r GenerateVideoParam) MarshalJSON() (data []byte, err error)

type GenerateVideoStyle 

type GenerateVideoStyle string

Artistic style of the video. 

const (
	GenerateVideoStyleCinematic   GenerateVideoStyle = "Cinematic"
	GenerateVideoStyleExplainer   GenerateVideoStyle = "Explainer"
	GenerateVideoStyleDocumentary GenerateVideoStyle = "Documentary"
	GenerateVideoStyleAbstract    GenerateVideoStyle = "Abstract"
	GenerateVideoStyleMinimalist  GenerateVideoStyle = "Minimalist"
)

func (GenerateVideoStyle) IsKnown 

func (r GenerateVideoStyle) IsKnown() bool

type GoalListParams 

type GoalListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (GoalListParams) URLQuery 

func (r GoalListParams) URLQuery() (v url.Values)

URLQuery serializes GoalListParams's query parameters as `url.Values`.

type GoalListResponse 

type GoalListResponse struct {
	Data []FinancialGoal      `json:"data"`
	JSON goalListResponseJSON `json:"-"`
	PaginatedList
}

func (*GoalListResponse) UnmarshalJSON 

func (r *GoalListResponse) UnmarshalJSON(data []byte) (err error)

type GoalNewParams 

type GoalNewParams struct {
	// Name of the new financial goal.
	Name param.Field[interface{}] `json:"name,required"`
	// The target monetary amount for the goal.
	TargetAmount param.Field[interface{}] `json:"targetAmount,required"`
	// The target completion date for the goal.
	TargetDate param.Field[interface{}] `json:"targetDate,required"`
	// Type of financial goal.
	Type param.Field[GoalNewParamsType] `json:"type,required"`
	// Optional: List of account IDs initially contributing to this goal.
	ContributingAccounts param.Field[[]interface{}] `json:"contributingAccounts"`
	// If true, AI will automatically generate a strategic plan for the goal.
	GenerateAIPlan param.Field[interface{}] `json:"generateAIPlan"`
	// Optional: Initial amount to contribute to the goal.
	InitialContribution param.Field[interface{}] `json:"initialContribution"`
	// Desired risk tolerance for investments related to this goal.
	RiskTolerance param.Field[GoalNewParamsRiskTolerance] `json:"riskTolerance"`
}

func (GoalNewParams) MarshalJSON 

func (r GoalNewParams) MarshalJSON() (data []byte, err error)

type GoalNewParamsRiskTolerance 

type GoalNewParamsRiskTolerance string

Desired risk tolerance for investments related to this goal. 

const (
	GoalNewParamsRiskToleranceConservative GoalNewParamsRiskTolerance = "conservative"
	GoalNewParamsRiskToleranceModerate     GoalNewParamsRiskTolerance = "moderate"
	GoalNewParamsRiskToleranceAggressive   GoalNewParamsRiskTolerance = "aggressive"
)

func (GoalNewParamsRiskTolerance) IsKnown 

func (r GoalNewParamsRiskTolerance) IsKnown() bool

type GoalNewParamsType 

type GoalNewParamsType string

Type of financial goal. 

const (
	GoalNewParamsTypeRetirement    GoalNewParamsType = "retirement"
	GoalNewParamsTypeHomePurchase  GoalNewParamsType = "home_purchase"
	GoalNewParamsTypeEducation     GoalNewParamsType = "education"
	GoalNewParamsTypeLargePurchase GoalNewParamsType = "large_purchase"
	GoalNewParamsTypeDebtReduction GoalNewParamsType = "debt_reduction"
	GoalNewParamsTypeOther         GoalNewParamsType = "other"
)

func (GoalNewParamsType) IsKnown 

func (r GoalNewParamsType) IsKnown() bool

type GoalService 

type GoalService struct {
	Options []option.RequestOption
}

GoalService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewGoalService method instead.

func NewGoalService 

func NewGoalService(opts ...option.RequestOption) (r *GoalService)

NewGoalService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*GoalService) Delete 

func (r *GoalService) Delete(ctx context.Context, goalID interface{}, opts ...option.RequestOption) (err error)

Deletes a specific financial goal from the user's profile.

func (*GoalService) Get 

func (r *GoalService) Get(ctx context.Context, goalID interface{}, opts ...option.RequestOption) (res *FinancialGoal, err error)

Retrieves detailed information for a specific financial goal, including current progress, AI strategic plan, and related insights.

func (*GoalService) List 

func (r *GoalService) List(ctx context.Context, query GoalListParams, opts ...option.RequestOption) (res *GoalListResponse, err error)

Retrieves a list of all financial goals defined by the user, including their progress and associated AI plans.

func (*GoalService) New 

func (r *GoalService) New(ctx context.Context, body GoalNewParams, opts ...option.RequestOption) (res *FinancialGoal, err error)

Creates a new long-term financial goal, with optional AI plan generation.

func (*GoalService) Update 

func (r *GoalService) Update(ctx context.Context, goalID interface{}, body GoalUpdateParams, opts ...option.RequestOption) (res *FinancialGoal, err error)

Updates the parameters of an existing financial goal, such as target amount, date, or contributing accounts. This may trigger an AI plan recalculation.

type GoalUpdateParams 

type GoalUpdateParams struct {
	// Updated list of account IDs contributing to this goal.
	ContributingAccounts param.Field[[]interface{}] `json:"contributingAccounts"`
	// If true, AI will recalculate and update the strategic plan for the goal.
	GenerateAIPlan param.Field[interface{}] `json:"generateAIPlan"`
	// Updated name of the financial goal.
	Name param.Field[interface{}] `json:"name"`
	// Updated risk tolerance for investments related to this goal.
	RiskTolerance param.Field[GoalUpdateParamsRiskTolerance] `json:"riskTolerance"`
	// Updated status of the goal's progress.
	Status param.Field[GoalUpdateParamsStatus] `json:"status"`
	// The updated target monetary amount for the goal.
	TargetAmount param.Field[interface{}] `json:"targetAmount"`
	// The updated target completion date for the goal.
	TargetDate param.Field[interface{}] `json:"targetDate"`
}

func (GoalUpdateParams) MarshalJSON 

func (r GoalUpdateParams) MarshalJSON() (data []byte, err error)

type GoalUpdateParamsRiskTolerance 

type GoalUpdateParamsRiskTolerance string

Updated risk tolerance for investments related to this goal. 

const (
	GoalUpdateParamsRiskToleranceConservative GoalUpdateParamsRiskTolerance = "conservative"
	GoalUpdateParamsRiskToleranceModerate     GoalUpdateParamsRiskTolerance = "moderate"
	GoalUpdateParamsRiskToleranceAggressive   GoalUpdateParamsRiskTolerance = "aggressive"
)

func (GoalUpdateParamsRiskTolerance) IsKnown 

func (r GoalUpdateParamsRiskTolerance) IsKnown() bool

type GoalUpdateParamsStatus 

type GoalUpdateParamsStatus string

Updated status of the goal's progress. 

const (
	GoalUpdateParamsStatusOnTrack         GoalUpdateParamsStatus = "on_track"
	GoalUpdateParamsStatusBehindSchedule  GoalUpdateParamsStatus = "behind_schedule"
	GoalUpdateParamsStatusAheadOfSchedule GoalUpdateParamsStatus = "ahead_of_schedule"
	GoalUpdateParamsStatusCompleted       GoalUpdateParamsStatus = "completed"
	GoalUpdateParamsStatusPaused          GoalUpdateParamsStatus = "paused"
	GoalUpdateParamsStatusCancelled       GoalUpdateParamsStatus = "cancelled"
)

func (GoalUpdateParamsStatus) IsKnown 

func (r GoalUpdateParamsStatus) IsKnown() bool

type IdentityKYCService 

type IdentityKYCService struct {
	Options []option.RequestOption
}

IdentityKYCService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewIdentityKYCService method instead.

func NewIdentityKYCService 

func NewIdentityKYCService(opts ...option.RequestOption) (r *IdentityKYCService)

NewIdentityKYCService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*IdentityKYCService) GetStatus 

func (r *IdentityKYCService) GetStatus(ctx context.Context, opts ...option.RequestOption) (res *KYCStatus, err error)

Retrieves the current status of the user's Know Your Customer (KYC) verification process.

func (*IdentityKYCService) Submit 

func (r *IdentityKYCService) Submit(ctx context.Context, body IdentityKYCSubmitParams, opts ...option.RequestOption) (res *KYCStatus, err error)

Submits Know Your Customer (KYC) documentation, such as identity proofs and address verification, for AI-accelerated compliance and identity verification, crucial for higher service tiers and regulatory adherence.

type IdentityKYCSubmitParams 

type IdentityKYCSubmitParams struct {
	// The two-letter ISO country code where the document was issued.
	CountryOfIssue param.Field[interface{}] `json:"countryOfIssue,required"`
	// The identification number on the document.
	DocumentNumber param.Field[interface{}] `json:"documentNumber,required"`
	// The type of KYC document being submitted.
	DocumentType param.Field[IdentityKYCSubmitParamsDocumentType] `json:"documentType,required"`
	// The expiration date of the document (YYYY-MM-DD).
	ExpirationDate param.Field[interface{}] `json:"expirationDate,required"`
	// The issue date of the document (YYYY-MM-DD).
	IssueDate param.Field[interface{}] `json:"issueDate,required"`
	// Array of additional documents (e.g., utility bills) as base64 encoded images.
	AdditionalDocuments param.Field[[]interface{}] `json:"additionalDocuments"`
	// Base64 encoded image of the back of the document (if applicable).
	DocumentBackImage param.Field[interface{}] `json:"documentBackImage"`
	// Base64 encoded image of the front of the document. Use 'application/json' with
	// base64 string, or 'multipart/form-data' for direct file upload.
	DocumentFrontImage param.Field[interface{}] `json:"documentFrontImage"`
}

func (IdentityKYCSubmitParams) MarshalJSON 

func (r IdentityKYCSubmitParams) MarshalJSON() (data []byte, err error)

type IdentityKYCSubmitParamsDocumentType 

type IdentityKYCSubmitParamsDocumentType string

The type of KYC document being submitted. 

const (
	IdentityKYCSubmitParamsDocumentTypeDriversLicense IdentityKYCSubmitParamsDocumentType = "drivers_license"
	IdentityKYCSubmitParamsDocumentTypePassport       IdentityKYCSubmitParamsDocumentType = "passport"
	IdentityKYCSubmitParamsDocumentTypeNationalID     IdentityKYCSubmitParamsDocumentType = "national_id"
	IdentityKYCSubmitParamsDocumentTypeUtilityBill    IdentityKYCSubmitParamsDocumentType = "utility_bill"
	IdentityKYCSubmitParamsDocumentTypeBankStatement  IdentityKYCSubmitParamsDocumentType = "bank_statement"
	IdentityKYCSubmitParamsDocumentTypeOther          IdentityKYCSubmitParamsDocumentType = "other"
)

func (IdentityKYCSubmitParamsDocumentType) IsKnown 

func (r IdentityKYCSubmitParamsDocumentType) IsKnown() bool

type IdentityService 

type IdentityService struct {
	Options []option.RequestOption
	KYC     *IdentityKYCService
}

IdentityService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewIdentityService method instead.

func NewIdentityService 

func NewIdentityService(opts ...option.RequestOption) (r *IdentityService)

NewIdentityService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type InternationalPaymentStatus 

type InternationalPaymentStatus struct {
	// The foreign exchange rate applied (target per source currency).
	FxRateApplied interface{} `json:"fxRateApplied,required"`
	// Unique identifier for the international payment.
	PaymentID interface{} `json:"paymentId,required"`
	// The amount sent in the source currency.
	SourceAmount interface{} `json:"sourceAmount,required"`
	// The source currency code.
	SourceCurrency interface{} `json:"sourceCurrency,required"`
	// Current processing status of the payment.
	Status InternationalPaymentStatusStatus `json:"status,required"`
	// The amount received by the beneficiary in the target currency.
	TargetAmount interface{} `json:"targetAmount,required"`
	// The target currency code.
	TargetCurrency interface{} `json:"targetCurrency,required"`
	// Estimated time when the payment will be completed.
	EstimatedCompletionTime interface{} `json:"estimatedCompletionTime"`
	// Total fees applied to the payment.
	FeesApplied interface{} `json:"feesApplied"`
	// An optional message providing more context on the status (e.g., reason for
	// hold).
	Message interface{} `json:"message"`
	// URL to track the payment's progress.
	TrackingURL interface{}                    `json:"trackingUrl"`
	JSON        internationalPaymentStatusJSON `json:"-"`
}

func (*InternationalPaymentStatus) UnmarshalJSON 

func (r *InternationalPaymentStatus) UnmarshalJSON(data []byte) (err error)

type InternationalPaymentStatusStatus 

type InternationalPaymentStatusStatus string

Current processing status of the payment. 

const (
	InternationalPaymentStatusStatusInProgress    InternationalPaymentStatusStatus = "in_progress"
	InternationalPaymentStatusStatusHeldForReview InternationalPaymentStatusStatus = "held_for_review"
	InternationalPaymentStatusStatusCompleted     InternationalPaymentStatusStatus = "completed"
	InternationalPaymentStatusStatusFailed        InternationalPaymentStatusStatus = "failed"
	InternationalPaymentStatusStatusCancelled     InternationalPaymentStatusStatus = "cancelled"
)

func (InternationalPaymentStatusStatus) IsKnown 

func (r InternationalPaymentStatusStatus) IsKnown() bool

type InvestmentAssetSearchParams 

type InvestmentAssetSearchParams struct {
	// Search query for asset name or symbol.
	Query param.Field[interface{}] `query:"query,required"`
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Minimum desired ESG score (0-10).
	MinEsgScore param.Field[interface{}] `query:"minESGScore"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (InvestmentAssetSearchParams) URLQuery 

func (r InvestmentAssetSearchParams) URLQuery() (v url.Values)

URLQuery serializes InvestmentAssetSearchParams's query parameters as `url.Values`.

type InvestmentAssetSearchResponse 

type InvestmentAssetSearchResponse struct {
	Data []InvestmentAssetSearchResponseData `json:"data"`
	JSON investmentAssetSearchResponseJSON   `json:"-"`
	PaginatedList
}

func (*InvestmentAssetSearchResponse) UnmarshalJSON 

func (r *InvestmentAssetSearchResponse) UnmarshalJSON(data []byte) (err error)

type InvestmentAssetSearchResponseData 

type InvestmentAssetSearchResponseData struct {
	// Full name of the investment asset.
	AssetName interface{} `json:"assetName,required"`
	// Symbol of the investment asset.
	AssetSymbol interface{} `json:"assetSymbol,required"`
	// Type of the investment asset.
	AssetType InvestmentAssetSearchResponseDataAssetType `json:"assetType,required"`
	// Currency of the asset's price.
	Currency interface{} `json:"currency,required"`
	// Current market price of the asset.
	CurrentPrice interface{} `json:"currentPrice,required"`
	// Overall ESG score (0-10), higher is better.
	OverallEsgScore interface{} `json:"overallESGScore,required"`
	// AI-generated insight summarizing the ESG profile.
	AIEsgInsight interface{} `json:"aiESGInsight"`
	// Environmental component of the ESG score.
	EnvironmentalScore interface{} `json:"environmentalScore"`
	// List of any significant ESG-related controversies associated with the asset.
	EsgControversies []interface{} `json:"esgControversies,nullable"`
	// Provider of the ESG rating (e.g., MSCI, Sustainalytics).
	EsgRatingProvider interface{} `json:"esgRatingProvider"`
	// Governance component of the ESG score.
	GovernanceScore interface{} `json:"governanceScore"`
	// Social component of the ESG score.
	SocialScore interface{}                           `json:"socialScore"`
	JSON        investmentAssetSearchResponseDataJSON `json:"-"`
}

func (*InvestmentAssetSearchResponseData) UnmarshalJSON 

func (r *InvestmentAssetSearchResponseData) UnmarshalJSON(data []byte) (err error)

type InvestmentAssetSearchResponseDataAssetType 

type InvestmentAssetSearchResponseDataAssetType string

Type of the investment asset. 

const (
	InvestmentAssetSearchResponseDataAssetTypeStock      InvestmentAssetSearchResponseDataAssetType = "stock"
	InvestmentAssetSearchResponseDataAssetTypeEtf        InvestmentAssetSearchResponseDataAssetType = "etf"
	InvestmentAssetSearchResponseDataAssetTypeMutualFund InvestmentAssetSearchResponseDataAssetType = "mutual_fund"
	InvestmentAssetSearchResponseDataAssetTypeBond       InvestmentAssetSearchResponseDataAssetType = "bond"
)

func (InvestmentAssetSearchResponseDataAssetType) IsKnown 

func (r InvestmentAssetSearchResponseDataAssetType) IsKnown() bool

type InvestmentAssetService 

type InvestmentAssetService struct {
	Options []option.RequestOption
}

InvestmentAssetService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewInvestmentAssetService method instead.

func NewInvestmentAssetService 

func NewInvestmentAssetService(opts ...option.RequestOption) (r *InvestmentAssetService)

NewInvestmentAssetService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*InvestmentAssetService) Search 

func (r *InvestmentAssetService) Search(ctx context.Context, query InvestmentAssetSearchParams, opts ...option.RequestOption) (res *InvestmentAssetSearchResponse, err error)

Searches for available investment assets (stocks, ETFs, mutual funds) and returns their ESG impact scores.

type InvestmentPortfolio 

type InvestmentPortfolio struct {
	// Unique identifier for the investment portfolio.
	ID interface{} `json:"id,required"`
	// ISO 4217 currency code of the portfolio.
	Currency interface{} `json:"currency,required"`
	// Timestamp when the portfolio data was last updated.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Name of the portfolio.
	Name interface{} `json:"name,required"`
	// User's stated or AI-assessed risk tolerance for this portfolio.
	RiskTolerance InvestmentPortfolioRiskTolerance `json:"riskTolerance,required"`
	// Daily gain or loss on the portfolio.
	TodayGainLoss interface{} `json:"todayGainLoss,required"`
	// Current total market value of the portfolio.
	TotalValue interface{} `json:"totalValue,required"`
	// General type or strategy of the portfolio.
	Type InvestmentPortfolioType `json:"type,required"`
	// Total unrealized gain or loss on the portfolio.
	UnrealizedGainLoss interface{} `json:"unrealizedGainLoss,required"`
	// AI-driven insights into portfolio performance and market outlook.
	AIPerformanceInsights []AIInsight `json:"aiPerformanceInsights,nullable"`
	// Frequency at which AI-driven rebalancing is set to occur.
	AIRebalancingFrequency InvestmentPortfolioAIRebalancingFrequency `json:"aiRebalancingFrequency,nullable"`
	// List of individual assets held in the portfolio.
	Holdings []InvestmentPortfolioHolding `json:"holdings"`
	JSON     investmentPortfolioJSON      `json:"-"`
}

func (*InvestmentPortfolio) UnmarshalJSON 

func (r *InvestmentPortfolio) UnmarshalJSON(data []byte) (err error)

type InvestmentPortfolioAIRebalancingFrequency 

type InvestmentPortfolioAIRebalancingFrequency string

Frequency at which AI-driven rebalancing is set to occur. 

const (
	InvestmentPortfolioAIRebalancingFrequencyMonthly      InvestmentPortfolioAIRebalancingFrequency = "monthly"
	InvestmentPortfolioAIRebalancingFrequencyQuarterly    InvestmentPortfolioAIRebalancingFrequency = "quarterly"
	InvestmentPortfolioAIRebalancingFrequencySemiAnnually InvestmentPortfolioAIRebalancingFrequency = "semi_annually"
	InvestmentPortfolioAIRebalancingFrequencyAnnually     InvestmentPortfolioAIRebalancingFrequency = "annually"
	InvestmentPortfolioAIRebalancingFrequencyNever        InvestmentPortfolioAIRebalancingFrequency = "never"
)

func (InvestmentPortfolioAIRebalancingFrequency) IsKnown 

func (r InvestmentPortfolioAIRebalancingFrequency) IsKnown() bool

type InvestmentPortfolioHolding 

type InvestmentPortfolioHolding struct {
	// Average cost per unit.
	AverageCost interface{} `json:"averageCost,required"`
	// Current market price per unit.
	CurrentPrice interface{} `json:"currentPrice,required"`
	// Total market value of the holding.
	MarketValue interface{} `json:"marketValue,required"`
	// Full name of the investment asset.
	Name interface{} `json:"name,required"`
	// Percentage of the total portfolio value this holding represents.
	PercentageOfPortfolio interface{} `json:"percentageOfPortfolio,required"`
	// Number of units held.
	Quantity interface{} `json:"quantity,required"`
	// Stock ticker or asset symbol.
	Symbol interface{} `json:"symbol,required"`
	// Overall ESG (Environmental, Social, Governance) score of the asset (0-10).
	EsgScore interface{}                    `json:"esgScore"`
	JSON     investmentPortfolioHoldingJSON `json:"-"`
}

func (*InvestmentPortfolioHolding) UnmarshalJSON 

func (r *InvestmentPortfolioHolding) UnmarshalJSON(data []byte) (err error)

type InvestmentPortfolioListParams 

type InvestmentPortfolioListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (InvestmentPortfolioListParams) URLQuery 

func (r InvestmentPortfolioListParams) URLQuery() (v url.Values)

URLQuery serializes InvestmentPortfolioListParams's query parameters as `url.Values`.

type InvestmentPortfolioListResponse 

type InvestmentPortfolioListResponse struct {
	Data []InvestmentPortfolio               `json:"data"`
	JSON investmentPortfolioListResponseJSON `json:"-"`
	PaginatedList
}

func (*InvestmentPortfolioListResponse) UnmarshalJSON 

func (r *InvestmentPortfolioListResponse) UnmarshalJSON(data []byte) (err error)

type InvestmentPortfolioNewParams 

type InvestmentPortfolioNewParams struct {
	// ISO 4217 currency code of the portfolio.
	Currency param.Field[interface{}] `json:"currency,required"`
	// Initial amount to invest into the portfolio.
	InitialInvestment param.Field[interface{}] `json:"initialInvestment,required"`
	// Name for the new investment portfolio.
	Name param.Field[interface{}] `json:"name,required"`
	// Desired risk tolerance for this portfolio.
	RiskTolerance param.Field[InvestmentPortfolioNewParamsRiskTolerance] `json:"riskTolerance,required"`
	// General type or strategy of the portfolio.
	Type param.Field[InvestmentPortfolioNewParamsType] `json:"type,required"`
	// If true, AI will automatically allocate initial investment based on risk
	// tolerance.
	AIAutoAllocate param.Field[interface{}] `json:"aiAutoAllocate"`
	// Optional: ID of a linked account to fund the initial investment.
	LinkedAccountID param.Field[interface{}] `json:"linkedAccountId"`
}

func (InvestmentPortfolioNewParams) MarshalJSON 

func (r InvestmentPortfolioNewParams) MarshalJSON() (data []byte, err error)

type InvestmentPortfolioNewParamsRiskTolerance 

type InvestmentPortfolioNewParamsRiskTolerance string

Desired risk tolerance for this portfolio. 

const (
	InvestmentPortfolioNewParamsRiskToleranceConservative   InvestmentPortfolioNewParamsRiskTolerance = "conservative"
	InvestmentPortfolioNewParamsRiskToleranceModerate       InvestmentPortfolioNewParamsRiskTolerance = "moderate"
	InvestmentPortfolioNewParamsRiskToleranceAggressive     InvestmentPortfolioNewParamsRiskTolerance = "aggressive"
	InvestmentPortfolioNewParamsRiskToleranceVeryAggressive InvestmentPortfolioNewParamsRiskTolerance = "very_aggressive"
)

func (InvestmentPortfolioNewParamsRiskTolerance) IsKnown 

func (r InvestmentPortfolioNewParamsRiskTolerance) IsKnown() bool

type InvestmentPortfolioNewParamsType 

type InvestmentPortfolioNewParamsType string

General type or strategy of the portfolio. 

const (
	InvestmentPortfolioNewParamsTypeEquities    InvestmentPortfolioNewParamsType = "equities"
	InvestmentPortfolioNewParamsTypeBonds       InvestmentPortfolioNewParamsType = "bonds"
	InvestmentPortfolioNewParamsTypeDiversified InvestmentPortfolioNewParamsType = "diversified"
	InvestmentPortfolioNewParamsTypeCrypto      InvestmentPortfolioNewParamsType = "crypto"
	InvestmentPortfolioNewParamsTypeRetirement  InvestmentPortfolioNewParamsType = "retirement"
	InvestmentPortfolioNewParamsTypeOther       InvestmentPortfolioNewParamsType = "other"
)

func (InvestmentPortfolioNewParamsType) IsKnown 

func (r InvestmentPortfolioNewParamsType) IsKnown() bool

type InvestmentPortfolioRebalanceParams 

type InvestmentPortfolioRebalanceParams struct {
	// The desired risk tolerance for rebalancing the portfolio.
	TargetRiskTolerance param.Field[InvestmentPortfolioRebalanceParamsTargetRiskTolerance] `json:"targetRiskTolerance,required"`
	// If true, user confirmation is required before executing actual trades after a
	// dry run.
	ConfirmationRequired param.Field[interface{}] `json:"confirmationRequired"`
	// If true, only simulate the rebalance without executing trades. Returns proposed
	// trades.
	DryRun param.Field[interface{}] `json:"dryRun"`
}

func (InvestmentPortfolioRebalanceParams) MarshalJSON 

func (r InvestmentPortfolioRebalanceParams) MarshalJSON() (data []byte, err error)

type InvestmentPortfolioRebalanceParamsTargetRiskTolerance 

type InvestmentPortfolioRebalanceParamsTargetRiskTolerance string

The desired risk tolerance for rebalancing the portfolio. 

const (
	InvestmentPortfolioRebalanceParamsTargetRiskToleranceConservative   InvestmentPortfolioRebalanceParamsTargetRiskTolerance = "conservative"
	InvestmentPortfolioRebalanceParamsTargetRiskToleranceModerate       InvestmentPortfolioRebalanceParamsTargetRiskTolerance = "moderate"
	InvestmentPortfolioRebalanceParamsTargetRiskToleranceAggressive     InvestmentPortfolioRebalanceParamsTargetRiskTolerance = "aggressive"
	InvestmentPortfolioRebalanceParamsTargetRiskToleranceVeryAggressive InvestmentPortfolioRebalanceParamsTargetRiskTolerance = "very_aggressive"
)

func (InvestmentPortfolioRebalanceParamsTargetRiskTolerance) IsKnown 

func (r InvestmentPortfolioRebalanceParamsTargetRiskTolerance) IsKnown() bool

type InvestmentPortfolioRebalanceResponse 

type InvestmentPortfolioRebalanceResponse struct {
	// ID of the portfolio being rebalanced.
	PortfolioID interface{} `json:"portfolioId,required"`
	// Unique identifier for the rebalancing operation.
	RebalanceID interface{} `json:"rebalanceId,required"`
	// Current status of the rebalancing operation.
	Status InvestmentPortfolioRebalanceResponseStatus `json:"status,required"`
	// A descriptive message about the current rebalance status.
	StatusMessage interface{} `json:"statusMessage,required"`
	// Timestamp when the rebalance confirmation expires, if `confirmationRequired` is
	// true.
	ConfirmationExpiresAt interface{} `json:"confirmationExpiresAt"`
	// Indicates if user confirmation is required to proceed with trades.
	ConfirmationRequired interface{} `json:"confirmationRequired"`
	// AI-estimated impact of the rebalance on the portfolio.
	EstimatedImpact interface{} `json:"estimatedImpact"`
	// List of proposed trades if `dryRun` was true and status is
	// `pending_confirmation`.
	ProposedTrades []InvestmentPortfolioRebalanceResponseProposedTrade `json:"proposedTrades,nullable"`
	JSON           investmentPortfolioRebalanceResponseJSON            `json:"-"`
}

func (*InvestmentPortfolioRebalanceResponse) UnmarshalJSON 

func (r *InvestmentPortfolioRebalanceResponse) UnmarshalJSON(data []byte) (err error)

type InvestmentPortfolioRebalanceResponseProposedTrade 

type InvestmentPortfolioRebalanceResponseProposedTrade struct {
	Action         InvestmentPortfolioRebalanceResponseProposedTradesAction `json:"action"`
	EstimatedPrice interface{}                                              `json:"estimatedPrice"`
	Quantity       interface{}                                              `json:"quantity"`
	Symbol         interface{}                                              `json:"symbol"`
	JSON           investmentPortfolioRebalanceResponseProposedTradeJSON    `json:"-"`
}

func (*InvestmentPortfolioRebalanceResponseProposedTrade) UnmarshalJSON 

func (r *InvestmentPortfolioRebalanceResponseProposedTrade) UnmarshalJSON(data []byte) (err error)

type InvestmentPortfolioRebalanceResponseProposedTradesAction 

type InvestmentPortfolioRebalanceResponseProposedTradesAction string
const (
	InvestmentPortfolioRebalanceResponseProposedTradesActionBuy  InvestmentPortfolioRebalanceResponseProposedTradesAction = "buy"
	InvestmentPortfolioRebalanceResponseProposedTradesActionSell InvestmentPortfolioRebalanceResponseProposedTradesAction = "sell"
)

func (InvestmentPortfolioRebalanceResponseProposedTradesAction) IsKnown 

func (r InvestmentPortfolioRebalanceResponseProposedTradesAction) IsKnown() bool

type InvestmentPortfolioRebalanceResponseStatus 

type InvestmentPortfolioRebalanceResponseStatus string

Current status of the rebalancing operation. 

const (
	InvestmentPortfolioRebalanceResponseStatusAnalyzing           InvestmentPortfolioRebalanceResponseStatus = "analyzing"
	InvestmentPortfolioRebalanceResponseStatusPendingConfirmation InvestmentPortfolioRebalanceResponseStatus = "pending_confirmation"
	InvestmentPortfolioRebalanceResponseStatusExecutingTrades     InvestmentPortfolioRebalanceResponseStatus = "executing_trades"
	InvestmentPortfolioRebalanceResponseStatusCompleted           InvestmentPortfolioRebalanceResponseStatus = "completed"
	InvestmentPortfolioRebalanceResponseStatusFailed              InvestmentPortfolioRebalanceResponseStatus = "failed"
)

func (InvestmentPortfolioRebalanceResponseStatus) IsKnown 

func (r InvestmentPortfolioRebalanceResponseStatus) IsKnown() bool

type InvestmentPortfolioRiskTolerance 

type InvestmentPortfolioRiskTolerance string

User's stated or AI-assessed risk tolerance for this portfolio. 

const (
	InvestmentPortfolioRiskToleranceConservative   InvestmentPortfolioRiskTolerance = "conservative"
	InvestmentPortfolioRiskToleranceModerate       InvestmentPortfolioRiskTolerance = "moderate"
	InvestmentPortfolioRiskToleranceAggressive     InvestmentPortfolioRiskTolerance = "aggressive"
	InvestmentPortfolioRiskToleranceVeryAggressive InvestmentPortfolioRiskTolerance = "very_aggressive"
)

func (InvestmentPortfolioRiskTolerance) IsKnown 

func (r InvestmentPortfolioRiskTolerance) IsKnown() bool

type InvestmentPortfolioService 

type InvestmentPortfolioService struct {
	Options []option.RequestOption
}

InvestmentPortfolioService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewInvestmentPortfolioService method instead.

func NewInvestmentPortfolioService 

func NewInvestmentPortfolioService(opts ...option.RequestOption) (r *InvestmentPortfolioService)

NewInvestmentPortfolioService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*InvestmentPortfolioService) Get 

func (r *InvestmentPortfolioService) Get(ctx context.Context, portfolioID interface{}, opts ...option.RequestOption) (res *InvestmentPortfolio, err error)

Retrieves detailed information for a specific investment portfolio, including holdings, performance, and AI insights.

func (*InvestmentPortfolioService) List 

func (r *InvestmentPortfolioService) List(ctx context.Context, query InvestmentPortfolioListParams, opts ...option.RequestOption) (res *InvestmentPortfolioListResponse, err error)

Retrieves a summary of all investment portfolios linked to the user's account.

func (*InvestmentPortfolioService) New 

func (r *InvestmentPortfolioService) New(ctx context.Context, body InvestmentPortfolioNewParams, opts ...option.RequestOption) (res *InvestmentPortfolio, err error)

Creates a new investment portfolio, with options for initial asset allocation.

func (*InvestmentPortfolioService) Rebalance 

func (r *InvestmentPortfolioService) Rebalance(ctx context.Context, portfolioID interface{}, body InvestmentPortfolioRebalanceParams, opts ...option.RequestOption) (res *InvestmentPortfolioRebalanceResponse, err error)

Triggers an AI-driven rebalancing process for a specific investment portfolio based on a target risk tolerance or strategy.

func (*InvestmentPortfolioService) Update 

func (r *InvestmentPortfolioService) Update(ctx context.Context, portfolioID interface{}, body InvestmentPortfolioUpdateParams, opts ...option.RequestOption) (res *InvestmentPortfolio, err error)

Updates high-level details of an investment portfolio, such as name or risk tolerance.

type InvestmentPortfolioType 

type InvestmentPortfolioType string

General type or strategy of the portfolio. 

const (
	InvestmentPortfolioTypeEquities    InvestmentPortfolioType = "equities"
	InvestmentPortfolioTypeBonds       InvestmentPortfolioType = "bonds"
	InvestmentPortfolioTypeDiversified InvestmentPortfolioType = "diversified"
	InvestmentPortfolioTypeCrypto      InvestmentPortfolioType = "crypto"
	InvestmentPortfolioTypeRetirement  InvestmentPortfolioType = "retirement"
	InvestmentPortfolioTypeOther       InvestmentPortfolioType = "other"
)

func (InvestmentPortfolioType) IsKnown 

func (r InvestmentPortfolioType) IsKnown() bool

type InvestmentPortfolioUpdateParams 

type InvestmentPortfolioUpdateParams struct {
	// Updated frequency for AI-driven rebalancing.
	AIRebalancingFrequency param.Field[InvestmentPortfolioUpdateParamsAIRebalancingFrequency] `json:"aiRebalancingFrequency"`
	// Updated name of the portfolio.
	Name param.Field[interface{}] `json:"name"`
	// Updated risk tolerance for this portfolio. May trigger rebalancing.
	RiskTolerance param.Field[InvestmentPortfolioUpdateParamsRiskTolerance] `json:"riskTolerance"`
}

func (InvestmentPortfolioUpdateParams) MarshalJSON 

func (r InvestmentPortfolioUpdateParams) MarshalJSON() (data []byte, err error)

type InvestmentPortfolioUpdateParamsAIRebalancingFrequency 

type InvestmentPortfolioUpdateParamsAIRebalancingFrequency string

Updated frequency for AI-driven rebalancing. 

const (
	InvestmentPortfolioUpdateParamsAIRebalancingFrequencyMonthly      InvestmentPortfolioUpdateParamsAIRebalancingFrequency = "monthly"
	InvestmentPortfolioUpdateParamsAIRebalancingFrequencyQuarterly    InvestmentPortfolioUpdateParamsAIRebalancingFrequency = "quarterly"
	InvestmentPortfolioUpdateParamsAIRebalancingFrequencySemiAnnually InvestmentPortfolioUpdateParamsAIRebalancingFrequency = "semi_annually"
	InvestmentPortfolioUpdateParamsAIRebalancingFrequencyAnnually     InvestmentPortfolioUpdateParamsAIRebalancingFrequency = "annually"
	InvestmentPortfolioUpdateParamsAIRebalancingFrequencyNever        InvestmentPortfolioUpdateParamsAIRebalancingFrequency = "never"
)

func (InvestmentPortfolioUpdateParamsAIRebalancingFrequency) IsKnown 

func (r InvestmentPortfolioUpdateParamsAIRebalancingFrequency) IsKnown() bool

type InvestmentPortfolioUpdateParamsRiskTolerance 

type InvestmentPortfolioUpdateParamsRiskTolerance string

Updated risk tolerance for this portfolio. May trigger rebalancing. 

const (
	InvestmentPortfolioUpdateParamsRiskToleranceConservative   InvestmentPortfolioUpdateParamsRiskTolerance = "conservative"
	InvestmentPortfolioUpdateParamsRiskToleranceModerate       InvestmentPortfolioUpdateParamsRiskTolerance = "moderate"
	InvestmentPortfolioUpdateParamsRiskToleranceAggressive     InvestmentPortfolioUpdateParamsRiskTolerance = "aggressive"
	InvestmentPortfolioUpdateParamsRiskToleranceVeryAggressive InvestmentPortfolioUpdateParamsRiskTolerance = "very_aggressive"
)

func (InvestmentPortfolioUpdateParamsRiskTolerance) IsKnown 

func (r InvestmentPortfolioUpdateParamsRiskTolerance) IsKnown() bool

type InvestmentService 

type InvestmentService struct {
	Options    []option.RequestOption
	Portfolios *InvestmentPortfolioService
	Assets     *InvestmentAssetService
}

InvestmentService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewInvestmentService method instead.

func NewInvestmentService 

func NewInvestmentService(opts ...option.RequestOption) (r *InvestmentService)

NewInvestmentService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type KYCStatus 

type KYCStatus struct {
	// Timestamp of the last KYC document submission.
	LastSubmissionDate interface{} `json:"lastSubmissionDate,required"`
	// Overall status of the KYC verification process.
	OverallStatus KYCStatusOverallStatus `json:"overallStatus,required"`
	// List of actions required from the user if status is 'requires_more_info'.
	RequiredActions []interface{} `json:"requiredActions,required"`
	// The ID of the user whose KYC status is being retrieved.
	UserID interface{} `json:"userId,required"`
	// Reason for rejection if status is 'rejected'.
	RejectionReason interface{} `json:"rejectionReason"`
	// The KYC verification tier achieved (e.g., for different service levels).
	VerifiedTier KYCStatusVerifiedTier `json:"verifiedTier,nullable"`
	JSON         kycStatusJSON         `json:"-"`
}

func (*KYCStatus) UnmarshalJSON 

func (r *KYCStatus) UnmarshalJSON(data []byte) (err error)

type KYCStatusOverallStatus 

type KYCStatusOverallStatus string

Overall status of the KYC verification process. 

const (
	KYCStatusOverallStatusNotSubmitted     KYCStatusOverallStatus = "not_submitted"
	KYCStatusOverallStatusInReview         KYCStatusOverallStatus = "in_review"
	KYCStatusOverallStatusVerified         KYCStatusOverallStatus = "verified"
	KYCStatusOverallStatusRejected         KYCStatusOverallStatus = "rejected"
	KYCStatusOverallStatusRequiresMoreInfo KYCStatusOverallStatus = "requires_more_info"
)

func (KYCStatusOverallStatus) IsKnown 

func (r KYCStatusOverallStatus) IsKnown() bool

type KYCStatusVerifiedTier 

type KYCStatusVerifiedTier string

The KYC verification tier achieved (e.g., for different service levels). 

const (
	KYCStatusVerifiedTierBronze   KYCStatusVerifiedTier = "bronze"
	KYCStatusVerifiedTierSilver   KYCStatusVerifiedTier = "silver"
	KYCStatusVerifiedTierGold     KYCStatusVerifiedTier = "gold"
	KYCStatusVerifiedTierPlatinum KYCStatusVerifiedTier = "platinum"
)

func (KYCStatusVerifiedTier) IsKnown 

func (r KYCStatusVerifiedTier) IsKnown() bool

type LendingApplicationService 

type LendingApplicationService struct {
	Options []option.RequestOption
}

LendingApplicationService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewLendingApplicationService method instead.

func NewLendingApplicationService 

func NewLendingApplicationService(opts ...option.RequestOption) (r *LendingApplicationService)

NewLendingApplicationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*LendingApplicationService) Get 

func (r *LendingApplicationService) Get(ctx context.Context, applicationID interface{}, opts ...option.RequestOption) (res *LoanApplicationStatus, err error)

Retrieves the current status and detailed information for a submitted loan application, including AI underwriting outcomes, approved terms, and next steps.

func (*LendingApplicationService) Submit 

func (r *LendingApplicationService) Submit(ctx context.Context, body LendingApplicationSubmitParams, opts ...option.RequestOption) (res *LoanApplicationStatus, err error)

Submits a new loan application, which is instantly processed and underwritten by our Quantum AI, providing rapid decisions and personalized loan offers based on real-time financial health data.

type LendingApplicationSubmitParams 

type LendingApplicationSubmitParams struct {
	// The desired loan amount.
	LoanAmount param.Field[interface{}] `json:"loanAmount,required"`
	// The purpose of the loan.
	LoanPurpose param.Field[LendingApplicationSubmitParamsLoanPurpose] `json:"loanPurpose,required"`
	// The desired repayment term in months.
	RepaymentTermMonths param.Field[interface{}] `json:"repaymentTermMonths,required"`
	// Optional notes or details for the application.
	AdditionalNotes param.Field[interface{}] `json:"additionalNotes"`
	// Optional: Details of a co-applicant for the loan.
	CoApplicant param.Field[LendingApplicationSubmitParamsCoApplicant] `json:"coApplicant"`
}

func (LendingApplicationSubmitParams) MarshalJSON 

func (r LendingApplicationSubmitParams) MarshalJSON() (data []byte, err error)

type LendingApplicationSubmitParamsCoApplicant 

type LendingApplicationSubmitParamsCoApplicant struct {
	Email  param.Field[interface{}] `json:"email"`
	Income param.Field[interface{}] `json:"income"`
	Name   param.Field[interface{}] `json:"name"`
}

Optional: Details of a co-applicant for the loan.

func (LendingApplicationSubmitParamsCoApplicant) MarshalJSON 

func (r LendingApplicationSubmitParamsCoApplicant) MarshalJSON() (data []byte, err error)

type LendingApplicationSubmitParamsLoanPurpose 

type LendingApplicationSubmitParamsLoanPurpose string

The purpose of the loan. 

const (
	LendingApplicationSubmitParamsLoanPurposeHomeImprovement   LendingApplicationSubmitParamsLoanPurpose = "home_improvement"
	LendingApplicationSubmitParamsLoanPurposeDebtConsolidation LendingApplicationSubmitParamsLoanPurpose = "debt_consolidation"
	LendingApplicationSubmitParamsLoanPurposeMedicalExpense    LendingApplicationSubmitParamsLoanPurpose = "medical_expense"
	LendingApplicationSubmitParamsLoanPurposeEducation         LendingApplicationSubmitParamsLoanPurpose = "education"
	LendingApplicationSubmitParamsLoanPurposeAutoPurchase      LendingApplicationSubmitParamsLoanPurpose = "auto_purchase"
	LendingApplicationSubmitParamsLoanPurposeOther             LendingApplicationSubmitParamsLoanPurpose = "other"
)

func (LendingApplicationSubmitParamsLoanPurpose) IsKnown 

func (r LendingApplicationSubmitParamsLoanPurpose) IsKnown() bool

type LendingOfferListPreApprovedParams 

type LendingOfferListPreApprovedParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (LendingOfferListPreApprovedParams) URLQuery 

func (r LendingOfferListPreApprovedParams) URLQuery() (v url.Values)

URLQuery serializes LendingOfferListPreApprovedParams's query parameters as `url.Values`.

type LendingOfferListPreApprovedResponse 

type LendingOfferListPreApprovedResponse struct {
	Data []LoanOffer                             `json:"data"`
	JSON lendingOfferListPreApprovedResponseJSON `json:"-"`
	PaginatedList
}

func (*LendingOfferListPreApprovedResponse) UnmarshalJSON 

func (r *LendingOfferListPreApprovedResponse) UnmarshalJSON(data []byte) (err error)

type LendingOfferService 

type LendingOfferService struct {
	Options []option.RequestOption
}

LendingOfferService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewLendingOfferService method instead.

func NewLendingOfferService 

func NewLendingOfferService(opts ...option.RequestOption) (r *LendingOfferService)

NewLendingOfferService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*LendingOfferService) ListPreApproved 

func (r *LendingOfferService) ListPreApproved(ctx context.Context, query LendingOfferListPreApprovedParams, opts ...option.RequestOption) (res *LendingOfferListPreApprovedResponse, err error)

Retrieves a list of personalized, pre-approved loan offers generated by the AI based on the user's financial profile and credit health.

type LendingService 

type LendingService struct {
	Options      []option.RequestOption
	Applications *LendingApplicationService
	Offers       *LendingOfferService
}

LendingService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewLendingService method instead.

func NewLendingService 

func NewLendingService(opts ...option.RequestOption) (r *LendingService)

NewLendingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type LinkedAccount 

type LinkedAccount struct {
	// Unique identifier for the linked account within .
	ID interface{} `json:"id,required"`
	// ISO 4217 currency code of the account.
	Currency interface{} `json:"currency,required"`
	// Current balance of the account.
	CurrentBalance interface{} `json:"currentBalance,required"`
	// Name of the financial institution where the account is held.
	InstitutionName interface{} `json:"institutionName,required"`
	// Timestamp when the account balance was last synced.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Display name of the account.
	Name interface{} `json:"name,required"`
	// General type of the account.
	Type LinkedAccountType `json:"type,required"`
	// Available balance (after pending transactions) of the account.
	AvailableBalance interface{} `json:"availableBalance"`
	// Optional: Identifier from the external data provider (e.g., Plaid).
	ExternalID interface{} `json:"externalId"`
	// Masked account number (e.g., last 4 digits).
	Mask interface{} `json:"mask"`
	// Specific subtype of the account (e.g., checking, savings, IRA, 401k).
	Subtype interface{}       `json:"subtype"`
	JSON    linkedAccountJSON `json:"-"`
}

Summary information for a linked financial account.

func (*LinkedAccount) UnmarshalJSON 

func (r *LinkedAccount) UnmarshalJSON(data []byte) (err error)

type LinkedAccountType 

type LinkedAccountType string

General type of the account. 

const (
	LinkedAccountTypeDepository LinkedAccountType = "depository"
	LinkedAccountTypeCredit     LinkedAccountType = "credit"
	LinkedAccountTypeLoan       LinkedAccountType = "loan"
	LinkedAccountTypeInvestment LinkedAccountType = "investment"
	LinkedAccountTypeOther      LinkedAccountType = "other"
)

func (LinkedAccountType) IsKnown 

func (r LinkedAccountType) IsKnown() bool

type LoanApplicationStatus 

type LoanApplicationStatus struct {
	// Timestamp when the application was submitted.
	ApplicationDate interface{} `json:"applicationDate,required"`
	// Unique identifier for the loan application.
	ApplicationID interface{} `json:"applicationId,required"`
	// The amount originally requested in the application.
	LoanAmountRequested interface{} `json:"loanAmountRequested,required"`
	// The purpose of the loan.
	LoanPurpose LoanApplicationStatusLoanPurpose `json:"loanPurpose,required"`
	// Guidance on the next actions for the user.
	NextSteps interface{} `json:"nextSteps,required"`
	// Current status of the loan application.
	Status               LoanApplicationStatusStatus               `json:"status,required"`
	AIUnderwritingResult LoanApplicationStatusAIUnderwritingResult `json:"aiUnderwritingResult"`
	OfferDetails         LoanOffer                                 `json:"offerDetails"`
	JSON                 loanApplicationStatusJSON                 `json:"-"`
}

func (*LoanApplicationStatus) UnmarshalJSON 

func (r *LoanApplicationStatus) UnmarshalJSON(data []byte) (err error)

type LoanApplicationStatusAIUnderwritingResult 

type LoanApplicationStatusAIUnderwritingResult struct {
	// AI's confidence in its underwriting decision (0-1).
	AIConfidence interface{} `json:"aiConfidence,required"`
	// The AI's underwriting decision.
	Decision LoanApplicationStatusAIUnderwritingResultDecision `json:"decision,required"`
	// Reasoning for the AI's decision.
	Reason interface{} `json:"reason,required"`
	// The maximum amount the AI is willing to approve.
	MaxApprovedAmount interface{} `json:"maxApprovedAmount"`
	// The interest rate recommended by the AI.
	RecommendedInterestRate interface{}                                   `json:"recommendedInterestRate"`
	JSON                    loanApplicationStatusAIUnderwritingResultJSON `json:"-"`
}

func (*LoanApplicationStatusAIUnderwritingResult) UnmarshalJSON 

func (r *LoanApplicationStatusAIUnderwritingResult) UnmarshalJSON(data []byte) (err error)

type LoanApplicationStatusAIUnderwritingResultDecision 

type LoanApplicationStatusAIUnderwritingResultDecision string

The AI's underwriting decision. 

const (
	LoanApplicationStatusAIUnderwritingResultDecisionApproved        LoanApplicationStatusAIUnderwritingResultDecision = "approved"
	LoanApplicationStatusAIUnderwritingResultDecisionDeclined        LoanApplicationStatusAIUnderwritingResultDecision = "declined"
	LoanApplicationStatusAIUnderwritingResultDecisionReferredToHuman LoanApplicationStatusAIUnderwritingResultDecision = "referred_to_human"
)

func (LoanApplicationStatusAIUnderwritingResultDecision) IsKnown 

func (r LoanApplicationStatusAIUnderwritingResultDecision) IsKnown() bool

type LoanApplicationStatusLoanPurpose 

type LoanApplicationStatusLoanPurpose string

The purpose of the loan. 

const (
	LoanApplicationStatusLoanPurposeHomeImprovement   LoanApplicationStatusLoanPurpose = "home_improvement"
	LoanApplicationStatusLoanPurposeDebtConsolidation LoanApplicationStatusLoanPurpose = "debt_consolidation"
	LoanApplicationStatusLoanPurposeMedicalExpense    LoanApplicationStatusLoanPurpose = "medical_expense"
	LoanApplicationStatusLoanPurposeEducation         LoanApplicationStatusLoanPurpose = "education"
	LoanApplicationStatusLoanPurposeAutoPurchase      LoanApplicationStatusLoanPurpose = "auto_purchase"
	LoanApplicationStatusLoanPurposeOther             LoanApplicationStatusLoanPurpose = "other"
)

func (LoanApplicationStatusLoanPurpose) IsKnown 

func (r LoanApplicationStatusLoanPurpose) IsKnown() bool

type LoanApplicationStatusStatus 

type LoanApplicationStatusStatus string

Current status of the loan application. 

const (
	LoanApplicationStatusStatusSubmitted         LoanApplicationStatusStatus = "submitted"
	LoanApplicationStatusStatusUnderwriting      LoanApplicationStatusStatus = "underwriting"
	LoanApplicationStatusStatusApproved          LoanApplicationStatusStatus = "approved"
	LoanApplicationStatusStatusDeclined          LoanApplicationStatusStatus = "declined"
	LoanApplicationStatusStatusPendingAcceptance LoanApplicationStatusStatus = "pending_acceptance"
	LoanApplicationStatusStatusFunded            LoanApplicationStatusStatus = "funded"
	LoanApplicationStatusStatusCancelled         LoanApplicationStatusStatus = "cancelled"
)

func (LoanApplicationStatusStatus) IsKnown 

func (r LoanApplicationStatusStatus) IsKnown() bool

type LoanOffer 

type LoanOffer struct {
	// The offered loan amount.
	Amount interface{} `json:"amount,required"`
	// Date the offer expires.
	ExpirationDate interface{} `json:"expirationDate,required"`
	// Annual interest rate offered (as a percentage).
	InterestRate interface{} `json:"interestRate,required"`
	// Indicates if this is a pre-approved offer.
	IsPreApproved interface{} `json:"isPreApproved,required"`
	// Unique identifier for the loan offer.
	OfferID interface{} `json:"offerId,required"`
	// Type of loan being offered.
	OfferType LoanOfferOfferType `json:"offerType,required"`
	// AI's score for how well this offer is personalized to the user (0-1).
	AIPersonalizationScore interface{} `json:"aiPersonalizationScore"`
	// Estimated monthly payment (if applicable).
	MonthlyPayment interface{} `json:"monthlyPayment"`
	// Any origination fees for the loan.
	OriginationFee interface{} `json:"originationFee"`
	// Repayment term in months (if applicable).
	RepaymentTermMonths interface{} `json:"repaymentTermMonths"`
	// URL to the full terms and conditions of the loan offer.
	TermsAndConditionsURL interface{} `json:"termsAndConditionsUrl"`
	// Total amount repayable over the loan term.
	TotalRepayable interface{}   `json:"totalRepayable"`
	JSON           loanOfferJSON `json:"-"`
}

func (*LoanOffer) UnmarshalJSON 

func (r *LoanOffer) UnmarshalJSON(data []byte) (err error)

type LoanOfferOfferType 

type LoanOfferOfferType string

Type of loan being offered. 

const (
	LoanOfferOfferTypePersonalLoan LoanOfferOfferType = "personal_loan"
	LoanOfferOfferTypeAutoLoan     LoanOfferOfferType = "auto_loan"
	LoanOfferOfferTypeMortgage     LoanOfferOfferType = "mortgage"
	LoanOfferOfferTypeCreditLine   LoanOfferOfferType = "credit_line"
	LoanOfferOfferTypeMicroloan    LoanOfferOfferType = "microloan"
)

func (LoanOfferOfferType) IsKnown 

func (r LoanOfferOfferType) IsKnown() bool

type MarketplaceOfferRedeemParams 

type MarketplaceOfferRedeemParams struct {
	// Optional: The ID of the account to use for any associated payment or credit.
	PaymentAccountID param.Field[interface{}] `json:"paymentAccountId"`
}

func (MarketplaceOfferRedeemParams) MarshalJSON 

func (r MarketplaceOfferRedeemParams) MarshalJSON() (data []byte, err error)

type MarketplaceOfferRedeemResponse 

type MarketplaceOfferRedeemResponse struct {
	// If applicable, the ID of any associated transaction (e.g., a credit or initial
	// payment).
	AssociatedTransactionID interface{} `json:"associatedTransactionId"`
	// A descriptive message about the redemption.
	Message interface{} `json:"message"`
	// The ID of the redeemed offer.
	OfferID        interface{} `json:"offerId"`
	RedemptionDate interface{} `json:"redemptionDate"`
	// Unique ID for this redemption.
	RedemptionID interface{} `json:"redemptionId"`
	// Status of the redemption.
	Status MarketplaceOfferRedeemResponseStatus `json:"status"`
	JSON   marketplaceOfferRedeemResponseJSON   `json:"-"`
}

func (*MarketplaceOfferRedeemResponse) UnmarshalJSON 

func (r *MarketplaceOfferRedeemResponse) UnmarshalJSON(data []byte) (err error)

type MarketplaceOfferRedeemResponseStatus 

type MarketplaceOfferRedeemResponseStatus string

Status of the redemption. 

const (
	MarketplaceOfferRedeemResponseStatusSuccess MarketplaceOfferRedeemResponseStatus = "success"
	MarketplaceOfferRedeemResponseStatusPending MarketplaceOfferRedeemResponseStatus = "pending"
	MarketplaceOfferRedeemResponseStatusFailed  MarketplaceOfferRedeemResponseStatus = "failed"
)

func (MarketplaceOfferRedeemResponseStatus) IsKnown 

func (r MarketplaceOfferRedeemResponseStatus) IsKnown() bool

type MarketplaceOfferService 

type MarketplaceOfferService struct {
	Options []option.RequestOption
}

MarketplaceOfferService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewMarketplaceOfferService method instead.

func NewMarketplaceOfferService 

func NewMarketplaceOfferService(opts ...option.RequestOption) (r *MarketplaceOfferService)

NewMarketplaceOfferService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*MarketplaceOfferService) Redeem 

func (r *MarketplaceOfferService) Redeem(ctx context.Context, offerID interface{}, body MarketplaceOfferRedeemParams, opts ...option.RequestOption) (res *MarketplaceOfferRedeemResponse, err error)

Redeems a personalized, exclusive offer from the Plato AI marketplace, often resulting in a discount, special rate, or credit to the user's account.

type MarketplaceProductListParams 

type MarketplaceProductListParams struct {
	// Filter by AI personalization level (e.g., low, medium, high). 'High' means
	// highly relevant to user's specific needs.
	AIPersonalizationLevel param.Field[MarketplaceProductListParamsAIPersonalizationLevel] `query:"aiPersonalizationLevel"`
	// Filter products by category (e.g., loans, insurance, credit_cards, investments).
	Category param.Field[MarketplaceProductListParamsCategory] `query:"category"`
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Minimum user rating for products (0-5).
	MinRating param.Field[interface{}] `query:"minRating"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (MarketplaceProductListParams) URLQuery 

func (r MarketplaceProductListParams) URLQuery() (v url.Values)

URLQuery serializes MarketplaceProductListParams's query parameters as `url.Values`.

type MarketplaceProductListParamsAIPersonalizationLevel 

type MarketplaceProductListParamsAIPersonalizationLevel string

Filter by AI personalization level (e.g., low, medium, high). 'High' means highly relevant to user's specific needs. 

const (
	MarketplaceProductListParamsAIPersonalizationLevelLow    MarketplaceProductListParamsAIPersonalizationLevel = "low"
	MarketplaceProductListParamsAIPersonalizationLevelMedium MarketplaceProductListParamsAIPersonalizationLevel = "medium"
	MarketplaceProductListParamsAIPersonalizationLevelHigh   MarketplaceProductListParamsAIPersonalizationLevel = "high"
)

func (MarketplaceProductListParamsAIPersonalizationLevel) IsKnown 

func (r MarketplaceProductListParamsAIPersonalizationLevel) IsKnown() bool

type MarketplaceProductListParamsCategory 

type MarketplaceProductListParamsCategory string

Filter products by category (e.g., loans, insurance, credit_cards, investments). 

const (
	MarketplaceProductListParamsCategoryLoans          MarketplaceProductListParamsCategory = "loans"
	MarketplaceProductListParamsCategoryInsurance      MarketplaceProductListParamsCategory = "insurance"
	MarketplaceProductListParamsCategoryCreditCards    MarketplaceProductListParamsCategory = "credit_cards"
	MarketplaceProductListParamsCategoryInvestments    MarketplaceProductListParamsCategory = "investments"
	MarketplaceProductListParamsCategoryBudgetingTools MarketplaceProductListParamsCategory = "budgeting_tools"
	MarketplaceProductListParamsCategorySmartHome      MarketplaceProductListParamsCategory = "smart_home"
	MarketplaceProductListParamsCategoryTravel         MarketplaceProductListParamsCategory = "travel"
	MarketplaceProductListParamsCategoryEducation      MarketplaceProductListParamsCategory = "education"
)

func (MarketplaceProductListParamsCategory) IsKnown 

func (r MarketplaceProductListParamsCategory) IsKnown() bool

type MarketplaceProductListResponse 

type MarketplaceProductListResponse struct {
	Data []MarketplaceProductListResponseData `json:"data"`
	JSON marketplaceProductListResponseJSON   `json:"-"`
	PaginatedList
}

func (*MarketplaceProductListResponse) UnmarshalJSON 

func (r *MarketplaceProductListResponse) UnmarshalJSON(data []byte) (err error)

type MarketplaceProductListResponseData 

type MarketplaceProductListResponseData struct {
	// Unique identifier for the marketplace product.
	ID interface{} `json:"id,required"`
	// AI's score for how well this product is personalized to the user (0-1).
	AIPersonalizationScore interface{} `json:"aiPersonalizationScore,required"`
	// Category of the product/service.
	Category MarketplaceProductListResponseDataCategory `json:"category,required"`
	// Detailed description of the product/service.
	Description interface{} `json:"description,required"`
	// URL to an image representing the product.
	ImageURL interface{} `json:"imageUrl,required"`
	// Name of the product/service.
	Name interface{} `json:"name,required"`
	// Pricing information (can be a range or fixed text).
	Price interface{} `json:"price,required"`
	// Provider or vendor of the product/service.
	Provider interface{} `json:"provider,required"`
	// Average user rating for the product (0-5).
	Rating interface{} `json:"rating,required"`
	// AI-generated explanation for recommending this product.
	AIRecommendationReason interface{} `json:"aiRecommendationReason"`
	// Details of any special offers associated with the product.
	OfferDetails MarketplaceProductListResponseDataOfferDetails `json:"offerDetails"`
	// Direct URL to the product on the provider's website.
	ProductURL interface{}                            `json:"productUrl"`
	JSON       marketplaceProductListResponseDataJSON `json:"-"`
}

func (*MarketplaceProductListResponseData) UnmarshalJSON 

func (r *MarketplaceProductListResponseData) UnmarshalJSON(data []byte) (err error)

type MarketplaceProductListResponseDataCategory 

type MarketplaceProductListResponseDataCategory string

Category of the product/service. 

const (
	MarketplaceProductListResponseDataCategoryLoans          MarketplaceProductListResponseDataCategory = "loans"
	MarketplaceProductListResponseDataCategoryInsurance      MarketplaceProductListResponseDataCategory = "insurance"
	MarketplaceProductListResponseDataCategoryCreditCards    MarketplaceProductListResponseDataCategory = "credit_cards"
	MarketplaceProductListResponseDataCategoryInvestments    MarketplaceProductListResponseDataCategory = "investments"
	MarketplaceProductListResponseDataCategoryBudgetingTools MarketplaceProductListResponseDataCategory = "budgeting_tools"
	MarketplaceProductListResponseDataCategorySmartHome      MarketplaceProductListResponseDataCategory = "smart_home"
	MarketplaceProductListResponseDataCategoryTravel         MarketplaceProductListResponseDataCategory = "travel"
	MarketplaceProductListResponseDataCategoryEducation      MarketplaceProductListResponseDataCategory = "education"
	MarketplaceProductListResponseDataCategoryHealth         MarketplaceProductListResponseDataCategory = "health"
)

func (MarketplaceProductListResponseDataCategory) IsKnown 

func (r MarketplaceProductListResponseDataCategory) IsKnown() bool

type MarketplaceProductListResponseDataOfferDetails 

type MarketplaceProductListResponseDataOfferDetails struct {
	// Optional redemption code.
	Code  interface{}                                        `json:"code"`
	Type  MarketplaceProductListResponseDataOfferDetailsType `json:"type"`
	Value interface{}                                        `json:"value"`
	JSON  marketplaceProductListResponseDataOfferDetailsJSON `json:"-"`
}

Details of any special offers associated with the product.

func (*MarketplaceProductListResponseDataOfferDetails) UnmarshalJSON 

func (r *MarketplaceProductListResponseDataOfferDetails) UnmarshalJSON(data []byte) (err error)

type MarketplaceProductListResponseDataOfferDetailsType 

type MarketplaceProductListResponseDataOfferDetailsType string
const (
	MarketplaceProductListResponseDataOfferDetailsTypeDiscount    MarketplaceProductListResponseDataOfferDetailsType = "discount"
	MarketplaceProductListResponseDataOfferDetailsTypeSpecialRate MarketplaceProductListResponseDataOfferDetailsType = "special_rate"
	MarketplaceProductListResponseDataOfferDetailsTypeFreeTrial   MarketplaceProductListResponseDataOfferDetailsType = "free_trial"
)

func (MarketplaceProductListResponseDataOfferDetailsType) IsKnown 

func (r MarketplaceProductListResponseDataOfferDetailsType) IsKnown() bool

type MarketplaceProductService 

type MarketplaceProductService struct {
	Options []option.RequestOption
}

MarketplaceProductService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewMarketplaceProductService method instead.

func NewMarketplaceProductService 

func NewMarketplaceProductService(opts ...option.RequestOption) (r *MarketplaceProductService)

NewMarketplaceProductService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*MarketplaceProductService) List 

func (r *MarketplaceProductService) List(ctx context.Context, query MarketplaceProductListParams, opts ...option.RequestOption) (res *MarketplaceProductListResponse, err error)

Retrieves a personalized, AI-curated list of products and services from the Plato AI marketplace, tailored to the user's financial profile, goals, and spending patterns. Includes options for filtering and advanced search.

func (*MarketplaceProductService) SimulateImpact 

func (r *MarketplaceProductService) SimulateImpact(ctx context.Context, productID interface{}, body MarketplaceProductSimulateImpactParams, opts ...option.RequestOption) (res *MarketplaceProductSimulateImpactResponse, err error)

Uses the Quantum Oracle to simulate the long-term financial impact of purchasing or subscribing to a specific marketplace product, such as a loan, investment, or insurance policy, on the user's overall financial health and goals.

type MarketplaceProductSimulateImpactParams 

type MarketplaceProductSimulateImpactParams struct {
	// Dynamic parameters specific to the product type (e.g., loan amount, investment
	// term).
	SimulationParameters param.Field[interface{}] `json:"simulationParameters"`
}

func (MarketplaceProductSimulateImpactParams) MarshalJSON 

func (r MarketplaceProductSimulateImpactParams) MarshalJSON() (data []byte, err error)

type MarketplaceProductSimulateImpactResponse 

type MarketplaceProductSimulateImpactResponse struct {
	// Key financial impacts identified by the AI (e.g., on cash flow, debt-to-income).
	KeyImpacts []MarketplaceProductSimulateImpactResponseKeyImpact `json:"keyImpacts,required"`
	// A natural language summary of the simulation's results for this product.
	NarrativeSummary interface{} `json:"narrativeSummary,required"`
	// The ID of the marketplace product being simulated.
	ProductID interface{} `json:"productId,required"`
	// Unique identifier for the simulation performed.
	SimulationID interface{} `json:"simulationId,required"`
	// Actionable recommendations or advice related to the product and its impact.
	AIRecommendations []AIInsight `json:"aiRecommendations,nullable"`
	// Projected amortization schedule for loan products.
	ProjectedAmortizationSchedule []MarketplaceProductSimulateImpactResponseProjectedAmortizationSchedule `json:"projectedAmortizationSchedule,nullable"`
	JSON                          marketplaceProductSimulateImpactResponseJSON                            `json:"-"`
}

func (*MarketplaceProductSimulateImpactResponse) UnmarshalJSON 

func (r *MarketplaceProductSimulateImpactResponse) UnmarshalJSON(data []byte) (err error)

type MarketplaceProductSimulateImpactResponseKeyImpact 

type MarketplaceProductSimulateImpactResponseKeyImpact struct {
	Metric   interface{}                                                `json:"metric"`
	Severity MarketplaceProductSimulateImpactResponseKeyImpactsSeverity `json:"severity"`
	Value    interface{}                                                `json:"value"`
	JSON     marketplaceProductSimulateImpactResponseKeyImpactJSON      `json:"-"`
}

func (*MarketplaceProductSimulateImpactResponseKeyImpact) UnmarshalJSON 

func (r *MarketplaceProductSimulateImpactResponseKeyImpact) UnmarshalJSON(data []byte) (err error)

type MarketplaceProductSimulateImpactResponseKeyImpactsSeverity 

type MarketplaceProductSimulateImpactResponseKeyImpactsSeverity string
const (
	MarketplaceProductSimulateImpactResponseKeyImpactsSeverityLow    MarketplaceProductSimulateImpactResponseKeyImpactsSeverity = "low"
	MarketplaceProductSimulateImpactResponseKeyImpactsSeverityMedium MarketplaceProductSimulateImpactResponseKeyImpactsSeverity = "medium"
	MarketplaceProductSimulateImpactResponseKeyImpactsSeverityHigh   MarketplaceProductSimulateImpactResponseKeyImpactsSeverity = "high"
)

func (MarketplaceProductSimulateImpactResponseKeyImpactsSeverity) IsKnown 

func (r MarketplaceProductSimulateImpactResponseKeyImpactsSeverity) IsKnown() bool

type MarketplaceProductSimulateImpactResponseProjectedAmortizationSchedule 

type MarketplaceProductSimulateImpactResponseProjectedAmortizationSchedule struct {
	Interest         interface{}                                                               `json:"interest"`
	Month            interface{}                                                               `json:"month"`
	Payment          interface{}                                                               `json:"payment"`
	Principal        interface{}                                                               `json:"principal"`
	RemainingBalance interface{}                                                               `json:"remainingBalance"`
	JSON             marketplaceProductSimulateImpactResponseProjectedAmortizationScheduleJSON `json:"-"`
}

func (*MarketplaceProductSimulateImpactResponseProjectedAmortizationSchedule) UnmarshalJSON 

func (r *MarketplaceProductSimulateImpactResponseProjectedAmortizationSchedule) UnmarshalJSON(data []byte) (err error)

type MarketplaceService 

type MarketplaceService struct {
	Options  []option.RequestOption
	Products *MarketplaceProductService
	Offers   *MarketplaceOfferService
}

MarketplaceService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewMarketplaceService method instead.

func NewMarketplaceService 

func NewMarketplaceService(opts ...option.RequestOption) (r *MarketplaceService)

NewMarketplaceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type Notification 

type Notification struct {
	// Unique identifier for the notification.
	ID interface{} `json:"id,required"`
	// Full message content of the notification.
	Message interface{} `json:"message,required"`
	// Indicates if the user has read the notification.
	Read interface{} `json:"read,required"`
	// Severity of the notification (AI-assessed).
	Severity NotificationSeverity `json:"severity,required"`
	// Timestamp when the notification was generated.
	Timestamp interface{} `json:"timestamp,required"`
	// Concise title for the notification.
	Title interface{} `json:"title,required"`
	// Type of notification.
	Type NotificationType `json:"type,required"`
	// Optional deep link for the user to take action related to the notification.
	ActionableLink interface{} `json:"actionableLink"`
	// If applicable, the ID of the AIInsight that generated this notification.
	AIInsightID interface{}      `json:"aiInsightId"`
	JSON        notificationJSON `json:"-"`
}

func (*Notification) UnmarshalJSON 

func (r *Notification) UnmarshalJSON(data []byte) (err error)

type NotificationListUserNotificationsParams 

type NotificationListUserNotificationsParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Filter notifications by AI-assigned severity level.
	Severity param.Field[NotificationListUserNotificationsParamsSeverity] `query:"severity"`
	// Filter notifications by their read status.
	Status param.Field[NotificationListUserNotificationsParamsStatus] `query:"status"`
}

func (NotificationListUserNotificationsParams) URLQuery 

func (r NotificationListUserNotificationsParams) URLQuery() (v url.Values)

URLQuery serializes NotificationListUserNotificationsParams's query parameters as `url.Values`.

type NotificationListUserNotificationsParamsSeverity 

type NotificationListUserNotificationsParamsSeverity string

Filter notifications by AI-assigned severity level. 

const (
	NotificationListUserNotificationsParamsSeverityLow      NotificationListUserNotificationsParamsSeverity = "low"
	NotificationListUserNotificationsParamsSeverityMedium   NotificationListUserNotificationsParamsSeverity = "medium"
	NotificationListUserNotificationsParamsSeverityHigh     NotificationListUserNotificationsParamsSeverity = "high"
	NotificationListUserNotificationsParamsSeverityCritical NotificationListUserNotificationsParamsSeverity = "critical"
)

func (NotificationListUserNotificationsParamsSeverity) IsKnown 

func (r NotificationListUserNotificationsParamsSeverity) IsKnown() bool

type NotificationListUserNotificationsParamsStatus 

type NotificationListUserNotificationsParamsStatus string

Filter notifications by their read status. 

const (
	NotificationListUserNotificationsParamsStatusRead   NotificationListUserNotificationsParamsStatus = "read"
	NotificationListUserNotificationsParamsStatusUnread NotificationListUserNotificationsParamsStatus = "unread"
)

func (NotificationListUserNotificationsParamsStatus) IsKnown 

func (r NotificationListUserNotificationsParamsStatus) IsKnown() bool

type NotificationListUserNotificationsResponse 

type NotificationListUserNotificationsResponse struct {
	Data []Notification                                `json:"data"`
	JSON notificationListUserNotificationsResponseJSON `json:"-"`
	PaginatedList
}

func (*NotificationListUserNotificationsResponse) UnmarshalJSON 

func (r *NotificationListUserNotificationsResponse) UnmarshalJSON(data []byte) (err error)

type NotificationService 

type NotificationService struct {
	Options  []option.RequestOption
	Settings *NotificationSettingService
}

NotificationService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewNotificationService method instead.

func NewNotificationService 

func NewNotificationService(opts ...option.RequestOption) (r *NotificationService)

NewNotificationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*NotificationService) ListUserNotifications 

func (r *NotificationService) ListUserNotifications(ctx context.Context, query NotificationListUserNotificationsParams, opts ...option.RequestOption) (res *NotificationListUserNotificationsResponse, err error)

Retrieves a paginated list of personalized notifications and proactive AI alerts for the authenticated user, allowing filtering by status and severity.

func (*NotificationService) MarkAsRead 

func (r *NotificationService) MarkAsRead(ctx context.Context, notificationID interface{}, opts ...option.RequestOption) (res *Notification, err error)

Marks a specific user notification as read.

type NotificationSettingService 

type NotificationSettingService struct {
	Options []option.RequestOption
}

NotificationSettingService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewNotificationSettingService method instead.

func NewNotificationSettingService 

func NewNotificationSettingService(opts ...option.RequestOption) (r *NotificationSettingService)

NewNotificationSettingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*NotificationSettingService) Get 

func (r *NotificationSettingService) Get(ctx context.Context, opts ...option.RequestOption) (res *NotificationSettings, err error)

Retrieves the user's granular notification preferences across different channels (email, push, SMS, in-app) and event types.

func (*NotificationSettingService) Update 

func (r *NotificationSettingService) Update(ctx context.Context, body NotificationSettingUpdateParams, opts ...option.RequestOption) (res *NotificationSettings, err error)

Updates the user's notification preferences, allowing control over channels, event types, and quiet hours.

type NotificationSettingUpdateParams 

type NotificationSettingUpdateParams struct {
	// Updated preferences for notification delivery channels. Only provided fields are
	// updated.
	ChannelPreferences param.Field[NotificationSettingUpdateParamsChannelPreferences] `json:"channelPreferences"`
	// Updated preferences for different types of events. Only provided fields are
	// updated.
	EventPreferences param.Field[NotificationSettingUpdateParamsEventPreferences] `json:"eventPreferences"`
	// Updated settings for notification quiet hours. Only provided fields are updated.
	QuietHours param.Field[NotificationSettingUpdateParamsQuietHours] `json:"quietHours"`
}

func (NotificationSettingUpdateParams) MarshalJSON 

func (r NotificationSettingUpdateParams) MarshalJSON() (data []byte, err error)

type NotificationSettingUpdateParamsChannelPreferences 

type NotificationSettingUpdateParamsChannelPreferences struct {
	Email param.Field[interface{}] `json:"email"`
	InApp param.Field[interface{}] `json:"inApp"`
	Push  param.Field[interface{}] `json:"push"`
	SMS   param.Field[interface{}] `json:"sms"`
}

Updated preferences for notification delivery channels. Only provided fields are updated.

func (NotificationSettingUpdateParamsChannelPreferences) MarshalJSON 

func (r NotificationSettingUpdateParamsChannelPreferences) MarshalJSON() (data []byte, err error)

type NotificationSettingUpdateParamsEventPreferences 

type NotificationSettingUpdateParamsEventPreferences struct {
	AIInsights        param.Field[interface{}] `json:"aiInsights"`
	BudgetAlerts      param.Field[interface{}] `json:"budgetAlerts"`
	PromotionalOffers param.Field[interface{}] `json:"promotionalOffers"`
	SecurityAlerts    param.Field[interface{}] `json:"securityAlerts"`
	TransactionAlerts param.Field[interface{}] `json:"transactionAlerts"`
}

Updated preferences for different types of events. Only provided fields are updated.

func (NotificationSettingUpdateParamsEventPreferences) MarshalJSON 

func (r NotificationSettingUpdateParamsEventPreferences) MarshalJSON() (data []byte, err error)

type NotificationSettingUpdateParamsQuietHours 

type NotificationSettingUpdateParamsQuietHours struct {
	Enabled   param.Field[interface{}] `json:"enabled"`
	EndTime   param.Field[interface{}] `json:"endTime"`
	StartTime param.Field[interface{}] `json:"startTime"`
}

Updated settings for notification quiet hours. Only provided fields are updated.

func (NotificationSettingUpdateParamsQuietHours) MarshalJSON 

func (r NotificationSettingUpdateParamsQuietHours) MarshalJSON() (data []byte, err error)

type NotificationSettings 

type NotificationSettings struct {
	// Preferences for notification delivery channels.
	ChannelPreferences NotificationSettingsChannelPreferences `json:"channelPreferences,required"`
	// Preferences for different types of events.
	EventPreferences NotificationSettingsEventPreferences `json:"eventPreferences,required"`
	// Settings for notification quiet hours.
	QuietHours NotificationSettingsQuietHours `json:"quietHours,required"`
	JSON       notificationSettingsJSON       `json:"-"`
}

func (*NotificationSettings) UnmarshalJSON 

func (r *NotificationSettings) UnmarshalJSON(data []byte) (err error)

type NotificationSettingsChannelPreferences 

type NotificationSettingsChannelPreferences struct {
	// Receive notifications via email.
	Email interface{} `json:"email"`
	// Receive notifications within the application.
	InApp interface{} `json:"inApp"`
	// Receive notifications via push notifications.
	Push interface{} `json:"push"`
	// Receive notifications via SMS.
	SMS  interface{}                                `json:"sms"`
	JSON notificationSettingsChannelPreferencesJSON `json:"-"`
}

Preferences for notification delivery channels.

func (*NotificationSettingsChannelPreferences) UnmarshalJSON 

func (r *NotificationSettingsChannelPreferences) UnmarshalJSON(data []byte) (err error)

type NotificationSettingsEventPreferences 

type NotificationSettingsEventPreferences struct {
	// Receive proactive AI-driven financial insights.
	AIInsights interface{} `json:"aiInsights"`
	// Receive alerts for budget progress (e.g., nearing limit, over budget).
	BudgetAlerts interface{} `json:"budgetAlerts"`
	// Receive promotional offers and marketing communications.
	PromotionalOffers interface{} `json:"promotionalOffers"`
	// Receive critical security alerts (e.g., suspicious login).
	SecurityAlerts interface{} `json:"securityAlerts"`
	// Receive alerts for transactions (e.g., large spend, recurring charges).
	TransactionAlerts interface{}                              `json:"transactionAlerts"`
	JSON              notificationSettingsEventPreferencesJSON `json:"-"`
}

Preferences for different types of events.

func (*NotificationSettingsEventPreferences) UnmarshalJSON 

func (r *NotificationSettingsEventPreferences) UnmarshalJSON(data []byte) (err error)

type NotificationSettingsQuietHours 

type NotificationSettingsQuietHours struct {
	// If true, notifications are suppressed during specified quiet hours.
	Enabled interface{} `json:"enabled"`
	// End time for quiet hours (HH:MM format).
	EndTime interface{} `json:"endTime"`
	// Start time for quiet hours (HH:MM format).
	StartTime interface{}                        `json:"startTime"`
	JSON      notificationSettingsQuietHoursJSON `json:"-"`
}

Settings for notification quiet hours.

func (*NotificationSettingsQuietHours) UnmarshalJSON 

func (r *NotificationSettingsQuietHours) UnmarshalJSON(data []byte) (err error)

type NotificationSeverity 

type NotificationSeverity string

Severity of the notification (AI-assessed). 

const (
	NotificationSeverityLow      NotificationSeverity = "low"
	NotificationSeverityMedium   NotificationSeverity = "medium"
	NotificationSeverityHigh     NotificationSeverity = "high"
	NotificationSeverityCritical NotificationSeverity = "critical"
)

func (NotificationSeverity) IsKnown 

func (r NotificationSeverity) IsKnown() bool

type NotificationType 

type NotificationType string

Type of notification. 

const (
	NotificationTypeSecurity         NotificationType = "security"
	NotificationTypeFinancialInsight NotificationType = "financial_insight"
	NotificationTypeMarketing        NotificationType = "marketing"
	NotificationTypeSystemUpdate     NotificationType = "system_update"
	NotificationTypeTransaction      NotificationType = "transaction"
)

func (NotificationType) IsKnown 

func (r NotificationType) IsKnown() bool

type OverdraftSettings 

type OverdraftSettings struct {
	// The account ID these overdraft settings apply to.
	AccountID interface{} `json:"accountId,required"`
	// If true, overdraft protection is enabled.
	Enabled interface{} `json:"enabled,required"`
	// User's preference for how overdraft fees are handled or if transactions should
	// be declined.
	FeePreference OverdraftSettingsFeePreference `json:"feePreference,required"`
	// The ID of the linked savings account, if `linkToSavings` is true.
	LinkedSavingsAccountID interface{} `json:"linkedSavingsAccountId"`
	// If true, attempts to draw funds from a linked savings account.
	LinkToSavings interface{} `json:"linkToSavings"`
	// The maximum amount that can be covered by overdraft protection.
	ProtectionLimit interface{}           `json:"protectionLimit"`
	JSON            overdraftSettingsJSON `json:"-"`
}

func (*OverdraftSettings) UnmarshalJSON 

func (r *OverdraftSettings) UnmarshalJSON(data []byte) (err error)

type OverdraftSettingsFeePreference 

type OverdraftSettingsFeePreference string

User's preference for how overdraft fees are handled or if transactions should be declined. 

const (
	OverdraftSettingsFeePreferenceAlwaysPay          OverdraftSettingsFeePreference = "always_pay"
	OverdraftSettingsFeePreferenceDeclineIfOverLimit OverdraftSettingsFeePreference = "decline_if_over_limit"
	OverdraftSettingsFeePreferenceAskMeFirst         OverdraftSettingsFeePreference = "ask_me_first"
)

func (OverdraftSettingsFeePreference) IsKnown 

func (r OverdraftSettingsFeePreference) IsKnown() bool

type PaginatedList 

type PaginatedList struct {
	// The maximum number of items returned in the current page.
	Limit interface{} `json:"limit,required"`
	// The number of items skipped before the current page.
	Offset interface{} `json:"offset,required"`
	// The total number of items available across all pages.
	Total interface{} `json:"total,required"`
	// The offset for the next page of results, if available. Null if no more pages.
	NextOffset interface{}       `json:"nextOffset"`
	JSON       paginatedListJSON `json:"-"`
}

func (*PaginatedList) UnmarshalJSON 

func (r *PaginatedList) UnmarshalJSON(data []byte) (err error)

type PaginatedTransactions 

type PaginatedTransactions struct {
	Data []Transaction             `json:"data"`
	JSON paginatedTransactionsJSON `json:"-"`
	PaginatedList
}

func (*PaginatedTransactions) UnmarshalJSON 

func (r *PaginatedTransactions) UnmarshalJSON(data []byte) (err error)

type PaymentFxConvertParams 

type PaymentFxConvertParams struct {
	// The ID of the account from which funds will be converted.
	SourceAccountID param.Field[interface{}] `json:"sourceAccountId,required"`
	// The amount to convert from the source currency.
	SourceAmount param.Field[interface{}] `json:"sourceAmount,required"`
	// The ISO 4217 currency code of the source funds.
	SourceCurrency param.Field[interface{}] `json:"sourceCurrency,required"`
	// The ISO 4217 currency code for the target currency.
	TargetCurrency param.Field[interface{}] `json:"targetCurrency,required"`
	// If true, attempts to lock the quoted FX rate for a short period.
	FxRateLock param.Field[interface{}] `json:"fxRateLock"`
	// Optional: The ID of the account to deposit the converted funds. If null, funds
	// are held in a wallet/balance.
	TargetAccountID param.Field[interface{}] `json:"targetAccountId"`
}

func (PaymentFxConvertParams) MarshalJSON 

func (r PaymentFxConvertParams) MarshalJSON() (data []byte, err error)

type PaymentFxConvertResponse 

type PaymentFxConvertResponse struct {
	// Unique identifier for the currency conversion.
	ConversionID interface{} `json:"conversionId,required"`
	// Timestamp when the conversion was completed.
	ConversionTimestamp interface{} `json:"conversionTimestamp,required"`
	// The foreign exchange rate applied (target per source currency).
	FxRateApplied interface{} `json:"fxRateApplied,required"`
	// The amount converted from the source currency.
	SourceAmount interface{} `json:"sourceAmount,required"`
	// The source currency code.
	SourceCurrency interface{} `json:"sourceCurrency,required"`
	// Status of the currency conversion.
	Status PaymentFxConvertResponseStatus `json:"status,required"`
	// The amount converted into the target currency.
	TargetAmount interface{} `json:"targetAmount,required"`
	// Any fees applied to the conversion.
	FeesApplied interface{} `json:"feesApplied"`
	// The target currency code.
	TargetCurrency interface{} `json:"targetCurrency"`
	// The ID of the internal transaction representing this conversion.
	TransactionID interface{}                  `json:"transactionId"`
	JSON          paymentFxConvertResponseJSON `json:"-"`
}

func (*PaymentFxConvertResponse) UnmarshalJSON 

func (r *PaymentFxConvertResponse) UnmarshalJSON(data []byte) (err error)

type PaymentFxConvertResponseStatus 

type PaymentFxConvertResponseStatus string

Status of the currency conversion. 

const (
	PaymentFxConvertResponseStatusCompleted PaymentFxConvertResponseStatus = "completed"
	PaymentFxConvertResponseStatusPending   PaymentFxConvertResponseStatus = "pending"
	PaymentFxConvertResponseStatusFailed    PaymentFxConvertResponseStatus = "failed"
)

func (PaymentFxConvertResponseStatus) IsKnown 

func (r PaymentFxConvertResponseStatus) IsKnown() bool

type PaymentFxGetRatesParams 

type PaymentFxGetRatesParams struct {
	// The base currency code (e.g., USD).
	BaseCurrency param.Field[interface{}] `query:"baseCurrency,required"`
	// The target currency code (e.g., EUR).
	TargetCurrency param.Field[interface{}] `query:"targetCurrency,required"`
	// Number of days into the future to provide an AI-driven prediction.
	ForecastDays param.Field[interface{}] `query:"forecastDays"`
}

func (PaymentFxGetRatesParams) URLQuery 

func (r PaymentFxGetRatesParams) URLQuery() (v url.Values)

URLQuery serializes PaymentFxGetRatesParams's query parameters as `url.Values`.

type PaymentFxGetRatesResponse 

type PaymentFxGetRatesResponse struct {
	// The base currency code.
	BaseCurrency interface{} `json:"baseCurrency,required"`
	// Real-time foreign exchange rates.
	CurrentRate PaymentFxGetRatesResponseCurrentRate `json:"currentRate,required"`
	// The target currency code.
	TargetCurrency       interface{}                                   `json:"targetCurrency,required"`
	HistoricalVolatility PaymentFxGetRatesResponseHistoricalVolatility `json:"historicalVolatility"`
	// AI-predicted foreign exchange rates for future dates.
	PredictiveRates []PaymentFxGetRatesResponsePredictiveRate `json:"predictiveRates,nullable"`
	JSON            paymentFxGetRatesResponseJSON             `json:"-"`
}

func (*PaymentFxGetRatesResponse) UnmarshalJSON 

func (r *PaymentFxGetRatesResponse) UnmarshalJSON(data []byte) (err error)

type PaymentFxGetRatesResponseCurrentRate 

type PaymentFxGetRatesResponseCurrentRate struct {
	// Current ask rate (price at which a currency dealer will sell the base currency).
	Ask interface{} `json:"ask"`
	// Current bid rate (price at which a currency dealer will buy the base currency).
	Bid interface{} `json:"bid"`
	// Mid-market rate (average of bid and ask).
	Mid interface{} `json:"mid"`
	// Timestamp of the current rate.
	Timestamp interface{}                              `json:"timestamp"`
	JSON      paymentFxGetRatesResponseCurrentRateJSON `json:"-"`
}

Real-time foreign exchange rates.

func (*PaymentFxGetRatesResponseCurrentRate) UnmarshalJSON 

func (r *PaymentFxGetRatesResponseCurrentRate) UnmarshalJSON(data []byte) (err error)

type PaymentFxGetRatesResponseHistoricalVolatility 

type PaymentFxGetRatesResponseHistoricalVolatility struct {
	// Historical volatility over the past 30 days.
	Past30Days interface{} `json:"past30Days"`
	// Historical volatility over the past 7 days.
	Past7Days interface{}                                       `json:"past7Days"`
	JSON      paymentFxGetRatesResponseHistoricalVolatilityJSON `json:"-"`
}

func (*PaymentFxGetRatesResponseHistoricalVolatility) UnmarshalJSON 

func (r *PaymentFxGetRatesResponseHistoricalVolatility) UnmarshalJSON(data []byte) (err error)

type PaymentFxGetRatesResponsePredictiveRate 

type PaymentFxGetRatesResponsePredictiveRate struct {
	// AI model's confidence in the prediction (0-1).
	AIModelConfidence interface{} `json:"aiModelConfidence"`
	// Lower bound of the AI's confidence interval for the predicted rate.
	ConfidenceIntervalLower interface{} `json:"confidenceIntervalLower"`
	// Upper bound of the AI's confidence interval for the predicted rate.
	ConfidenceIntervalUpper interface{} `json:"confidenceIntervalUpper"`
	// Date for the predicted rate.
	Date interface{} `json:"date"`
	// AI-predicted mid-market rate.
	PredictedMidRate interface{}                                 `json:"predictedMidRate"`
	JSON             paymentFxGetRatesResponsePredictiveRateJSON `json:"-"`
}

func (*PaymentFxGetRatesResponsePredictiveRate) UnmarshalJSON 

func (r *PaymentFxGetRatesResponsePredictiveRate) UnmarshalJSON(data []byte) (err error)

type PaymentFxService 

type PaymentFxService struct {
	Options []option.RequestOption
}

PaymentFxService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPaymentFxService method instead.

func NewPaymentFxService 

func NewPaymentFxService(opts ...option.RequestOption) (r *PaymentFxService)

NewPaymentFxService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PaymentFxService) Convert 

func (r *PaymentFxService) Convert(ctx context.Context, body PaymentFxConvertParams, opts ...option.RequestOption) (res *PaymentFxConvertResponse, err error)

Executes an instant currency conversion between two currencies, either from a balance or into a specified account.

func (*PaymentFxService) GetRates 

func (r *PaymentFxService) GetRates(ctx context.Context, query PaymentFxGetRatesParams, opts ...option.RequestOption) (res *PaymentFxGetRatesResponse, err error)

Retrieves current and AI-predicted future foreign exchange rates for a specified currency pair, including bid/ask spreads and historical volatility data for informed decisions.

type PaymentInternationalInitiateParams 

type PaymentInternationalInitiateParams struct {
	// The amount to send in the source currency.
	Amount param.Field[interface{}] `json:"amount,required"`
	// Details of the payment beneficiary.
	Beneficiary param.Field[PaymentInternationalInitiateParamsBeneficiary] `json:"beneficiary,required"`
	// Purpose of the payment.
	Purpose param.Field[interface{}] `json:"purpose,required"`
	// The ID of the user's source account for the payment.
	SourceAccountID param.Field[interface{}] `json:"sourceAccountId,required"`
	// The ISO 4217 currency code of the source funds.
	SourceCurrency param.Field[interface{}] `json:"sourceCurrency,required"`
	// The ISO 4217 currency code for the beneficiary's currency.
	TargetCurrency param.Field[interface{}] `json:"targetCurrency,required"`
	// If true, attempts to lock the quoted FX rate for a short period.
	FxRateLock param.Field[interface{}] `json:"fxRateLock"`
	// Indicates whether to use AI-optimized FX rates or standard market rates.
	FxRateProvider param.Field[PaymentInternationalInitiateParamsFxRateProvider] `json:"fxRateProvider"`
	// Optional: Your internal reference for this payment.
	Reference param.Field[interface{}] `json:"reference"`
}

func (PaymentInternationalInitiateParams) MarshalJSON 

func (r PaymentInternationalInitiateParams) MarshalJSON() (data []byte, err error)

type PaymentInternationalInitiateParamsBeneficiary 

type PaymentInternationalInitiateParamsBeneficiary struct {
	// Full address of the beneficiary.
	Address param.Field[interface{}] `json:"address,required"`
	// Name of the beneficiary's bank.
	BankName param.Field[interface{}] `json:"bankName,required"`
	// Full name of the beneficiary.
	Name param.Field[interface{}] `json:"name,required"`
	// Account number (if IBAN/SWIFT not applicable).
	AccountNumber param.Field[interface{}] `json:"accountNumber"`
	// IBAN for Eurozone transfers.
	Iban param.Field[interface{}] `json:"iban"`
	// Routing number (if applicable, e.g., for US transfers).
	RoutingNumber param.Field[interface{}] `json:"routingNumber"`
	// SWIFT/BIC code for international transfers.
	SwiftBic param.Field[interface{}] `json:"swiftBic"`
}

Details of the payment beneficiary.

func (PaymentInternationalInitiateParamsBeneficiary) MarshalJSON 

func (r PaymentInternationalInitiateParamsBeneficiary) MarshalJSON() (data []byte, err error)

type PaymentInternationalInitiateParamsFxRateProvider 

type PaymentInternationalInitiateParamsFxRateProvider string

Indicates whether to use AI-optimized FX rates or standard market rates. 

const (
	PaymentInternationalInitiateParamsFxRateProviderProprietaryAI PaymentInternationalInitiateParamsFxRateProvider = "proprietary_ai"
	PaymentInternationalInitiateParamsFxRateProviderMarketRate    PaymentInternationalInitiateParamsFxRateProvider = "market_rate"
)

func (PaymentInternationalInitiateParamsFxRateProvider) IsKnown 

func (r PaymentInternationalInitiateParamsFxRateProvider) IsKnown() bool

type PaymentInternationalService 

type PaymentInternationalService struct {
	Options []option.RequestOption
}

PaymentInternationalService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPaymentInternationalService method instead.

func NewPaymentInternationalService 

func NewPaymentInternationalService(opts ...option.RequestOption) (r *PaymentInternationalService)

NewPaymentInternationalService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PaymentInternationalService) GetStatus 

func (r *PaymentInternationalService) GetStatus(ctx context.Context, paymentID interface{}, opts ...option.RequestOption) (res *InternationalPaymentStatus, err error)

Retrieves the current processing status and details of an initiated international payment.

func (*PaymentInternationalService) Initiate 

func (r *PaymentInternationalService) Initiate(ctx context.Context, body PaymentInternationalInitiateParams, opts ...option.RequestOption) (res *InternationalPaymentStatus, err error)

Facilitates the secure initiation of an international wire transfer to a beneficiary in another country and currency, leveraging optimal FX rates and tracking capabilities.

type PaymentService 

type PaymentService struct {
	Options       []option.RequestOption
	International *PaymentInternationalService
	Fx            *PaymentFxService
}

PaymentService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPaymentService method instead.

func NewPaymentService 

func NewPaymentService(opts ...option.RequestOption) (r *PaymentService)

NewPaymentService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type QuantumWeaverState 

type QuantumWeaverState struct {
	// Timestamp of the last status update.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Guidance on the next actions for the user.
	NextSteps interface{} `json:"nextSteps,required"`
	// Unique identifier for the business pitch.
	PitchID interface{} `json:"pitchId,required"`
	// Current stage of the business pitch in the incubation process.
	Stage QuantumWeaverStateStage `json:"stage,required"`
	// A human-readable status message.
	StatusMessage interface{} `json:"statusMessage,required"`
	// AI's estimated funding offer, if the pitch progresses.
	EstimatedFundingOffer interface{} `json:"estimatedFundingOffer"`
	// A summary of AI-generated feedback, if applicable.
	FeedbackSummary interface{} `json:"feedbackSummary"`
	// List of questions from Quantum Weaver requiring the user's input.
	Questions []QuantumWeaverStateQuestion `json:"questions,nullable"`
	JSON      quantumWeaverStateJSON       `json:"-"`
}

func (*QuantumWeaverState) UnmarshalJSON 

func (r *QuantumWeaverState) UnmarshalJSON(data []byte) (err error)

type QuantumWeaverStateQuestion 

type QuantumWeaverStateQuestion struct {
	ID         interface{}                    `json:"id"`
	Category   interface{}                    `json:"category"`
	IsRequired interface{}                    `json:"isRequired"`
	Question   interface{}                    `json:"question"`
	JSON       quantumWeaverStateQuestionJSON `json:"-"`
}

func (*QuantumWeaverStateQuestion) UnmarshalJSON 

func (r *QuantumWeaverStateQuestion) UnmarshalJSON(data []byte) (err error)

type QuantumWeaverStateStage 

type QuantumWeaverStateStage string

Current stage of the business pitch in the incubation process. 

const (
	QuantumWeaverStateStageSubmitted          QuantumWeaverStateStage = "submitted"
	QuantumWeaverStateStageInitialReview      QuantumWeaverStateStage = "initial_review"
	QuantumWeaverStateStageAIAnalysis         QuantumWeaverStateStage = "ai_analysis"
	QuantumWeaverStateStageFeedbackRequired   QuantumWeaverStateStage = "feedback_required"
	QuantumWeaverStateStageTestPhase          QuantumWeaverStateStage = "test_phase"
	QuantumWeaverStateStageFinalReview        QuantumWeaverStateStage = "final_review"
	QuantumWeaverStateStageApprovedForFunding QuantumWeaverStateStage = "approved_for_funding"
	QuantumWeaverStateStageRejected           QuantumWeaverStateStage = "rejected"
	QuantumWeaverStateStageIncubatedGraduated QuantumWeaverStateStage = "incubated_graduated"
)

func (QuantumWeaverStateStage) IsKnown 

func (r QuantumWeaverStateStage) IsKnown() bool

type RecurringTransaction 

type RecurringTransaction struct {
	// Unique identifier for the recurring transaction.
	ID interface{} `json:"id,required"`
	// Amount of the recurring transaction.
	Amount interface{} `json:"amount,required"`
	// Category of the recurring transaction.
	Category interface{} `json:"category,required"`
	// ISO 4217 currency code.
	Currency interface{} `json:"currency,required"`
	// Description of the recurring transaction.
	Description interface{} `json:"description,required"`
	// Frequency of the recurring transaction.
	Frequency RecurringTransactionFrequency `json:"frequency,required"`
	// Current status of the recurring transaction.
	Status RecurringTransactionStatus `json:"status,required"`
	// AI confidence score that this is a recurring transaction (0-1).
	AIConfidenceScore interface{} `json:"aiConfidenceScore"`
	// Date of the last payment for this recurring transaction.
	LastPaidDate interface{} `json:"lastPaidDate"`
	// ID of the account typically used for this recurring transaction.
	LinkedAccountID interface{} `json:"linkedAccountId"`
	// Next scheduled due date for the transaction.
	NextDueDate interface{}              `json:"nextDueDate"`
	JSON        recurringTransactionJSON `json:"-"`
}

Details of a detected or user-defined recurring transaction.

func (*RecurringTransaction) UnmarshalJSON 

func (r *RecurringTransaction) UnmarshalJSON(data []byte) (err error)

type RecurringTransactionFrequency 

type RecurringTransactionFrequency string

Frequency of the recurring transaction. 

const (
	RecurringTransactionFrequencyDaily        RecurringTransactionFrequency = "daily"
	RecurringTransactionFrequencyWeekly       RecurringTransactionFrequency = "weekly"
	RecurringTransactionFrequencyBiWeekly     RecurringTransactionFrequency = "bi_weekly"
	RecurringTransactionFrequencyMonthly      RecurringTransactionFrequency = "monthly"
	RecurringTransactionFrequencyQuarterly    RecurringTransactionFrequency = "quarterly"
	RecurringTransactionFrequencySemiAnnually RecurringTransactionFrequency = "semi_annually"
	RecurringTransactionFrequencyAnnually     RecurringTransactionFrequency = "annually"
)

func (RecurringTransactionFrequency) IsKnown 

func (r RecurringTransactionFrequency) IsKnown() bool

type RecurringTransactionStatus 

type RecurringTransactionStatus string

Current status of the recurring transaction. 

const (
	RecurringTransactionStatusActive    RecurringTransactionStatus = "active"
	RecurringTransactionStatusInactive  RecurringTransactionStatus = "inactive"
	RecurringTransactionStatusCancelled RecurringTransactionStatus = "cancelled"
	RecurringTransactionStatusPaused    RecurringTransactionStatus = "paused"
)

func (RecurringTransactionStatus) IsKnown 

func (r RecurringTransactionStatus) IsKnown() bool

type SimulationResponse 

type SimulationResponse struct {
	// Key quantitative and qualitative impacts identified by the AI.
	KeyImpacts []SimulationResponseKeyImpact `json:"keyImpacts,required"`
	// A natural language summary of the simulation's results and key findings.
	NarrativeSummary interface{} `json:"narrativeSummary,required"`
	// Unique identifier for the completed simulation.
	SimulationID interface{} `json:"simulationId,required"`
	// Actionable recommendations derived from the simulation.
	Recommendations []AIInsight `json:"recommendations,nullable"`
	// AI-driven risk assessment of the simulated scenario.
	RiskAnalysis SimulationResponseRiskAnalysis `json:"riskAnalysis"`
	// Optional: URLs to generated visualization data or images.
	Visualizations []SimulationResponseVisualization `json:"visualizations,nullable"`
	JSON           simulationResponseJSON            `json:"-"`
}

func (*SimulationResponse) UnmarshalJSON 

func (r *SimulationResponse) UnmarshalJSON(data []byte) (err error)

type SimulationResponseKeyImpact 

type SimulationResponseKeyImpact struct {
	Metric   interface{}                          `json:"metric"`
	Severity SimulationResponseKeyImpactsSeverity `json:"severity"`
	Value    interface{}                          `json:"value"`
	JSON     simulationResponseKeyImpactJSON      `json:"-"`
}

func (*SimulationResponseKeyImpact) UnmarshalJSON 

func (r *SimulationResponseKeyImpact) UnmarshalJSON(data []byte) (err error)

type SimulationResponseKeyImpactsSeverity 

type SimulationResponseKeyImpactsSeverity string
const (
	SimulationResponseKeyImpactsSeverityLow    SimulationResponseKeyImpactsSeverity = "low"
	SimulationResponseKeyImpactsSeverityMedium SimulationResponseKeyImpactsSeverity = "medium"
	SimulationResponseKeyImpactsSeverityHigh   SimulationResponseKeyImpactsSeverity = "high"
)

func (SimulationResponseKeyImpactsSeverity) IsKnown 

func (r SimulationResponseKeyImpactsSeverity) IsKnown() bool

type SimulationResponseRiskAnalysis 

type SimulationResponseRiskAnalysis struct {
	// Maximum potential loss from peak to trough (e.g., 0.25 for 25%).
	MaxDrawdown interface{} `json:"maxDrawdown"`
	// Measure of market volatility associated with the scenario.
	VolatilityIndex interface{}                        `json:"volatilityIndex"`
	JSON            simulationResponseRiskAnalysisJSON `json:"-"`
}

AI-driven risk assessment of the simulated scenario.

func (*SimulationResponseRiskAnalysis) UnmarshalJSON 

func (r *SimulationResponseRiskAnalysis) UnmarshalJSON(data []byte) (err error)

type SimulationResponseVisualization 

type SimulationResponseVisualization struct {
	DataUri interface{}                          `json:"dataUri"`
	Title   interface{}                          `json:"title"`
	Type    SimulationResponseVisualizationsType `json:"type"`
	JSON    simulationResponseVisualizationJSON  `json:"-"`
}

func (*SimulationResponseVisualization) UnmarshalJSON 

func (r *SimulationResponseVisualization) UnmarshalJSON(data []byte) (err error)

type SimulationResponseVisualizationsType 

type SimulationResponseVisualizationsType string
const (
	SimulationResponseVisualizationsTypeLineChart SimulationResponseVisualizationsType = "line_chart"
	SimulationResponseVisualizationsTypeBarChart  SimulationResponseVisualizationsType = "bar_chart"
	SimulationResponseVisualizationsTypeTable     SimulationResponseVisualizationsType = "table"
)

func (SimulationResponseVisualizationsType) IsKnown 

func (r SimulationResponseVisualizationsType) IsKnown() bool

type SustainabilityGetCarbonFootprintResponse 

type SustainabilityGetCarbonFootprintResponse struct {
	// AI-driven insights and recommendations for reducing carbon footprint.
	AIInsights []AIInsight `json:"aiInsights,required"`
	// Breakdown of carbon footprint by spending categories.
	BreakdownByCategory []SustainabilityGetCarbonFootprintResponseBreakdownByCategory `json:"breakdownByCategory,required"`
	// The period covered by the report.
	Period interface{} `json:"period,required"`
	// Unique identifier for the carbon footprint report.
	ReportID interface{} `json:"reportId,required"`
	// Total estimated carbon footprint in kilograms of CO2 equivalent.
	TotalCarbonFootprintKgCo2e interface{} `json:"totalCarbonFootprintKgCO2e,required"`
	// Recommendations for purchasing carbon offsets.
	OffsetRecommendations []SustainabilityGetCarbonFootprintResponseOffsetRecommendation `json:"offsetRecommendations,nullable"`
	JSON                  sustainabilityGetCarbonFootprintResponseJSON                   `json:"-"`
}

func (*SustainabilityGetCarbonFootprintResponse) UnmarshalJSON 

func (r *SustainabilityGetCarbonFootprintResponse) UnmarshalJSON(data []byte) (err error)

type SustainabilityGetCarbonFootprintResponseBreakdownByCategory 

type SustainabilityGetCarbonFootprintResponseBreakdownByCategory struct {
	CarbonFootprintKgCo2e interface{}                                                     `json:"carbonFootprintKgCO2e"`
	Category              interface{}                                                     `json:"category"`
	Percentage            interface{}                                                     `json:"percentage"`
	JSON                  sustainabilityGetCarbonFootprintResponseBreakdownByCategoryJSON `json:"-"`
}

func (*SustainabilityGetCarbonFootprintResponseBreakdownByCategory) UnmarshalJSON 

func (r *SustainabilityGetCarbonFootprintResponseBreakdownByCategory) UnmarshalJSON(data []byte) (err error)

type SustainabilityGetCarbonFootprintResponseOffsetRecommendation 

type SustainabilityGetCarbonFootprintResponseOffsetRecommendation struct {
	CostPerTonUsd      interface{}                                                      `json:"costPerTonUSD"`
	OffsetAmountKgCo2e interface{}                                                      `json:"offsetAmountKgCO2e"`
	Project            interface{}                                                      `json:"project"`
	TotalCostUsd       interface{}                                                      `json:"totalCostUSD"`
	JSON               sustainabilityGetCarbonFootprintResponseOffsetRecommendationJSON `json:"-"`
}

func (*SustainabilityGetCarbonFootprintResponseOffsetRecommendation) UnmarshalJSON 

func (r *SustainabilityGetCarbonFootprintResponseOffsetRecommendation) UnmarshalJSON(data []byte) (err error)

type SustainabilityInvestmentAnalyzeImpactResponse 

type SustainabilityInvestmentAnalyzeImpactResponse struct {
	// AI-driven recommendations to improve the portfolio's ESG impact.
	AIRecommendations []AIInsight `json:"aiRecommendations,required"`
	// Average ESG score of a relevant market benchmark for comparison.
	BenchmarkEsgScore interface{} `json:"benchmarkESGScore,required"`
	// Breakdown of the portfolio's ESG score by individual factors.
	BreakdownByEsgFactors SustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactors `json:"breakdownByESGFactors,required"`
	// Lowest holdings in the portfolio by ESG score.
	LowestEsgHoldings []SustainabilityInvestmentAnalyzeImpactResponseLowestEsgHolding `json:"lowestESGHoldings,required"`
	// Overall ESG score of the entire portfolio (0-10).
	OverallEsgScore interface{} `json:"overallESGScore,required"`
	// ID of the investment portfolio analyzed.
	PortfolioID interface{} `json:"portfolioId,required"`
	// Top holdings in the portfolio by ESG score.
	TopEsgHoldings []SustainabilityInvestmentAnalyzeImpactResponseTopEsgHolding `json:"topESGHoldings,required"`
	JSON           sustainabilityInvestmentAnalyzeImpactResponseJSON            `json:"-"`
}

func (*SustainabilityInvestmentAnalyzeImpactResponse) UnmarshalJSON 

func (r *SustainabilityInvestmentAnalyzeImpactResponse) UnmarshalJSON(data []byte) (err error)

type SustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactors 

type SustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactors struct {
	EnvironmentalScore interface{}                                                            `json:"environmentalScore"`
	GovernanceScore    interface{}                                                            `json:"governanceScore"`
	SocialScore        interface{}                                                            `json:"socialScore"`
	JSON               sustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactorsJSON `json:"-"`
}

Breakdown of the portfolio's ESG score by individual factors.

func (*SustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactors) UnmarshalJSON 

func (r *SustainabilityInvestmentAnalyzeImpactResponseBreakdownByEsgFactors) UnmarshalJSON(data []byte) (err error)

type SustainabilityInvestmentAnalyzeImpactResponseLowestEsgHolding 

type SustainabilityInvestmentAnalyzeImpactResponseLowestEsgHolding struct {
	AssetName   interface{}                                                       `json:"assetName"`
	AssetSymbol interface{}                                                       `json:"assetSymbol"`
	EsgScore    interface{}                                                       `json:"esgScore"`
	JSON        sustainabilityInvestmentAnalyzeImpactResponseLowestEsgHoldingJSON `json:"-"`
}

func (*SustainabilityInvestmentAnalyzeImpactResponseLowestEsgHolding) UnmarshalJSON 

func (r *SustainabilityInvestmentAnalyzeImpactResponseLowestEsgHolding) UnmarshalJSON(data []byte) (err error)

type SustainabilityInvestmentAnalyzeImpactResponseTopEsgHolding 

type SustainabilityInvestmentAnalyzeImpactResponseTopEsgHolding struct {
	AssetName   interface{}                                                    `json:"assetName"`
	AssetSymbol interface{}                                                    `json:"assetSymbol"`
	EsgScore    interface{}                                                    `json:"esgScore"`
	JSON        sustainabilityInvestmentAnalyzeImpactResponseTopEsgHoldingJSON `json:"-"`
}

func (*SustainabilityInvestmentAnalyzeImpactResponseTopEsgHolding) UnmarshalJSON 

func (r *SustainabilityInvestmentAnalyzeImpactResponseTopEsgHolding) UnmarshalJSON(data []byte) (err error)

type SustainabilityInvestmentService 

type SustainabilityInvestmentService struct {
	Options []option.RequestOption
}

SustainabilityInvestmentService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSustainabilityInvestmentService method instead.

func NewSustainabilityInvestmentService 

func NewSustainabilityInvestmentService(opts ...option.RequestOption) (r *SustainabilityInvestmentService)

NewSustainabilityInvestmentService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SustainabilityInvestmentService) AnalyzeImpact 

func (r *SustainabilityInvestmentService) AnalyzeImpact(ctx context.Context, opts ...option.RequestOption) (res *SustainabilityInvestmentAnalyzeImpactResponse, err error)

Provides an AI-driven analysis of the Environmental, Social, and Governance (ESG) impact of the user's entire investment portfolio, benchmarking against industry standards and suggesting more sustainable alternatives.

type SustainabilityPurchaseCarbonOffsetsParams 

type SustainabilityPurchaseCarbonOffsetsParams struct {
	// The amount of carbon dioxide equivalent to offset in kilograms.
	AmountKgCo2e param.Field[interface{}] `json:"amountKgCO2e,required"`
	// Optional: The specific carbon offset project to support.
	OffsetProject param.Field[interface{}] `json:"offsetProject,required"`
	// The ID of the user's account to use for payment.
	PaymentAccountID param.Field[interface{}] `json:"paymentAccountId,required"`
}

func (SustainabilityPurchaseCarbonOffsetsParams) MarshalJSON 

func (r SustainabilityPurchaseCarbonOffsetsParams) MarshalJSON() (data []byte, err error)

type SustainabilityPurchaseCarbonOffsetsResponse 

type SustainabilityPurchaseCarbonOffsetsResponse struct {
	// The amount of carbon dioxide equivalent offset by this purchase.
	AmountOffsetKgCo2e interface{} `json:"amountOffsetKgCO2e,required"`
	// Timestamp of the purchase.
	PurchaseDate interface{} `json:"purchaseDate,required"`
	// Unique identifier for the carbon offset purchase.
	PurchaseID interface{} `json:"purchaseId,required"`
	// Total cost of the carbon offset purchase in USD.
	TotalCostUsd interface{} `json:"totalCostUSD,required"`
	// URL to the official carbon offset certificate.
	CertificateURL interface{} `json:"certificateUrl"`
	// The carbon offset project supported.
	ProjectSupported interface{} `json:"projectSupported"`
	// The ID of the internal financial transaction for this purchase.
	TransactionID interface{}                                     `json:"transactionId"`
	JSON          sustainabilityPurchaseCarbonOffsetsResponseJSON `json:"-"`
}

func (*SustainabilityPurchaseCarbonOffsetsResponse) UnmarshalJSON 

func (r *SustainabilityPurchaseCarbonOffsetsResponse) UnmarshalJSON(data []byte) (err error)

type SustainabilityService 

type SustainabilityService struct {
	Options     []option.RequestOption
	Investments *SustainabilityInvestmentService
}

SustainabilityService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSustainabilityService method instead.

func NewSustainabilityService 

func NewSustainabilityService(opts ...option.RequestOption) (r *SustainabilityService)

NewSustainabilityService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SustainabilityService) GetCarbonFootprint 

func (r *SustainabilityService) GetCarbonFootprint(ctx context.Context, opts ...option.RequestOption) (res *SustainabilityGetCarbonFootprintResponse, err error)

Generates a detailed report of the user's estimated carbon footprint based on transaction data, lifestyle choices, and AI-driven impact assessments, offering insights and reduction strategies.

func (*SustainabilityService) PurchaseCarbonOffsets 

func (r *SustainabilityService) PurchaseCarbonOffsets(ctx context.Context, body SustainabilityPurchaseCarbonOffsetsParams, opts ...option.RequestOption) (res *SustainabilityPurchaseCarbonOffsetsResponse, err error)

Allows users to purchase carbon offsets to neutralize their estimated carbon footprint, supporting environmental initiatives.

type Transaction 

type Transaction struct {
	// Unique identifier for the transaction.
	ID interface{} `json:"id,required"`
	// ID of the account from which the transaction occurred.
	AccountID interface{} `json:"accountId,required"`
	// Amount of the transaction.
	Amount interface{} `json:"amount,required"`
	// AI-assigned or user-defined category of the transaction (e.g., 'Groceries',
	// 'Utilities').
	Category interface{} `json:"category,required"`
	// ISO 4217 currency code of the transaction.
	Currency interface{} `json:"currency,required"`
	// Date the transaction occurred (local date).
	Date interface{} `json:"date,required"`
	// Detailed description of the transaction.
	Description interface{} `json:"description,required"`
	// Type of the transaction.
	Type TransactionType `json:"type,required"`
	// AI confidence score for the assigned category (0-1).
	AICategoryConfidence interface{} `json:"aiCategoryConfidence"`
	// Estimated carbon footprint in kg CO2e for this transaction, derived by AI.
	CarbonFootprint interface{} `json:"carbonFootprint"`
	// Current dispute status of the transaction.
	DisputeStatus TransactionDisputeStatus `json:"disputeStatus"`
	// Geographic location details for a transaction.
	Location TransactionLocation `json:"location"`
	// Detailed information about a merchant associated with a transaction.
	MerchantDetails TransactionMerchantDetails `json:"merchantDetails"`
	// Personal notes added by the user to the transaction.
	Notes interface{} `json:"notes"`
	// Channel through which the payment was made.
	PaymentChannel TransactionPaymentChannel `json:"paymentChannel,nullable"`
	// Date the transaction was posted to the account (local date).
	PostedDate interface{} `json:"postedDate"`
	// URL to a digital receipt for the transaction.
	ReceiptURL interface{} `json:"receiptUrl"`
	// User-defined tags for the transaction.
	Tags []interface{}   `json:"tags,nullable"`
	JSON transactionJSON `json:"-"`
}

func (*Transaction) UnmarshalJSON 

func (r *Transaction) UnmarshalJSON(data []byte) (err error)

type TransactionCategorizeParams 

type TransactionCategorizeParams struct {
	// The new category for the transaction. Can be hierarchical.
	Category param.Field[interface{}] `json:"category,required"`
	// If true, the AI will learn from this correction and try to apply it to similar
	// future transactions.
	ApplyToFuture param.Field[interface{}] `json:"applyToFuture"`
	// Optional notes to add to the transaction.
	Notes param.Field[interface{}] `json:"notes"`
}

func (TransactionCategorizeParams) MarshalJSON 

func (r TransactionCategorizeParams) MarshalJSON() (data []byte, err error)

type TransactionDisputeParams 

type TransactionDisputeParams struct {
	// Detailed explanation of the dispute.
	Details param.Field[interface{}] `json:"details,required"`
	// The primary reason for disputing the transaction.
	Reason param.Field[TransactionDisputeParamsReason] `json:"reason,required"`
	// URLs to supporting documents (e.g., receipts, communication).
	SupportingDocuments param.Field[[]interface{}] `json:"supportingDocuments"`
}

func (TransactionDisputeParams) MarshalJSON 

func (r TransactionDisputeParams) MarshalJSON() (data []byte, err error)

type TransactionDisputeParamsReason 

type TransactionDisputeParamsReason string

The primary reason for disputing the transaction. 

const (
	TransactionDisputeParamsReasonUnauthorized        TransactionDisputeParamsReason = "unauthorized"
	TransactionDisputeParamsReasonDuplicateCharge     TransactionDisputeParamsReason = "duplicate_charge"
	TransactionDisputeParamsReasonIncorrectAmount     TransactionDisputeParamsReason = "incorrect_amount"
	TransactionDisputeParamsReasonProductServiceIssue TransactionDisputeParamsReason = "product_service_issue"
	TransactionDisputeParamsReasonOther               TransactionDisputeParamsReason = "other"
)

func (TransactionDisputeParamsReason) IsKnown 

func (r TransactionDisputeParamsReason) IsKnown() bool

type TransactionDisputeResponse 

type TransactionDisputeResponse struct {
	// Unique identifier for the dispute case.
	DisputeID interface{} `json:"disputeId,required"`
	// Timestamp when the dispute status was last updated.
	LastUpdated interface{} `json:"lastUpdated,required"`
	// Guidance on what to expect next in the dispute process.
	NextSteps interface{} `json:"nextSteps,required"`
	// Current status of the dispute.
	Status TransactionDisputeResponseStatus `json:"status,required"`
	JSON   transactionDisputeResponseJSON   `json:"-"`
}

func (*TransactionDisputeResponse) UnmarshalJSON 

func (r *TransactionDisputeResponse) UnmarshalJSON(data []byte) (err error)

type TransactionDisputeResponseStatus 

type TransactionDisputeResponseStatus string

Current status of the dispute. 

const (
	TransactionDisputeResponseStatusPending          TransactionDisputeResponseStatus = "pending"
	TransactionDisputeResponseStatusUnderReview      TransactionDisputeResponseStatus = "under_review"
	TransactionDisputeResponseStatusRequiresMoreInfo TransactionDisputeResponseStatus = "requires_more_info"
	TransactionDisputeResponseStatusResolved         TransactionDisputeResponseStatus = "resolved"
	TransactionDisputeResponseStatusRejected         TransactionDisputeResponseStatus = "rejected"
)

func (TransactionDisputeResponseStatus) IsKnown 

func (r TransactionDisputeResponseStatus) IsKnown() bool

type TransactionDisputeStatus 

type TransactionDisputeStatus string

Current dispute status of the transaction. 

const (
	TransactionDisputeStatusNone        TransactionDisputeStatus = "none"
	TransactionDisputeStatusPending     TransactionDisputeStatus = "pending"
	TransactionDisputeStatusUnderReview TransactionDisputeStatus = "under_review"
	TransactionDisputeStatusResolved    TransactionDisputeStatus = "resolved"
	TransactionDisputeStatusRejected    TransactionDisputeStatus = "rejected"
)

func (TransactionDisputeStatus) IsKnown 

func (r TransactionDisputeStatus) IsKnown() bool

type TransactionInsightGetSpendingTrendsResponse 

type TransactionInsightGetSpendingTrendsResponse struct {
	// AI-driven insights and recommendations related to spending.
	AIInsights []AIInsight `json:"aiInsights,required"`
	// AI-projected total spending for the next month.
	ForecastNextMonth interface{} `json:"forecastNextMonth,required"`
	// Overall trend of spending (increasing, decreasing, stable).
	OverallTrend TransactionInsightGetSpendingTrendsResponseOverallTrend `json:"overallTrend,required"`
	// Percentage change in spending over the period.
	PercentageChange interface{} `json:"percentageChange,required"`
	// The period over which the spending trend is analyzed.
	Period interface{} `json:"period,required"`
	// Categories with the most significant changes in spending.
	TopCategoriesByChange []TransactionInsightGetSpendingTrendsResponseTopCategoriesByChange `json:"topCategoriesByChange,required"`
	JSON                  transactionInsightGetSpendingTrendsResponseJSON                    `json:"-"`
}

func (*TransactionInsightGetSpendingTrendsResponse) UnmarshalJSON 

func (r *TransactionInsightGetSpendingTrendsResponse) UnmarshalJSON(data []byte) (err error)

type TransactionInsightGetSpendingTrendsResponseOverallTrend 

type TransactionInsightGetSpendingTrendsResponseOverallTrend string

Overall trend of spending (increasing, decreasing, stable). 

const (
	TransactionInsightGetSpendingTrendsResponseOverallTrendIncreasing TransactionInsightGetSpendingTrendsResponseOverallTrend = "increasing"
	TransactionInsightGetSpendingTrendsResponseOverallTrendDecreasing TransactionInsightGetSpendingTrendsResponseOverallTrend = "decreasing"
	TransactionInsightGetSpendingTrendsResponseOverallTrendStable     TransactionInsightGetSpendingTrendsResponseOverallTrend = "stable"
)

func (TransactionInsightGetSpendingTrendsResponseOverallTrend) IsKnown 

func (r TransactionInsightGetSpendingTrendsResponseOverallTrend) IsKnown() bool

type TransactionInsightGetSpendingTrendsResponseTopCategoriesByChange 

type TransactionInsightGetSpendingTrendsResponseTopCategoriesByChange struct {
	AbsoluteChange   interface{}                                                          `json:"absoluteChange"`
	Category         interface{}                                                          `json:"category"`
	PercentageChange interface{}                                                          `json:"percentageChange"`
	JSON             transactionInsightGetSpendingTrendsResponseTopCategoriesByChangeJSON `json:"-"`
}

func (*TransactionInsightGetSpendingTrendsResponseTopCategoriesByChange) UnmarshalJSON 

func (r *TransactionInsightGetSpendingTrendsResponseTopCategoriesByChange) UnmarshalJSON(data []byte) (err error)

type TransactionInsightService 

type TransactionInsightService struct {
	Options []option.RequestOption
}

TransactionInsightService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTransactionInsightService method instead.

func NewTransactionInsightService 

func NewTransactionInsightService(opts ...option.RequestOption) (r *TransactionInsightService)

NewTransactionInsightService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TransactionInsightService) GetSpendingTrends 

func (r *TransactionInsightService) GetSpendingTrends(ctx context.Context, opts ...option.RequestOption) (res *TransactionInsightGetSpendingTrendsResponse, err error)

Retrieves AI-generated insights into user spending trends over time, identifying patterns and anomalies.

type TransactionListParams 

type TransactionListParams struct {
	// Filter transactions by their AI-assigned or user-defined category.
	Category param.Field[interface{}] `query:"category"`
	// Retrieve transactions up to this date (inclusive).
	EndDate param.Field[interface{}] `query:"endDate"`
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Filter for transactions with an amount less than or equal to this value.
	MaxAmount param.Field[interface{}] `query:"maxAmount"`
	// Filter for transactions with an amount greater than or equal to this value.
	MinAmount param.Field[interface{}] `query:"minAmount"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
	// Free-text search across transaction descriptions, merchants, and notes.
	SearchQuery param.Field[interface{}] `query:"searchQuery"`
	// Retrieve transactions from this date (inclusive).
	StartDate param.Field[interface{}] `query:"startDate"`
	// Filter transactions by type (e.g., income, expense, transfer).
	Type param.Field[TransactionListParamsType] `query:"type"`
}

func (TransactionListParams) URLQuery 

func (r TransactionListParams) URLQuery() (v url.Values)

URLQuery serializes TransactionListParams's query parameters as `url.Values`.

type TransactionListParamsType 

type TransactionListParamsType string

Filter transactions by type (e.g., income, expense, transfer). 

const (
	TransactionListParamsTypeIncome      TransactionListParamsType = "income"
	TransactionListParamsTypeExpense     TransactionListParamsType = "expense"
	TransactionListParamsTypeTransfer    TransactionListParamsType = "transfer"
	TransactionListParamsTypeInvestment  TransactionListParamsType = "investment"
	TransactionListParamsTypeRefund      TransactionListParamsType = "refund"
	TransactionListParamsTypeBillPayment TransactionListParamsType = "bill_payment"
)

func (TransactionListParamsType) IsKnown 

func (r TransactionListParamsType) IsKnown() bool

type TransactionLocation 

type TransactionLocation struct {
	// City where the transaction occurred.
	City interface{} `json:"city"`
	// Latitude coordinate of the transaction.
	Latitude interface{} `json:"latitude"`
	// Longitude coordinate of the transaction.
	Longitude interface{} `json:"longitude"`
	// State where the transaction occurred.
	State interface{} `json:"state"`
	// Zip code where the transaction occurred.
	Zip  interface{}             `json:"zip"`
	JSON transactionLocationJSON `json:"-"`
}

Geographic location details for a transaction.

func (*TransactionLocation) UnmarshalJSON 

func (r *TransactionLocation) UnmarshalJSON(data []byte) (err error)

type TransactionMerchantDetails 

type TransactionMerchantDetails struct {
	Address Address `json:"address"`
	// URL to the merchant's logo.
	LogoURL interface{} `json:"logoUrl"`
	// Official name of the merchant.
	Name interface{} `json:"name"`
	// Merchant's phone number.
	Phone interface{} `json:"phone"`
	// Merchant's website URL.
	Website interface{}                    `json:"website"`
	JSON    transactionMerchantDetailsJSON `json:"-"`
}

Detailed information about a merchant associated with a transaction.

func (*TransactionMerchantDetails) UnmarshalJSON 

func (r *TransactionMerchantDetails) UnmarshalJSON(data []byte) (err error)

type TransactionPaymentChannel 

type TransactionPaymentChannel string

Channel through which the payment was made. 

const (
	TransactionPaymentChannelInStore     TransactionPaymentChannel = "in_store"
	TransactionPaymentChannelOnline      TransactionPaymentChannel = "online"
	TransactionPaymentChannelMobile      TransactionPaymentChannel = "mobile"
	TransactionPaymentChannelAtm         TransactionPaymentChannel = "ATM"
	TransactionPaymentChannelBillPayment TransactionPaymentChannel = "bill_payment"
	TransactionPaymentChannelTransfer    TransactionPaymentChannel = "transfer"
	TransactionPaymentChannelOther       TransactionPaymentChannel = "other"
)

func (TransactionPaymentChannel) IsKnown 

func (r TransactionPaymentChannel) IsKnown() bool

type TransactionRecurringListParams 

type TransactionRecurringListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (TransactionRecurringListParams) URLQuery 

func (r TransactionRecurringListParams) URLQuery() (v url.Values)

URLQuery serializes TransactionRecurringListParams's query parameters as `url.Values`.

type TransactionRecurringListResponse 

type TransactionRecurringListResponse struct {
	Data []RecurringTransaction               `json:"data"`
	JSON transactionRecurringListResponseJSON `json:"-"`
	PaginatedList
}

func (*TransactionRecurringListResponse) UnmarshalJSON 

func (r *TransactionRecurringListResponse) UnmarshalJSON(data []byte) (err error)

type TransactionRecurringNewParams 

type TransactionRecurringNewParams struct {
	// Amount of the recurring transaction.
	Amount param.Field[interface{}] `json:"amount,required"`
	// Category of the recurring transaction.
	Category param.Field[interface{}] `json:"category,required"`
	// ISO 4217 currency code.
	Currency param.Field[interface{}] `json:"currency,required"`
	// Description of the recurring transaction.
	Description param.Field[interface{}] `json:"description,required"`
	// Frequency of the recurring transaction.
	Frequency param.Field[TransactionRecurringNewParamsFrequency] `json:"frequency,required"`
	// ID of the account to associate with this recurring transaction.
	LinkedAccountID param.Field[interface{}] `json:"linkedAccountId,required"`
	// The date when this recurring transaction is expected to start.
	StartDate param.Field[interface{}] `json:"startDate,required"`
}

func (TransactionRecurringNewParams) MarshalJSON 

func (r TransactionRecurringNewParams) MarshalJSON() (data []byte, err error)

type TransactionRecurringNewParamsFrequency 

type TransactionRecurringNewParamsFrequency string

Frequency of the recurring transaction. 

const (
	TransactionRecurringNewParamsFrequencyDaily        TransactionRecurringNewParamsFrequency = "daily"
	TransactionRecurringNewParamsFrequencyWeekly       TransactionRecurringNewParamsFrequency = "weekly"
	TransactionRecurringNewParamsFrequencyBiWeekly     TransactionRecurringNewParamsFrequency = "bi_weekly"
	TransactionRecurringNewParamsFrequencyMonthly      TransactionRecurringNewParamsFrequency = "monthly"
	TransactionRecurringNewParamsFrequencyQuarterly    TransactionRecurringNewParamsFrequency = "quarterly"
	TransactionRecurringNewParamsFrequencySemiAnnually TransactionRecurringNewParamsFrequency = "semi_annually"
	TransactionRecurringNewParamsFrequencyAnnually     TransactionRecurringNewParamsFrequency = "annually"
)

func (TransactionRecurringNewParamsFrequency) IsKnown 

func (r TransactionRecurringNewParamsFrequency) IsKnown() bool

type TransactionRecurringService 

type TransactionRecurringService struct {
	Options []option.RequestOption
}

TransactionRecurringService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTransactionRecurringService method instead.

func NewTransactionRecurringService 

func NewTransactionRecurringService(opts ...option.RequestOption) (r *TransactionRecurringService)

NewTransactionRecurringService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TransactionRecurringService) List 

func (r *TransactionRecurringService) List(ctx context.Context, query TransactionRecurringListParams, opts ...option.RequestOption) (res *TransactionRecurringListResponse, err error)

Retrieves a list of all detected or user-defined recurring transactions, useful for budget tracking and subscription management.

func (*TransactionRecurringService) New 

func (r *TransactionRecurringService) New(ctx context.Context, body TransactionRecurringNewParams, opts ...option.RequestOption) (res *RecurringTransaction, err error)

Defines a new recurring transaction pattern for future tracking and budgeting.

type TransactionService 

type TransactionService struct {
	Options   []option.RequestOption
	Recurring *TransactionRecurringService
	Insights  *TransactionInsightService
}

TransactionService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTransactionService method instead.

func NewTransactionService 

func NewTransactionService(opts ...option.RequestOption) (r *TransactionService)

NewTransactionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TransactionService) Categorize 

func (r *TransactionService) Categorize(ctx context.Context, transactionID interface{}, body TransactionCategorizeParams, opts ...option.RequestOption) (res *Transaction, err error)

Allows the user to override or refine the AI's categorization for a transaction, improving future AI accuracy and personal financial reporting.

func (*TransactionService) Dispute 

func (r *TransactionService) Dispute(ctx context.Context, transactionID interface{}, body TransactionDisputeParams, opts ...option.RequestOption) (res *TransactionDisputeResponse, err error)

Begins the process of disputing a specific transaction, providing details and supporting documentation for review by our compliance team and AI.

func (*TransactionService) Get 

func (r *TransactionService) Get(ctx context.Context, transactionID interface{}, opts ...option.RequestOption) (res *Transaction, err error)

Retrieves granular information for a single transaction by its unique ID, including AI categorization confidence, merchant details, and associated carbon footprint.

func (*TransactionService) List 

func (r *TransactionService) List(ctx context.Context, query TransactionListParams, opts ...option.RequestOption) (res *PaginatedTransactions, err error)

Retrieves a paginated list of the user's transactions, with extensive options for filtering by type, category, date range, amount, and intelligent AI-driven sorting and search capabilities.

func (*TransactionService) UpdateNotes 

func (r *TransactionService) UpdateNotes(ctx context.Context, transactionID interface{}, body TransactionUpdateNotesParams, opts ...option.RequestOption) (res *Transaction, err error)

Allows the user to add or update personal notes for a specific transaction.

type TransactionType 

type TransactionType string

Type of the transaction. 

const (
	TransactionTypeIncome      TransactionType = "income"
	TransactionTypeExpense     TransactionType = "expense"
	TransactionTypeTransfer    TransactionType = "transfer"
	TransactionTypeInvestment  TransactionType = "investment"
	TransactionTypeRefund      TransactionType = "refund"
	TransactionTypeBillPayment TransactionType = "bill_payment"
)

func (TransactionType) IsKnown 

func (r TransactionType) IsKnown() bool

type TransactionUpdateNotesParams 

type TransactionUpdateNotesParams struct {
	// The personal notes to add or update for the transaction.
	Notes param.Field[interface{}] `json:"notes,required"`
}

func (TransactionUpdateNotesParams) MarshalJSON 

func (r TransactionUpdateNotesParams) MarshalJSON() (data []byte, err error)

type User 

type User struct {
	// Unique identifier for the user.
	ID interface{} `json:"id,required"`
	// Primary email address of the user.
	Email interface{} `json:"email,required"`
	// Indicates if the user's identity has been verified (e.g., via KYC).
	IdentityVerified interface{} `json:"identityVerified,required"`
	// Full name of the user.
	Name    interface{} `json:"name,required"`
	Address Address     `json:"address"`
	// AI-identified financial persona for tailored advice.
	AIPersona interface{} `json:"aiPersona"`
	// Date of birth of the user (YYYY-MM-DD).
	DateOfBirth interface{} `json:"dateOfBirth"`
	// Current gamification level.
	GamificationLevel interface{} `json:"gamificationLevel"`
	// Current balance of loyalty points.
	LoyaltyPoints interface{} `json:"loyaltyPoints"`
	// Current loyalty program tier.
	LoyaltyTier interface{} `json:"loyaltyTier"`
	// Primary phone number of the user.
	Phone interface{} `json:"phone"`
	// User's personalized preferences for the platform.
	Preferences UserPreferences `json:"preferences"`
	// Security-related status for the user account.
	SecurityStatus UserSecurityStatus `json:"securityStatus"`
	JSON           userJSON           `json:"-"`
}

func (*User) UnmarshalJSON 

func (r *User) UnmarshalJSON(data []byte) (err error)

type UserLoginParams 

type UserLoginParams struct {
	// User's email address.
	Email param.Field[interface{}] `json:"email,required"`
	// User's password.
	Password param.Field[interface{}] `json:"password,required"`
	// Optional: Multi-factor authentication code, if required.
	MfaCode param.Field[interface{}] `json:"mfaCode"`
}

func (UserLoginParams) MarshalJSON 

func (r UserLoginParams) MarshalJSON() (data []byte, err error)

type UserLoginResponse 

type UserLoginResponse struct {
	// JWT access token to authenticate subsequent API requests.
	AccessToken interface{} `json:"accessToken,required"`
	// Lifetime of the access token in seconds.
	ExpiresIn interface{} `json:"expiresIn,required"`
	// Token used to obtain new access tokens without re-authenticating.
	RefreshToken interface{} `json:"refreshToken,required"`
	// Type of the access token.
	TokenType interface{}           `json:"tokenType,required"`
	JSON      userLoginResponseJSON `json:"-"`
}

func (*UserLoginResponse) UnmarshalJSON 

func (r *UserLoginResponse) UnmarshalJSON(data []byte) (err error)

type UserMeBiometricEnrollParams 

type UserMeBiometricEnrollParams struct {
	// Base64 encoded representation of the biometric template or proof.
	BiometricSignature param.Field[interface{}] `json:"biometricSignature,required"`
	// The type of biometric data being enrolled.
	BiometricType param.Field[UserMeBiometricEnrollParamsBiometricType] `json:"biometricType,required"`
	// The ID of the device on which the biometric is being enrolled.
	DeviceID param.Field[interface{}] `json:"deviceId,required"`
	// Optional: A friendly name for the device, if not already linked.
	DeviceName param.Field[interface{}] `json:"deviceName"`
}

func (UserMeBiometricEnrollParams) MarshalJSON 

func (r UserMeBiometricEnrollParams) MarshalJSON() (data []byte, err error)

type UserMeBiometricEnrollParamsBiometricType 

type UserMeBiometricEnrollParamsBiometricType string

The type of biometric data being enrolled. 

const (
	UserMeBiometricEnrollParamsBiometricTypeFingerprint       UserMeBiometricEnrollParamsBiometricType = "fingerprint"
	UserMeBiometricEnrollParamsBiometricTypeFacialRecognition UserMeBiometricEnrollParamsBiometricType = "facial_recognition"
	UserMeBiometricEnrollParamsBiometricTypeVoiceRecognition  UserMeBiometricEnrollParamsBiometricType = "voice_recognition"
)

func (UserMeBiometricEnrollParamsBiometricType) IsKnown 

func (r UserMeBiometricEnrollParamsBiometricType) IsKnown() bool

type UserMeBiometricService 

type UserMeBiometricService struct {
	Options []option.RequestOption
}

UserMeBiometricService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserMeBiometricService method instead.

func NewUserMeBiometricService 

func NewUserMeBiometricService(opts ...option.RequestOption) (r *UserMeBiometricService)

NewUserMeBiometricService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserMeBiometricService) Deregister 

func (r *UserMeBiometricService) Deregister(ctx context.Context, opts ...option.RequestOption) (err error)

Removes all enrolled biometric data associated with the user's account for security reasons.

func (*UserMeBiometricService) Enroll 

func (r *UserMeBiometricService) Enroll(ctx context.Context, body UserMeBiometricEnrollParams, opts ...option.RequestOption) (res *BiometricStatus, err error)

Initiates the enrollment process for biometric authentication (e.g., fingerprint, facial scan) to enable secure and convenient access to sensitive features. Requires a biometric signature for initial proof.

func (*UserMeBiometricService) Status 

func (r *UserMeBiometricService) Status(ctx context.Context, opts ...option.RequestOption) (res *BiometricStatus, err error)

Retrieves the current status of biometric enrollments for the authenticated user.

func (*UserMeBiometricService) Verify 

func (r *UserMeBiometricService) Verify(ctx context.Context, body UserMeBiometricVerifyParams, opts ...option.RequestOption) (res *UserMeBiometricVerifyResponse, err error)

Performs real-time biometric verification to authorize sensitive actions or access protected resources, using a one-time biometric signature.

type UserMeBiometricVerifyParams 

type UserMeBiometricVerifyParams struct {
	// Base64 encoded representation of the one-time biometric proof for verification.
	BiometricSignature param.Field[interface{}] `json:"biometricSignature,required"`
	// The type of biometric data being verified.
	BiometricType param.Field[UserMeBiometricVerifyParamsBiometricType] `json:"biometricType,required"`
	// The ID of the device initiating the biometric verification.
	DeviceID param.Field[interface{}] `json:"deviceId,required"`
}

func (UserMeBiometricVerifyParams) MarshalJSON 

func (r UserMeBiometricVerifyParams) MarshalJSON() (data []byte, err error)

type UserMeBiometricVerifyParamsBiometricType 

type UserMeBiometricVerifyParamsBiometricType string

The type of biometric data being verified. 

const (
	UserMeBiometricVerifyParamsBiometricTypeFingerprint       UserMeBiometricVerifyParamsBiometricType = "fingerprint"
	UserMeBiometricVerifyParamsBiometricTypeFacialRecognition UserMeBiometricVerifyParamsBiometricType = "facial_recognition"
	UserMeBiometricVerifyParamsBiometricTypeVoiceRecognition  UserMeBiometricVerifyParamsBiometricType = "voice_recognition"
)

func (UserMeBiometricVerifyParamsBiometricType) IsKnown 

func (r UserMeBiometricVerifyParamsBiometricType) IsKnown() bool

type UserMeBiometricVerifyResponse 

type UserMeBiometricVerifyResponse struct {
	// A descriptive message for the verification result.
	Message interface{} `json:"message"`
	// Status of the biometric verification.
	VerificationStatus UserMeBiometricVerifyResponseVerificationStatus `json:"verificationStatus"`
	JSON               userMeBiometricVerifyResponseJSON               `json:"-"`
}

func (*UserMeBiometricVerifyResponse) UnmarshalJSON 

func (r *UserMeBiometricVerifyResponse) UnmarshalJSON(data []byte) (err error)

type UserMeBiometricVerifyResponseVerificationStatus 

type UserMeBiometricVerifyResponseVerificationStatus string

Status of the biometric verification. 

const (
	UserMeBiometricVerifyResponseVerificationStatusSuccess UserMeBiometricVerifyResponseVerificationStatus = "success"
	UserMeBiometricVerifyResponseVerificationStatusFailed  UserMeBiometricVerifyResponseVerificationStatus = "failed"
)

func (UserMeBiometricVerifyResponseVerificationStatus) IsKnown 

func (r UserMeBiometricVerifyResponseVerificationStatus) IsKnown() bool

type UserMeDeviceListParams 

type UserMeDeviceListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (UserMeDeviceListParams) URLQuery 

func (r UserMeDeviceListParams) URLQuery() (v url.Values)

URLQuery serializes UserMeDeviceListParams's query parameters as `url.Values`.

type UserMeDeviceListResponse 

type UserMeDeviceListResponse struct {
	Data []Device                     `json:"data"`
	JSON userMeDeviceListResponseJSON `json:"-"`
	PaginatedList
}

func (*UserMeDeviceListResponse) UnmarshalJSON 

func (r *UserMeDeviceListResponse) UnmarshalJSON(data []byte) (err error)

type UserMeDeviceRegisterParams 

type UserMeDeviceRegisterParams struct {
	// Type of the device being registered.
	DeviceType param.Field[UserMeDeviceRegisterParamsDeviceType] `json:"deviceType,required"`
	// Model of the device.
	Model param.Field[interface{}] `json:"model,required"`
	// Operating system of the device.
	Os param.Field[interface{}] `json:"os,required"`
	// Optional: Base64 encoded biometric signature for initial enrollment (e.g., for
	// Passkey registration).
	BiometricSignature param.Field[interface{}] `json:"biometricSignature"`
	// Optional: A friendly name for the device.
	DeviceName param.Field[interface{}] `json:"deviceName"`
	// Optional: Push notification token for the device.
	PushToken param.Field[interface{}] `json:"pushToken"`
}

func (UserMeDeviceRegisterParams) MarshalJSON 

func (r UserMeDeviceRegisterParams) MarshalJSON() (data []byte, err error)

type UserMeDeviceRegisterParamsDeviceType 

type UserMeDeviceRegisterParamsDeviceType string

Type of the device being registered. 

const (
	UserMeDeviceRegisterParamsDeviceTypeMobile     UserMeDeviceRegisterParamsDeviceType = "mobile"
	UserMeDeviceRegisterParamsDeviceTypeDesktop    UserMeDeviceRegisterParamsDeviceType = "desktop"
	UserMeDeviceRegisterParamsDeviceTypeTablet     UserMeDeviceRegisterParamsDeviceType = "tablet"
	UserMeDeviceRegisterParamsDeviceTypeSmartWatch UserMeDeviceRegisterParamsDeviceType = "smart_watch"
)

func (UserMeDeviceRegisterParamsDeviceType) IsKnown 

func (r UserMeDeviceRegisterParamsDeviceType) IsKnown() bool

type UserMeDeviceService 

type UserMeDeviceService struct {
	Options []option.RequestOption
}

UserMeDeviceService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserMeDeviceService method instead.

func NewUserMeDeviceService 

func NewUserMeDeviceService(opts ...option.RequestOption) (r *UserMeDeviceService)

NewUserMeDeviceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserMeDeviceService) Deregister 

func (r *UserMeDeviceService) Deregister(ctx context.Context, deviceID interface{}, opts ...option.RequestOption) (err error)

Removes a specific device from the user's linked devices, revoking its access and requiring re-registration for future use. Useful for lost or compromised devices.

func (*UserMeDeviceService) List 

func (r *UserMeDeviceService) List(ctx context.Context, query UserMeDeviceListParams, opts ...option.RequestOption) (res *UserMeDeviceListResponse, err error)

Retrieves a list of all devices linked to the user's account, including mobile phones, tablets, and desktops, indicating their last active status and security posture.

func (*UserMeDeviceService) Register 

func (r *UserMeDeviceService) Register(ctx context.Context, body UserMeDeviceRegisterParams, opts ...option.RequestOption) (res *Device, err error)

Registers a new device for secure access and multi-factor authentication, associating it with the user's profile. This typically initiates a biometric or MFA enrollment flow.

type UserMePreferenceService 

type UserMePreferenceService struct {
	Options []option.RequestOption
}

UserMePreferenceService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserMePreferenceService method instead.

func NewUserMePreferenceService 

func NewUserMePreferenceService(opts ...option.RequestOption) (r *UserMePreferenceService)

NewUserMePreferenceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserMePreferenceService) Get 

func (r *UserMePreferenceService) Get(ctx context.Context, opts ...option.RequestOption) (res *UserPreferences, err error)

Retrieves the user's deep personalization preferences, including AI customization settings, notification channel priorities, thematic choices, and data sharing consents.

func (*UserMePreferenceService) Update 

func (r *UserMePreferenceService) Update(ctx context.Context, body UserMePreferenceUpdateParams, opts ...option.RequestOption) (res *UserPreferences, err error)

Updates the user's deep personalization preferences, allowing dynamic control over AI behavior, notification delivery, thematic choices, and data privacy settings.

type UserMePreferenceUpdateParams 

type UserMePreferenceUpdateParams struct {
	// User's personalized preferences for the platform.
	UserPreferences UserPreferencesParam `json:"user_preferences,required"`
}

func (UserMePreferenceUpdateParams) MarshalJSON 

func (r UserMePreferenceUpdateParams) MarshalJSON() (data []byte, err error)

type UserMeService 

type UserMeService struct {
	Options     []option.RequestOption
	Preferences *UserMePreferenceService
	Devices     *UserMeDeviceService
	Biometrics  *UserMeBiometricService
}

UserMeService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserMeService method instead.

func NewUserMeService 

func NewUserMeService(opts ...option.RequestOption) (r *UserMeService)

NewUserMeService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserMeService) Get 

func (r *UserMeService) Get(ctx context.Context, opts ...option.RequestOption) (res *User, err error)

Fetches the complete and dynamically updated profile information for the currently authenticated user, encompassing personal details, security status, gamification level, loyalty points, and linked identity attributes.

func (*UserMeService) Update 

func (r *UserMeService) Update(ctx context.Context, body UserMeUpdateParams, opts ...option.RequestOption) (res *User, err error)

Updates selected fields of the currently authenticated user's profile information.

type UserMeUpdateParams 

type UserMeUpdateParams struct {
	Address param.Field[AddressParam] `json:"address"`
	// Updated full name of the user.
	Name param.Field[interface{}] `json:"name"`
	// Updated primary phone number of the user.
	Phone param.Field[interface{}] `json:"phone"`
	// User's personalized preferences for the platform.
	Preferences param.Field[UserPreferencesParam] `json:"preferences"`
}

func (UserMeUpdateParams) MarshalJSON 

func (r UserMeUpdateParams) MarshalJSON() (data []byte, err error)

type UserPasswordResetConfirmParams 

type UserPasswordResetConfirmParams struct {
	// User's email or phone number used for verification.
	Identifier param.Field[interface{}] `json:"identifier,required"`
	// The new password for the user account.
	NewPassword param.Field[interface{}] `json:"newPassword,required"`
	// The verification code received via email or SMS.
	VerificationCode param.Field[interface{}] `json:"verificationCode,required"`
}

func (UserPasswordResetConfirmParams) MarshalJSON 

func (r UserPasswordResetConfirmParams) MarshalJSON() (data []byte, err error)

type UserPasswordResetConfirmResponse 

type UserPasswordResetConfirmResponse struct {
	Message interface{}                          `json:"message"`
	JSON    userPasswordResetConfirmResponseJSON `json:"-"`
}

func (*UserPasswordResetConfirmResponse) UnmarshalJSON 

func (r *UserPasswordResetConfirmResponse) UnmarshalJSON(data []byte) (err error)

type UserPasswordResetInitiateParams 

type UserPasswordResetInitiateParams struct {
	// User's email or phone number for verification.
	Identifier param.Field[interface{}] `json:"identifier,required"`
}

func (UserPasswordResetInitiateParams) MarshalJSON 

func (r UserPasswordResetInitiateParams) MarshalJSON() (data []byte, err error)

type UserPasswordResetInitiateResponse 

type UserPasswordResetInitiateResponse struct {
	Message interface{}                           `json:"message"`
	JSON    userPasswordResetInitiateResponseJSON `json:"-"`
}

func (*UserPasswordResetInitiateResponse) UnmarshalJSON 

func (r *UserPasswordResetInitiateResponse) UnmarshalJSON(data []byte) (err error)

type UserPasswordResetService 

type UserPasswordResetService struct {
	Options []option.RequestOption
}

UserPasswordResetService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserPasswordResetService method instead.

func NewUserPasswordResetService 

func NewUserPasswordResetService(opts ...option.RequestOption) (r *UserPasswordResetService)

NewUserPasswordResetService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserPasswordResetService) Confirm 

func (r *UserPasswordResetService) Confirm(ctx context.Context, body UserPasswordResetConfirmParams, opts ...option.RequestOption) (res *UserPasswordResetConfirmResponse, err error)

Confirms the password reset using the received verification code and sets a new password.

func (*UserPasswordResetService) Initiate 

func (r *UserPasswordResetService) Initiate(ctx context.Context, body UserPasswordResetInitiateParams, opts ...option.RequestOption) (res *UserPasswordResetInitiateResponse, err error)

Starts the password reset flow by sending a verification code or link to the user's registered email or phone.

type UserPreferences 

type UserPreferences struct {
	// How the user prefers to interact with AI (proactive advice, balanced, or only on
	// demand).
	AIInteractionMode UserPreferencesAIInteractionMode `json:"aiInteractionMode"`
	// Consent status for sharing anonymized data for AI improvement and personalized
	// offers.
	DataSharingConsent interface{} `json:"dataSharingConsent"`
	// Preferred channels for receiving notifications.
	NotificationChannels UserPreferencesNotificationChannels `json:"notificationChannels"`
	// Preferred language for the user interface.
	PreferredLanguage interface{} `json:"preferredLanguage"`
	// Preferred UI theme (e.g., Light-Default, Dark-Quantum).
	Theme interface{} `json:"theme"`
	// Default grouping preference for transaction lists.
	TransactionGrouping UserPreferencesTransactionGrouping `json:"transactionGrouping"`
	JSON                userPreferencesJSON                `json:"-"`
}

User's personalized preferences for the platform.

func (*UserPreferences) UnmarshalJSON 

func (r *UserPreferences) UnmarshalJSON(data []byte) (err error)

type UserPreferencesAIInteractionMode 

type UserPreferencesAIInteractionMode string

How the user prefers to interact with AI (proactive advice, balanced, or only on demand). 

const (
	UserPreferencesAIInteractionModeProactive UserPreferencesAIInteractionMode = "proactive"
	UserPreferencesAIInteractionModeBalanced  UserPreferencesAIInteractionMode = "balanced"
	UserPreferencesAIInteractionModeOnDemand  UserPreferencesAIInteractionMode = "on_demand"
)

func (UserPreferencesAIInteractionMode) IsKnown 

func (r UserPreferencesAIInteractionMode) IsKnown() bool

type UserPreferencesNotificationChannels 

type UserPreferencesNotificationChannels struct {
	Email interface{}                             `json:"email"`
	InApp interface{}                             `json:"inApp"`
	Push  interface{}                             `json:"push"`
	SMS   interface{}                             `json:"sms"`
	JSON  userPreferencesNotificationChannelsJSON `json:"-"`
}

Preferred channels for receiving notifications.

func (*UserPreferencesNotificationChannels) UnmarshalJSON 

func (r *UserPreferencesNotificationChannels) UnmarshalJSON(data []byte) (err error)

type UserPreferencesNotificationChannelsParam 

type UserPreferencesNotificationChannelsParam struct {
	Email param.Field[interface{}] `json:"email"`
	InApp param.Field[interface{}] `json:"inApp"`
	Push  param.Field[interface{}] `json:"push"`
	SMS   param.Field[interface{}] `json:"sms"`
}

Preferred channels for receiving notifications.

func (UserPreferencesNotificationChannelsParam) MarshalJSON 

func (r UserPreferencesNotificationChannelsParam) MarshalJSON() (data []byte, err error)

type UserPreferencesParam 

type UserPreferencesParam struct {
	// How the user prefers to interact with AI (proactive advice, balanced, or only on
	// demand).
	AIInteractionMode param.Field[UserPreferencesAIInteractionMode] `json:"aiInteractionMode"`
	// Consent status for sharing anonymized data for AI improvement and personalized
	// offers.
	DataSharingConsent param.Field[interface{}] `json:"dataSharingConsent"`
	// Preferred channels for receiving notifications.
	NotificationChannels param.Field[UserPreferencesNotificationChannelsParam] `json:"notificationChannels"`
	// Preferred language for the user interface.
	PreferredLanguage param.Field[interface{}] `json:"preferredLanguage"`
	// Preferred UI theme (e.g., Light-Default, Dark-Quantum).
	Theme param.Field[interface{}] `json:"theme"`
	// Default grouping preference for transaction lists.
	TransactionGrouping param.Field[UserPreferencesTransactionGrouping] `json:"transactionGrouping"`
}

User's personalized preferences for the platform.

func (UserPreferencesParam) MarshalJSON 

func (r UserPreferencesParam) MarshalJSON() (data []byte, err error)

type UserPreferencesTransactionGrouping 

type UserPreferencesTransactionGrouping string

Default grouping preference for transaction lists. 

const (
	UserPreferencesTransactionGroupingCategory UserPreferencesTransactionGrouping = "category"
	UserPreferencesTransactionGroupingMerchant UserPreferencesTransactionGrouping = "merchant"
	UserPreferencesTransactionGroupingDate     UserPreferencesTransactionGrouping = "date"
	UserPreferencesTransactionGroupingAccount  UserPreferencesTransactionGrouping = "account"
)

func (UserPreferencesTransactionGrouping) IsKnown 

func (r UserPreferencesTransactionGrouping) IsKnown() bool

type UserRegisterParams 

type UserRegisterParams struct {
	// Email address for registration and login.
	Email param.Field[interface{}] `json:"email,required"`
	// Full name of the user.
	Name param.Field[interface{}] `json:"name,required"`
	// User's chosen password.
	Password param.Field[interface{}]  `json:"password,required"`
	Address  param.Field[AddressParam] `json:"address"`
	// Optional date of birth (YYYY-MM-DD).
	DateOfBirth param.Field[interface{}] `json:"dateOfBirth"`
	// Optional phone number for MFA or recovery.
	Phone param.Field[interface{}] `json:"phone"`
}

func (UserRegisterParams) MarshalJSON 

func (r UserRegisterParams) MarshalJSON() (data []byte, err error)

type UserSecurityStatus 

type UserSecurityStatus struct {
	// Indicates if biometric authentication is enrolled.
	BiometricsEnrolled interface{} `json:"biometricsEnrolled"`
	// Timestamp of the last successful login.
	LastLogin interface{} `json:"lastLogin"`
	// IP address of the last successful login.
	LastLoginIP interface{} `json:"lastLoginIp"`
	// Indicates if two-factor authentication (2FA) is enabled.
	TwoFactorEnabled interface{}            `json:"twoFactorEnabled"`
	JSON             userSecurityStatusJSON `json:"-"`
}

Security-related status for the user account.

func (*UserSecurityStatus) UnmarshalJSON 

func (r *UserSecurityStatus) UnmarshalJSON(data []byte) (err error)

type UserService 

type UserService struct {
	Options       []option.RequestOption
	PasswordReset *UserPasswordResetService
	Me            *UserMeService
}

UserService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserService method instead.

func NewUserService 

func NewUserService(opts ...option.RequestOption) (r *UserService)

NewUserService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserService) Login 

func (r *UserService) Login(ctx context.Context, body UserLoginParams, opts ...option.RequestOption) (res *UserLoginResponse, err error)

Authenticates a user and creates a secure session, returning access tokens. May require MFA depending on user settings.

func (*UserService) Register 

func (r *UserService) Register(ctx context.Context, body UserRegisterParams, opts ...option.RequestOption) (res *User, err error)

Registers a new user account with , initiating the onboarding process. Requires basic user details.

type VideoOperationStatus 

type VideoOperationStatus struct {
	// A descriptive status message.
	Message interface{} `json:"message,required"`
	// The unique identifier for the video generation operation.
	OperationID interface{} `json:"operationId,required"`
	// Estimated completion percentage (0-100).
	ProgressPercentage interface{} `json:"progressPercentage,required"`
	// Current status of the video generation job.
	Status VideoOperationStatusStatus `json:"status,required"`
	// Error message if the operation failed.
	ErrorMessage interface{} `json:"errorMessage"`
	// Temporary, signed URL to a preview image/thumbnail of the video.
	PreviewImageUri interface{} `json:"previewImageUri"`
	// Temporary, signed URL to the generated video asset (available when status is
	// 'done').
	VideoUri interface{}              `json:"videoUri"`
	JSON     videoOperationStatusJSON `json:"-"`
}

func (*VideoOperationStatus) UnmarshalJSON 

func (r *VideoOperationStatus) UnmarshalJSON(data []byte) (err error)

type VideoOperationStatusStatus 

type VideoOperationStatusStatus string

Current status of the video generation job. 

const (
	VideoOperationStatusStatusQueued     VideoOperationStatusStatus = "queued"
	VideoOperationStatusStatusGenerating VideoOperationStatusStatus = "generating"
	VideoOperationStatusStatusRendering  VideoOperationStatusStatus = "rendering"
	VideoOperationStatusStatusDone       VideoOperationStatusStatus = "done"
	VideoOperationStatusStatusError      VideoOperationStatusStatus = "error"
)

func (VideoOperationStatusStatus) IsKnown 

func (r VideoOperationStatusStatus) IsKnown() bool

type Web3GetNFTsParams 

type Web3GetNFTsParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (Web3GetNFTsParams) URLQuery 

func (r Web3GetNFTsParams) URLQuery() (v url.Values)

URLQuery serializes Web3GetNFTsParams's query parameters as `url.Values`.

type Web3GetNFTsResponse 

type Web3GetNFTsResponse struct {
	Data []Web3GetNFTsResponseData `json:"data"`
	JSON web3GetNFTsResponseJSON   `json:"-"`
	PaginatedList
}

func (*Web3GetNFTsResponse) UnmarshalJSON 

func (r *Web3GetNFTsResponse) UnmarshalJSON(data []byte) (err error)

type Web3GetNFTsResponseData 

type Web3GetNFTsResponseData struct {
	// Unique identifier for the NFT within the system.
	ID interface{} `json:"id,required"`
	// Blockchain network on which the NFT exists.
	BlockchainNetwork interface{} `json:"blockchainNetwork,required"`
	// Name of the NFT collection.
	CollectionName interface{} `json:"collectionName,required"`
	// Blockchain contract address of the NFT collection.
	ContractAddress interface{} `json:"contractAddress,required"`
	// URL to the NFT's image.
	ImageURL interface{} `json:"imageUrl,required"`
	// Name of the specific NFT.
	Name interface{} `json:"name,required"`
	// Blockchain address of the current owner.
	OwnerAddress interface{} `json:"ownerAddress,required"`
	// Unique ID of the token within its contract.
	TokenID interface{} `json:"tokenId,required"`
	// Key-value attributes of the NFT (e.g., rarity traits).
	Attributes []Web3GetNFTsResponseDataAttribute `json:"attributes,nullable"`
	// Description of the NFT.
	Description interface{} `json:"description"`
	// AI-estimated current market value in USD.
	EstimatedValueUsd interface{} `json:"estimatedValueUSD"`
	// Last known sale price in USD.
	LastSalePriceUsd interface{}                 `json:"lastSalePriceUSD"`
	JSON             web3GetNFTsResponseDataJSON `json:"-"`
}

func (*Web3GetNFTsResponseData) UnmarshalJSON 

func (r *Web3GetNFTsResponseData) UnmarshalJSON(data []byte) (err error)

type Web3GetNFTsResponseDataAttribute 

type Web3GetNFTsResponseDataAttribute struct {
	TraitType interface{}                          `json:"trait_type"`
	Value     interface{}                          `json:"value"`
	JSON      web3GetNFTsResponseDataAttributeJSON `json:"-"`
}

func (*Web3GetNFTsResponseDataAttribute) UnmarshalJSON 

func (r *Web3GetNFTsResponseDataAttribute) UnmarshalJSON(data []byte) (err error)

type Web3Service 

type Web3Service struct {
	Options      []option.RequestOption
	Wallets      *Web3WalletService
	Transactions *Web3TransactionService
}

Web3Service contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWeb3Service method instead.

func NewWeb3Service 

func NewWeb3Service(opts ...option.RequestOption) (r *Web3Service)

NewWeb3Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*Web3Service) GetNFTs 

func (r *Web3Service) GetNFTs(ctx context.Context, query Web3GetNFTsParams, opts ...option.RequestOption) (res *Web3GetNFTsResponse, err error)

Fetches a comprehensive list of Non-Fungible Tokens (NFTs) owned by the user across all connected wallets and supported blockchain networks, including metadata and market values.

type Web3TransactionInitiateTransferParams 

type Web3TransactionInitiateTransferParams struct {
	// The amount of cryptocurrency to transfer.
	Amount param.Field[interface{}] `json:"amount,required"`
	// Symbol of the crypto asset to transfer (e.g., ETH, USDC).
	AssetSymbol param.Field[interface{}] `json:"assetSymbol,required"`
	// The blockchain network for the transfer.
	BlockchainNetwork param.Field[interface{}] `json:"blockchainNetwork,required"`
	// The recipient's blockchain address.
	RecipientAddress param.Field[interface{}] `json:"recipientAddress,required"`
	// ID of the connected wallet from which to send funds.
	SourceWalletID param.Field[interface{}] `json:"sourceWalletId,required"`
	// Optional: Gas price in Gwei for Ethereum-based transactions.
	GasPriceGwei param.Field[interface{}] `json:"gasPriceGwei"`
	// Optional: A short memo or note for the transaction.
	Memo param.Field[interface{}] `json:"memo"`
}

func (Web3TransactionInitiateTransferParams) MarshalJSON 

func (r Web3TransactionInitiateTransferParams) MarshalJSON() (data []byte, err error)

type Web3TransactionInitiateTransferResponse 

type Web3TransactionInitiateTransferResponse struct {
	// Current status of the transfer.
	Status Web3TransactionInitiateTransferResponseStatus `json:"status,required"`
	// Unique identifier for this cryptocurrency transfer operation.
	TransferID interface{} `json:"transferId,required"`
	// The blockchain transaction hash, if available and confirmed.
	BlockchainTxnHash interface{} `json:"blockchainTxnHash"`
	// A descriptive message about the transfer status.
	Message interface{}                                 `json:"message"`
	JSON    web3TransactionInitiateTransferResponseJSON `json:"-"`
}

func (*Web3TransactionInitiateTransferResponse) UnmarshalJSON 

func (r *Web3TransactionInitiateTransferResponse) UnmarshalJSON(data []byte) (err error)

type Web3TransactionInitiateTransferResponseStatus 

type Web3TransactionInitiateTransferResponseStatus string

Current status of the transfer. 

const (
	Web3TransactionInitiateTransferResponseStatusPendingSignature              Web3TransactionInitiateTransferResponseStatus = "pending_signature"
	Web3TransactionInitiateTransferResponseStatusPendingBlockchainConfirmation Web3TransactionInitiateTransferResponseStatus = "pending_blockchain_confirmation"
	Web3TransactionInitiateTransferResponseStatusCompleted                     Web3TransactionInitiateTransferResponseStatus = "completed"
	Web3TransactionInitiateTransferResponseStatusFailed                        Web3TransactionInitiateTransferResponseStatus = "failed"
	Web3TransactionInitiateTransferResponseStatusCancelled                     Web3TransactionInitiateTransferResponseStatus = "cancelled"
)

func (Web3TransactionInitiateTransferResponseStatus) IsKnown 

func (r Web3TransactionInitiateTransferResponseStatus) IsKnown() bool

type Web3TransactionService 

type Web3TransactionService struct {
	Options []option.RequestOption
}

Web3TransactionService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWeb3TransactionService method instead.

func NewWeb3TransactionService 

func NewWeb3TransactionService(opts ...option.RequestOption) (r *Web3TransactionService)

NewWeb3TransactionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*Web3TransactionService) InitiateTransfer 

func (r *Web3TransactionService) InitiateTransfer(ctx context.Context, body Web3TransactionInitiateTransferParams, opts ...option.RequestOption) (res *Web3TransactionInitiateTransferResponse, err error)

Prepares and initiates a cryptocurrency transfer from a connected wallet to a specified recipient address. Requires user confirmation (e.g., via wallet signature).

type Web3WalletConnectParams 

type Web3WalletConnectParams struct {
	// The blockchain network for this wallet (e.g., Ethereum, Solana).
	BlockchainNetwork param.Field[interface{}] `json:"blockchainNetwork,required"`
	// A message cryptographically signed by the wallet owner to prove
	// ownership/intent.
	SignedMessage param.Field[interface{}] `json:"signedMessage,required"`
	// The public address of the cryptocurrency wallet.
	WalletAddress param.Field[interface{}] `json:"walletAddress,required"`
	// The name of the wallet provider (e.g., MetaMask, Phantom).
	WalletProvider param.Field[interface{}] `json:"walletProvider,required"`
	// If true, requests write access to initiate transactions from this wallet.
	RequestWriteAccess param.Field[interface{}] `json:"requestWriteAccess"`
}

func (Web3WalletConnectParams) MarshalJSON 

func (r Web3WalletConnectParams) MarshalJSON() (data []byte, err error)

type Web3WalletGetBalancesParams 

type Web3WalletGetBalancesParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (Web3WalletGetBalancesParams) URLQuery 

func (r Web3WalletGetBalancesParams) URLQuery() (v url.Values)

URLQuery serializes Web3WalletGetBalancesParams's query parameters as `url.Values`.

type Web3WalletGetBalancesResponse 

type Web3WalletGetBalancesResponse struct {
	Data []Web3WalletGetBalancesResponseData `json:"data"`
	JSON web3WalletGetBalancesResponseJSON   `json:"-"`
	PaginatedList
}

func (*Web3WalletGetBalancesResponse) UnmarshalJSON 

func (r *Web3WalletGetBalancesResponse) UnmarshalJSON(data []byte) (err error)

type Web3WalletGetBalancesResponseData 

type Web3WalletGetBalancesResponseData struct {
	// Full name of the crypto asset.
	AssetName interface{} `json:"assetName,required"`
	// Symbol of the crypto asset (e.g., ETH, BTC, USDC).
	AssetSymbol interface{} `json:"assetSymbol,required"`
	// Current balance of the asset in the wallet.
	Balance interface{} `json:"balance,required"`
	// Current USD value of the asset balance.
	UsdValue interface{} `json:"usdValue,required"`
	// The contract address for ERC-20 tokens or similar.
	ContractAddress interface{} `json:"contractAddress"`
	// The blockchain network the asset resides on (if different from wallet's
	// primary).
	Network interface{}                           `json:"network"`
	JSON    web3WalletGetBalancesResponseDataJSON `json:"-"`
}

func (*Web3WalletGetBalancesResponseData) UnmarshalJSON 

func (r *Web3WalletGetBalancesResponseData) UnmarshalJSON(data []byte) (err error)

type Web3WalletListParams 

type Web3WalletListParams struct {
	// Maximum number of items to return in a single page.
	Limit param.Field[interface{}] `query:"limit"`
	// Number of items to skip before starting to collect the result set.
	Offset param.Field[interface{}] `query:"offset"`
}

func (Web3WalletListParams) URLQuery 

func (r Web3WalletListParams) URLQuery() (v url.Values)

URLQuery serializes Web3WalletListParams's query parameters as `url.Values`.

type Web3WalletListResponse 

type Web3WalletListResponse struct {
	Data []CryptoWalletConnection   `json:"data"`
	JSON web3WalletListResponseJSON `json:"-"`
	PaginatedList
}

func (*Web3WalletListResponse) UnmarshalJSON 

func (r *Web3WalletListResponse) UnmarshalJSON(data []byte) (err error)

type Web3WalletService 

type Web3WalletService struct {
	Options []option.RequestOption
}

Web3WalletService contains methods and other services that help with interacting with the jocall3 API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWeb3WalletService method instead.

func NewWeb3WalletService 

func NewWeb3WalletService(opts ...option.RequestOption) (r *Web3WalletService)

NewWeb3WalletService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*Web3WalletService) Connect 

func (r *Web3WalletService) Connect(ctx context.Context, body Web3WalletConnectParams, opts ...option.RequestOption) (res *CryptoWalletConnection, err error)

Initiates the process to securely connect a new cryptocurrency wallet to the user's profile, typically involving a signed message or OAuth flow from the wallet provider.

func (*Web3WalletService) GetBalances 

func (r *Web3WalletService) GetBalances(ctx context.Context, walletID interface{}, query Web3WalletGetBalancesParams, opts ...option.RequestOption) (res *Web3WalletGetBalancesResponse, err error)

Retrieves the current balances of all recognized crypto assets within a specific connected wallet.

func (*Web3WalletService) List 

func (r *Web3WalletService) List(ctx context.Context, query Web3WalletListParams, opts ...option.RequestOption) (res *Web3WalletListResponse, err error)

Retrieves a list of all securely linked cryptocurrency wallets (e.g., MetaMask, Ledger integration), showing their addresses, associated networks, and verification status.

type WebhookSubscription 

type WebhookSubscription struct {
	// Unique identifier for the webhook subscription.
	ID interface{} `json:"id,required"`
	// The URL where webhook events will be sent.
	CallbackURL interface{} `json:"callbackUrl,required"`
	// Timestamp when the subscription was created.
	CreatedAt interface{} `json:"createdAt,required"`
	// List of event types subscribed to.
	Events []interface{} `json:"events,required"`
	// Current status of the webhook subscription.
	Status WebhookSubscriptionStatus `json:"status,required"`
	// Number of consecutive failed delivery attempts.
	FailureCount interface{} `json:"failureCount"`
	// Timestamp of the last successful webhook delivery.
	LastTriggered interface{} `json:"lastTriggered"`
	// The shared secret used to sign webhook payloads, for verification. Only returned
	// on creation.
	Secret interface{}             `json:"secret"`
	JSON   webhookSubscriptionJSON `json:"-"`
}

func (*WebhookSubscription) UnmarshalJSON 

func (r *WebhookSubscription) UnmarshalJSON(data []byte) (err error)

type WebhookSubscriptionStatus 

type WebhookSubscriptionStatus string

Current status of the webhook subscription. 

const (
	WebhookSubscriptionStatusActive    WebhookSubscriptionStatus = "active"
	WebhookSubscriptionStatusPaused    WebhookSubscriptionStatus = "paused"
	WebhookSubscriptionStatusSuspended WebhookSubscriptionStatus = "suspended"
)

func (WebhookSubscriptionStatus) IsKnown 

func (r WebhookSubscriptionStatus) IsKnown() bool

Source Files

View all Source files

Directories

Path Synopsis
cmd
server command
api/handler
apierror
apiform
apijson
apiquery
config
domain/account
domain/ai
domain/budget
domain/corporate
domain/developer
domain/goal
domain/identity
domain/investment
domain/lending
domain/marketplace
Package marketplace contains the core domain entities and business logic for the marketplace context of the application.
 Package marketplace contains the core domain entities and business logic for the marketplace context of the application.
domain/notification
Package notification defines the core domain models for notifications and user settings.
 Package notification defines the core domain models for notifications and user settings.
domain/payment
domain/sustainability
domain/transaction
domain/user
domain/web3
param
platform/database
platform/errors
platform/server
requestconfig
service/account
service/ai
service/budget
service/corporate
service/developer
service/goal
service/identity
service/investment
service/lending
service/marketplace
Package marketplace provides the business logic for the marketplace feature, including listing products, simulating redemptions, and processing redemptions.
 Package marketplace provides the business logic for the marketplace feature, including listing products, simulating redemptions, and processing redemptions.
service/notification
service/payment
Package payment provides services related to payment processing, including foreign exchange, transaction handling, and account management.
 Package payment provides services related to payment processing, including foreign exchange, transaction handling, and account management.
service/sustainability
service/transaction
Package transaction provides service-level logic for handling financial transactions and insights.
 Package transaction provides service-level logic for handling financial transactions and insights.
service/user
service/web3
testutil
pkg
jocall3
Package jocall3 provides the client SDK for interacting with the JoCall v3 API.
 Package jocall3 provides the client SDK for interacting with the JoCall v3 API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.