micro

package module
v0.3.0 Latest Latest
Warning

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

 Go to latest Published: May 13, 2026 License: Apache-2.0 Imports: 16 Imported by: 0

README

Micro Go API Library

Go Reference

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

It is generated with Stainless.

MCP Server

Use the Micro MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.

Add to Cursor Install in VS Code

Note: You may need to set environment variables in your MCP client.

Installation

import (
	"github.com/micro-so/micro-sdk-go" // imported as micro
)

Or to pin the version:

go get -u 'github.com/micro-so/micro-sdk-go@v0.3.0'

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/micro-so/micro-sdk-go"
	"github.com/micro-so/micro-sdk-go/option"
)

func main() {
	client := micro.NewClient(
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("MICRO_API_KEY")
		option.WithTeamID("My Team ID"),
	)
	response, err := client.Prism.Objects.Deals.Query(context.TODO(), micro.PrismObjectDealQueryParams{
		Query: micro.F(micro.PrismObjectDealQueryParamsQuery{
			Select: micro.F([]string{"id", "name"}),
		}),
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Data)
}
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: micro.F("hello"),

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

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

		// In cases where the API specifies a given type,
		// but you want to send something else, use `Raw`:
		Z: micro.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 := micro.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Prism.Objects.Deals.Query(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 *micro.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.Prism.Objects.Deals.Query(context.TODO(), micro.PrismObjectDealQueryParams{
	Query: micro.F(micro.PrismObjectDealQueryParamsQuery{
		Select: micro.F([]string{"id", "name"}),
	}),
})
if err != nil {
	var apierr *micro.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 "/v2/prism/query/{teamId}/deal": 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.Prism.Objects.Deals.Query(
	ctx,
	micro.PrismObjectDealQueryParams{
		Query: micro.F(micro.PrismObjectDealQueryParamsQuery{
			Select: micro.F([]string{"id", "name"}),
		}),
	},
	// 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 micro.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 := micro.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Prism.Objects.Deals.Query(
	context.TODO(),
	micro.PrismObjectDealQueryParams{
		Query: micro.F(micro.PrismObjectDealQueryParamsQuery{
			Select: micro.F([]string{"id", "name"}),
		}),
	},
	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
response, err := client.Prism.Objects.Deals.Query(
	context.TODO(),
	micro.PrismObjectDealQueryParams{
		Query: micro.F(micro.PrismObjectDealQueryParamsQuery{
			Select: micro.F([]string{"id", "name"}),
		}),
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", response)

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:   micro.F("id_xxxx"),
    Data: micro.F(FooNewParamsData{
        FirstName: micro.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 := micro.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 (MICRO_API_KEY, MICRO_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 Client 

type Client struct {
	Options []option.RequestOption
	Prism   *PrismService
	Views   *ViewService
}

Client creates a struct with services and top level methods that help with interacting with the micro 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 (MICRO_API_KEY, MICRO_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 Error 

type Error = apierror.Error

type PrismMetadataListParams 

type PrismMetadataListParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID   param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	Autofill param.Field[bool]   `query:"autofill"`
	ListID   param.Field[string] `query:"listId" format:"uuid"`
	Term     param.Field[string] `query:"term"`
}

func (PrismMetadataListParams) URLQuery 

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

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

type PrismMetadataListParamsObjectType 

type PrismMetadataListParamsObjectType string
const (
	PrismMetadataListParamsObjectTypeDeal          PrismMetadataListParamsObjectType = "deal"
	PrismMetadataListParamsObjectTypeIdentity      PrismMetadataListParamsObjectType = "identity"
	PrismMetadataListParamsObjectTypeAIChatThread  PrismMetadataListParamsObjectType = "ai_chat_thread"
	PrismMetadataListParamsObjectTypeAIChatMessage PrismMetadataListParamsObjectType = "ai_chat_message"
	PrismMetadataListParamsObjectTypeDocument      PrismMetadataListParamsObjectType = "document"
	PrismMetadataListParamsObjectTypeAction        PrismMetadataListParamsObjectType = "action"
	PrismMetadataListParamsObjectTypeEvent         PrismMetadataListParamsObjectType = "event"
	PrismMetadataListParamsObjectTypeOrganization  PrismMetadataListParamsObjectType = "organization"
	PrismMetadataListParamsObjectTypeContact       PrismMetadataListParamsObjectType = "contact"
)

func (PrismMetadataListParamsObjectType) IsKnown 

func (r PrismMetadataListParamsObjectType) IsKnown() bool

type PrismMetadataListResponse 

type PrismMetadataListResponse map[string]interface{}

type PrismMetadataService 

type PrismMetadataService struct {
	Options []option.RequestOption
}

PrismMetadataService contains methods and other services that help with interacting with the micro 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 NewPrismMetadataService method instead.

func NewPrismMetadataService 

func NewPrismMetadataService(opts ...option.RequestOption) (r *PrismMetadataService)

NewPrismMetadataService 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 (*PrismMetadataService) List 

func (r *PrismMetadataService) List(ctx context.Context, objectType PrismMetadataListParamsObjectType, params PrismMetadataListParams, opts ...option.RequestOption) (res *PrismMetadataListResponse, err error)

Get metadata properties by object type

type PrismObjectActionBulkNewParams 

type PrismObjectActionBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]          `json:"objects" api:"required"`
	Options param.Field[PrismObjectActionBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectActionBulkNewParams) MarshalJSON 

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

type PrismObjectActionBulkNewParamsOptions 

type PrismObjectActionBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectActionBulkNewParamsOptions) MarshalJSON 

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

type PrismObjectActionBulkNewResponse 

type PrismObjectActionBulkNewResponse struct {
	Results []PrismObjectActionBulkNewResponseResult `json:"results"`
	Status  PrismObjectActionBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectActionBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectActionBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectActionBulkNewResponse) UnmarshalJSON 

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

type PrismObjectActionBulkNewResponseResult 

type PrismObjectActionBulkNewResponseResult struct {
	ID       string                                     `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                       `json:"created"`
	Error    string                                     `json:"error"`
	Existing bool                                       `json:"existing"`
	JSON     prismObjectActionBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectActionBulkNewResponseResult) UnmarshalJSON 

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

type PrismObjectActionBulkNewResponseStatus 

type PrismObjectActionBulkNewResponseStatus string
const (
	PrismObjectActionBulkNewResponseStatusComplete PrismObjectActionBulkNewResponseStatus = "complete"
)

func (PrismObjectActionBulkNewResponseStatus) IsKnown 

func (r PrismObjectActionBulkNewResponseStatus) IsKnown() bool

type PrismObjectActionBulkNewResponseSummary 

type PrismObjectActionBulkNewResponseSummary struct {
	Created  int64                                       `json:"created"`
	Errors   int64                                       `json:"errors"`
	Existing int64                                       `json:"existing"`
	Total    int64                                       `json:"total"`
	JSON     prismObjectActionBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectActionBulkNewResponseSummary) UnmarshalJSON 

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

type PrismObjectActionDeleteParams 

type PrismObjectActionDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectActionDuplicateParams 

type PrismObjectActionDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectActionDuplicateResponse 

type PrismObjectActionDuplicateResponse struct {
	ID   string                                 `json:"id" format:"uuid"`
	JSON prismObjectActionDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectActionDuplicateResponse) UnmarshalJSON 

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

type PrismObjectActionGetParams 

type PrismObjectActionGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectActionGetResponse added in v0.2.0 

type PrismObjectActionGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}           `json:"default"`
	List    interface{}                      `json:"list"`
	JSON    prismObjectActionGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectActionGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectActionGrantGetParams 

type PrismObjectActionGrantGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectActionGrantGetResponse 

type PrismObjectActionGrantGetResponse struct {
	TeamGroupID []map[string]PrismObjectActionGrantGetResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectActionGrantGetResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectActionGrantGetResponseUserID      `json:"user_id"`
	JSON        prismObjectActionGrantGetResponseJSON                     `json:"-"`
}

func (*PrismObjectActionGrantGetResponse) UnmarshalJSON 

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

type PrismObjectActionGrantGetResponseTeamGroupID 

type PrismObjectActionGrantGetResponseTeamGroupID string
const (
	PrismObjectActionGrantGetResponseTeamGroupIDA PrismObjectActionGrantGetResponseTeamGroupID = "a"
	PrismObjectActionGrantGetResponseTeamGroupIDR PrismObjectActionGrantGetResponseTeamGroupID = "r"
	PrismObjectActionGrantGetResponseTeamGroupIDW PrismObjectActionGrantGetResponseTeamGroupID = "w"
)

func (PrismObjectActionGrantGetResponseTeamGroupID) IsKnown 

func (r PrismObjectActionGrantGetResponseTeamGroupID) IsKnown() bool

type PrismObjectActionGrantGetResponseTeamID 

type PrismObjectActionGrantGetResponseTeamID string
const (
	PrismObjectActionGrantGetResponseTeamIDA PrismObjectActionGrantGetResponseTeamID = "a"
	PrismObjectActionGrantGetResponseTeamIDR PrismObjectActionGrantGetResponseTeamID = "r"
	PrismObjectActionGrantGetResponseTeamIDW PrismObjectActionGrantGetResponseTeamID = "w"
)

func (PrismObjectActionGrantGetResponseTeamID) IsKnown 

func (r PrismObjectActionGrantGetResponseTeamID) IsKnown() bool

type PrismObjectActionGrantGetResponseUserID 

type PrismObjectActionGrantGetResponseUserID string
const (
	PrismObjectActionGrantGetResponseUserIDA PrismObjectActionGrantGetResponseUserID = "a"
	PrismObjectActionGrantGetResponseUserIDR PrismObjectActionGrantGetResponseUserID = "r"
	PrismObjectActionGrantGetResponseUserIDW PrismObjectActionGrantGetResponseUserID = "w"
)

func (PrismObjectActionGrantGetResponseUserID) IsKnown 

func (r PrismObjectActionGrantGetResponseUserID) IsKnown() bool

type PrismObjectActionGrantService 

type PrismObjectActionGrantService struct {
	Options []option.RequestOption
}

PrismObjectActionGrantService contains methods and other services that help with interacting with the micro 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 NewPrismObjectActionGrantService method instead.

func NewPrismObjectActionGrantService 

func NewPrismObjectActionGrantService(opts ...option.RequestOption) (r *PrismObjectActionGrantService)

NewPrismObjectActionGrantService 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 (*PrismObjectActionGrantService) Get 

func (r *PrismObjectActionGrantService) Get(ctx context.Context, actionID string, query PrismObjectActionGrantGetParams, opts ...option.RequestOption) (res *PrismObjectActionGrantGetResponse, err error)

Get grant

func (*PrismObjectActionGrantService) Update 

func (r *PrismObjectActionGrantService) Update(ctx context.Context, actionID string, params PrismObjectActionGrantUpdateParams, opts ...option.RequestOption) (res *PrismObjectActionGrantUpdateResponse, err error)

Update grant

type PrismObjectActionGrantUpdateParams 

type PrismObjectActionGrantUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID  param.Field[string]                                                     `path:"teamId" api:"required" format:"uuid"`
	TeamGroupID param.Field[[]map[string]PrismObjectActionGrantUpdateParamsTeamGroupID] `json:"team_group_id"`
	BodyTeamID  param.Field[map[string]PrismObjectActionGrantUpdateParamsTeamID]        `json:"team_id"`
	UserID      param.Field[[]map[string]PrismObjectActionGrantUpdateParamsUserID]      `json:"user_id"`
}

func (PrismObjectActionGrantUpdateParams) MarshalJSON 

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

type PrismObjectActionGrantUpdateParamsTeamGroupID 

type PrismObjectActionGrantUpdateParamsTeamGroupID string
const (
	PrismObjectActionGrantUpdateParamsTeamGroupIDA PrismObjectActionGrantUpdateParamsTeamGroupID = "a"
	PrismObjectActionGrantUpdateParamsTeamGroupIDR PrismObjectActionGrantUpdateParamsTeamGroupID = "r"
	PrismObjectActionGrantUpdateParamsTeamGroupIDW PrismObjectActionGrantUpdateParamsTeamGroupID = "w"
)

func (PrismObjectActionGrantUpdateParamsTeamGroupID) IsKnown 

func (r PrismObjectActionGrantUpdateParamsTeamGroupID) IsKnown() bool

type PrismObjectActionGrantUpdateParamsTeamID 

type PrismObjectActionGrantUpdateParamsTeamID string
const (
	PrismObjectActionGrantUpdateParamsTeamIDA PrismObjectActionGrantUpdateParamsTeamID = "a"
	PrismObjectActionGrantUpdateParamsTeamIDR PrismObjectActionGrantUpdateParamsTeamID = "r"
	PrismObjectActionGrantUpdateParamsTeamIDW PrismObjectActionGrantUpdateParamsTeamID = "w"
)

func (PrismObjectActionGrantUpdateParamsTeamID) IsKnown 

func (r PrismObjectActionGrantUpdateParamsTeamID) IsKnown() bool

type PrismObjectActionGrantUpdateParamsUserID 

type PrismObjectActionGrantUpdateParamsUserID string
const (
	PrismObjectActionGrantUpdateParamsUserIDA PrismObjectActionGrantUpdateParamsUserID = "a"
	PrismObjectActionGrantUpdateParamsUserIDR PrismObjectActionGrantUpdateParamsUserID = "r"
	PrismObjectActionGrantUpdateParamsUserIDW PrismObjectActionGrantUpdateParamsUserID = "w"
)

func (PrismObjectActionGrantUpdateParamsUserID) IsKnown 

func (r PrismObjectActionGrantUpdateParamsUserID) IsKnown() bool

type PrismObjectActionGrantUpdateResponse 

type PrismObjectActionGrantUpdateResponse struct {
	TeamGroupID []map[string]PrismObjectActionGrantUpdateResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectActionGrantUpdateResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectActionGrantUpdateResponseUserID      `json:"user_id"`
	JSON        prismObjectActionGrantUpdateResponseJSON                     `json:"-"`
}

func (*PrismObjectActionGrantUpdateResponse) UnmarshalJSON 

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

type PrismObjectActionGrantUpdateResponseTeamGroupID 

type PrismObjectActionGrantUpdateResponseTeamGroupID string
const (
	PrismObjectActionGrantUpdateResponseTeamGroupIDA PrismObjectActionGrantUpdateResponseTeamGroupID = "a"
	PrismObjectActionGrantUpdateResponseTeamGroupIDR PrismObjectActionGrantUpdateResponseTeamGroupID = "r"
	PrismObjectActionGrantUpdateResponseTeamGroupIDW PrismObjectActionGrantUpdateResponseTeamGroupID = "w"
)

func (PrismObjectActionGrantUpdateResponseTeamGroupID) IsKnown 

func (r PrismObjectActionGrantUpdateResponseTeamGroupID) IsKnown() bool

type PrismObjectActionGrantUpdateResponseTeamID 

type PrismObjectActionGrantUpdateResponseTeamID string
const (
	PrismObjectActionGrantUpdateResponseTeamIDA PrismObjectActionGrantUpdateResponseTeamID = "a"
	PrismObjectActionGrantUpdateResponseTeamIDR PrismObjectActionGrantUpdateResponseTeamID = "r"
	PrismObjectActionGrantUpdateResponseTeamIDW PrismObjectActionGrantUpdateResponseTeamID = "w"
)

func (PrismObjectActionGrantUpdateResponseTeamID) IsKnown 

func (r PrismObjectActionGrantUpdateResponseTeamID) IsKnown() bool

type PrismObjectActionGrantUpdateResponseUserID 

type PrismObjectActionGrantUpdateResponseUserID string
const (
	PrismObjectActionGrantUpdateResponseUserIDA PrismObjectActionGrantUpdateResponseUserID = "a"
	PrismObjectActionGrantUpdateResponseUserIDR PrismObjectActionGrantUpdateResponseUserID = "r"
	PrismObjectActionGrantUpdateResponseUserIDW PrismObjectActionGrantUpdateResponseUserID = "w"
)

func (PrismObjectActionGrantUpdateResponseUserID) IsKnown 

func (r PrismObjectActionGrantUpdateResponseUserID) IsKnown() bool

type PrismObjectActionNewParams 

type PrismObjectActionNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectActionNewParams) MarshalJSON 

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

type PrismObjectActionNewResponse added in v0.2.0 

type PrismObjectActionNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}           `json:"default"`
	List    interface{}                      `json:"list"`
	JSON    prismObjectActionNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectActionNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectActionQueryParams 

type PrismObjectActionQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                              `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectActionQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectActionQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                            `json:"boxes"`
	Deleted param.Field[bool]                                `json:"deleted"`
	Sources param.Field[[]string]                            `json:"sources" format:"uuid"`
}

func (PrismObjectActionQueryParams) MarshalJSON 

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

type PrismObjectActionQueryParamsIDArray 

type PrismObjectActionQueryParamsIDArray []string

func (PrismObjectActionQueryParamsIDArray) ImplementsPrismObjectActionQueryParamsIDUnion 

func (r PrismObjectActionQueryParamsIDArray) ImplementsPrismObjectActionQueryParamsIDUnion()

type PrismObjectActionQueryParamsIDUnion 

type PrismObjectActionQueryParamsIDUnion interface {
	ImplementsPrismObjectActionQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectActionQueryParamsIDArray.

type PrismObjectActionQueryParamsQuery 

type PrismObjectActionQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectActionQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectActionQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                     `json:"limit"`
	ListID param.Field[string]                                                    `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                     `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectActionQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectActionQueryParamsQuery) MarshalJSON 

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

type PrismObjectActionQueryParamsQueryCombinator 

type PrismObjectActionQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectActionQueryParamsQueryCombinatorAnd PrismObjectActionQueryParamsQueryCombinator = "AND"
	PrismObjectActionQueryParamsQueryCombinatorOr  PrismObjectActionQueryParamsQueryCombinator = "OR"
)

func (PrismObjectActionQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectActionQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectActionQueryParamsQueryFilter added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectActionQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectActionQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectActionQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectActionQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilter, PrismObjectActionQueryParamsQueryFilterLikeRegex, PrismObjectActionQueryParamsQueryFilterBeginsWith, PrismObjectActionQueryParamsQueryFilterEndsWith, PrismObjectActionQueryParamsQueryFilterNotContains, PrismObjectActionQueryParamsQueryFilterExists, PrismObjectActionQueryParamsQueryFilterNotExists, PrismObjectActionQueryParamsQueryFilterIn, PrismObjectActionQueryParamsQueryFilterNotIn, PrismObjectActionQueryParamsQueryFilter.

type PrismObjectActionQueryParamsQuerySort 

type PrismObjectActionQueryParamsQuerySort string
const (
	PrismObjectActionQueryParamsQuerySortAsc  PrismObjectActionQueryParamsQuerySort = "asc"
	PrismObjectActionQueryParamsQuerySortDesc PrismObjectActionQueryParamsQuerySort = "desc"
)

func (PrismObjectActionQueryParamsQuerySort) IsKnown 

func (r PrismObjectActionQueryParamsQuerySort) IsKnown() bool

type PrismObjectActionQueryResponse 

type PrismObjectActionQueryResponse struct {
	Data []PrismObjectActionQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                               `json:"has_more"`
	JSON    prismObjectActionQueryResponseJSON `json:"-"`
}

func (*PrismObjectActionQueryResponse) UnmarshalJSON 

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

type PrismObjectActionQueryResponseData added in v0.2.0 

type PrismObjectActionQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                 `json:"default"`
	List    interface{}                            `json:"list"`
	JSON    prismObjectActionQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectActionQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectActionRestoreParams 

type PrismObjectActionRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectActionRestoreResponse added in v0.2.0 

type PrismObjectActionRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}               `json:"default"`
	List    interface{}                          `json:"list"`
	JSON    prismObjectActionRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectActionRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectActionService 

type PrismObjectActionService struct {
	Options []option.RequestOption
	Grant   *PrismObjectActionGrantService
}

PrismObjectActionService contains methods and other services that help with interacting with the micro 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 NewPrismObjectActionService method instead.

func NewPrismObjectActionService 

func NewPrismObjectActionService(opts ...option.RequestOption) (r *PrismObjectActionService)

NewPrismObjectActionService 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 (*PrismObjectActionService) BulkNew 

func (r *PrismObjectActionService) BulkNew(ctx context.Context, params PrismObjectActionBulkNewParams, opts ...option.RequestOption) (res *PrismObjectActionBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectActionService) Delete 

func (r *PrismObjectActionService) Delete(ctx context.Context, actionID string, body PrismObjectActionDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectActionService) Duplicate 

func (r *PrismObjectActionService) Duplicate(ctx context.Context, actionID string, body PrismObjectActionDuplicateParams, opts ...option.RequestOption) (res *PrismObjectActionDuplicateResponse, err error)

Duplicate object

func (*PrismObjectActionService) Get 

func (r *PrismObjectActionService) Get(ctx context.Context, actionID string, query PrismObjectActionGetParams, opts ...option.RequestOption) (res *PrismObjectActionGetResponse, err error)

Get object

func (*PrismObjectActionService) New 

func (r *PrismObjectActionService) New(ctx context.Context, params PrismObjectActionNewParams, opts ...option.RequestOption) (res *PrismObjectActionNewResponse, err error)

Create object

func (*PrismObjectActionService) Query 

func (r *PrismObjectActionService) Query(ctx context.Context, params PrismObjectActionQueryParams, opts ...option.RequestOption) (res *PrismObjectActionQueryResponse, err error)

Query

func (*PrismObjectActionService) Restore 

func (r *PrismObjectActionService) Restore(ctx context.Context, actionID string, body PrismObjectActionRestoreParams, opts ...option.RequestOption) (res *PrismObjectActionRestoreResponse, err error)

Restore object

func (*PrismObjectActionService) Update 

func (r *PrismObjectActionService) Update(ctx context.Context, actionID string, params PrismObjectActionUpdateParams, opts ...option.RequestOption) (res *PrismObjectActionUpdateResponse, err error)

Patch object

type PrismObjectActionUpdateParams 

type PrismObjectActionUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectActionUpdateParams) MarshalJSON 

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

type PrismObjectActionUpdateResponse added in v0.2.0 

type PrismObjectActionUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}              `json:"default"`
	List    interface{}                         `json:"list"`
	JSON    prismObjectActionUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectActionUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactBulkNewParams added in v0.2.0 

type PrismObjectContactBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]           `json:"objects" api:"required"`
	Options param.Field[PrismObjectContactBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectContactBulkNewParams) MarshalJSON added in v0.2.0 

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

type PrismObjectContactBulkNewParamsOptions added in v0.2.0 

type PrismObjectContactBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectContactBulkNewParamsOptions) MarshalJSON added in v0.2.0 

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

type PrismObjectContactBulkNewResponse added in v0.2.0 

type PrismObjectContactBulkNewResponse struct {
	Results []PrismObjectContactBulkNewResponseResult `json:"results"`
	Status  PrismObjectContactBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectContactBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectContactBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectContactBulkNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactBulkNewResponseResult added in v0.2.0 

type PrismObjectContactBulkNewResponseResult struct {
	ID       string                                      `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                        `json:"created"`
	Error    string                                      `json:"error"`
	Existing bool                                        `json:"existing"`
	JSON     prismObjectContactBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectContactBulkNewResponseResult) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactBulkNewResponseStatus added in v0.2.0 

type PrismObjectContactBulkNewResponseStatus string
const (
	PrismObjectContactBulkNewResponseStatusComplete PrismObjectContactBulkNewResponseStatus = "complete"
)

func (PrismObjectContactBulkNewResponseStatus) IsKnown added in v0.2.0 

func (r PrismObjectContactBulkNewResponseStatus) IsKnown() bool

type PrismObjectContactBulkNewResponseSummary added in v0.2.0 

type PrismObjectContactBulkNewResponseSummary struct {
	Created  int64                                        `json:"created"`
	Errors   int64                                        `json:"errors"`
	Existing int64                                        `json:"existing"`
	Total    int64                                        `json:"total"`
	JSON     prismObjectContactBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectContactBulkNewResponseSummary) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactDeleteParams added in v0.2.0 

type PrismObjectContactDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectContactDuplicateParams added in v0.2.0 

type PrismObjectContactDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectContactDuplicateResponse added in v0.2.0 

type PrismObjectContactDuplicateResponse struct {
	ID   string                                  `json:"id" format:"uuid"`
	JSON prismObjectContactDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectContactDuplicateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactGetParams added in v0.2.0 

type PrismObjectContactGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectContactGetResponse added in v0.2.0 

type PrismObjectContactGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}            `json:"default"`
	List    interface{}                       `json:"list"`
	JSON    prismObjectContactGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectContactGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactNewParams added in v0.2.0 

type PrismObjectContactNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectContactNewParams) MarshalJSON added in v0.2.0 

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

type PrismObjectContactNewResponse added in v0.2.0 

type PrismObjectContactNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}            `json:"default"`
	List    interface{}                       `json:"list"`
	JSON    prismObjectContactNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectContactNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactQueryParams 

type PrismObjectContactQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                               `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectContactQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectContactQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                             `json:"boxes"`
	Deleted param.Field[bool]                                 `json:"deleted"`
	Sources param.Field[[]string]                             `json:"sources" format:"uuid"`
}

func (PrismObjectContactQueryParams) MarshalJSON 

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

type PrismObjectContactQueryParamsIDArray 

type PrismObjectContactQueryParamsIDArray []string

func (PrismObjectContactQueryParamsIDArray) ImplementsPrismObjectContactQueryParamsIDUnion 

func (r PrismObjectContactQueryParamsIDArray) ImplementsPrismObjectContactQueryParamsIDUnion()

type PrismObjectContactQueryParamsIDUnion 

type PrismObjectContactQueryParamsIDUnion interface {
	ImplementsPrismObjectContactQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectContactQueryParamsIDArray.

type PrismObjectContactQueryParamsQuery 

type PrismObjectContactQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectContactQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectContactQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                      `json:"limit"`
	ListID param.Field[string]                                                     `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                      `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectContactQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectContactQueryParamsQuery) MarshalJSON 

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

type PrismObjectContactQueryParamsQueryCombinator 

type PrismObjectContactQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectContactQueryParamsQueryCombinatorAnd PrismObjectContactQueryParamsQueryCombinator = "AND"
	PrismObjectContactQueryParamsQueryCombinatorOr  PrismObjectContactQueryParamsQueryCombinator = "OR"
)

func (PrismObjectContactQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectContactQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectContactQueryParamsQueryFilter added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectContactQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectContactQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectContactQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectContactQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilter, PrismObjectContactQueryParamsQueryFilterLikeRegex, PrismObjectContactQueryParamsQueryFilterBeginsWith, PrismObjectContactQueryParamsQueryFilterEndsWith, PrismObjectContactQueryParamsQueryFilterNotContains, PrismObjectContactQueryParamsQueryFilterExists, PrismObjectContactQueryParamsQueryFilterNotExists, PrismObjectContactQueryParamsQueryFilterIn, PrismObjectContactQueryParamsQueryFilterNotIn, PrismObjectContactQueryParamsQueryFilter.

type PrismObjectContactQueryParamsQuerySort 

type PrismObjectContactQueryParamsQuerySort string
const (
	PrismObjectContactQueryParamsQuerySortAsc  PrismObjectContactQueryParamsQuerySort = "asc"
	PrismObjectContactQueryParamsQuerySortDesc PrismObjectContactQueryParamsQuerySort = "desc"
)

func (PrismObjectContactQueryParamsQuerySort) IsKnown 

func (r PrismObjectContactQueryParamsQuerySort) IsKnown() bool

type PrismObjectContactQueryResponse 

type PrismObjectContactQueryResponse struct {
	Data []PrismObjectContactQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                                `json:"has_more"`
	JSON    prismObjectContactQueryResponseJSON `json:"-"`
}

func (*PrismObjectContactQueryResponse) UnmarshalJSON 

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

type PrismObjectContactQueryResponseData added in v0.2.0 

type PrismObjectContactQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                  `json:"default"`
	List    interface{}                             `json:"list"`
	JSON    prismObjectContactQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectContactQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactRestoreParams added in v0.2.0 

type PrismObjectContactRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectContactRestoreResponse added in v0.2.0 

type PrismObjectContactRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                `json:"default"`
	List    interface{}                           `json:"list"`
	JSON    prismObjectContactRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectContactRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectContactService 

type PrismObjectContactService struct {
	Options []option.RequestOption
}

PrismObjectContactService contains methods and other services that help with interacting with the micro 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 NewPrismObjectContactService method instead.

func NewPrismObjectContactService 

func NewPrismObjectContactService(opts ...option.RequestOption) (r *PrismObjectContactService)

NewPrismObjectContactService 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 (*PrismObjectContactService) BulkNew added in v0.2.0 

func (r *PrismObjectContactService) BulkNew(ctx context.Context, params PrismObjectContactBulkNewParams, opts ...option.RequestOption) (res *PrismObjectContactBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectContactService) Delete added in v0.2.0 

func (r *PrismObjectContactService) Delete(ctx context.Context, contactID string, body PrismObjectContactDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectContactService) Duplicate added in v0.2.0 

func (r *PrismObjectContactService) Duplicate(ctx context.Context, contactID string, body PrismObjectContactDuplicateParams, opts ...option.RequestOption) (res *PrismObjectContactDuplicateResponse, err error)

Duplicate object

func (*PrismObjectContactService) Get added in v0.2.0 

func (r *PrismObjectContactService) Get(ctx context.Context, contactID string, query PrismObjectContactGetParams, opts ...option.RequestOption) (res *PrismObjectContactGetResponse, err error)

Get object

func (*PrismObjectContactService) New added in v0.2.0 

func (r *PrismObjectContactService) New(ctx context.Context, params PrismObjectContactNewParams, opts ...option.RequestOption) (res *PrismObjectContactNewResponse, err error)

Create object

func (*PrismObjectContactService) Query 

func (r *PrismObjectContactService) Query(ctx context.Context, params PrismObjectContactQueryParams, opts ...option.RequestOption) (res *PrismObjectContactQueryResponse, err error)

Query

func (*PrismObjectContactService) Restore added in v0.2.0 

func (r *PrismObjectContactService) Restore(ctx context.Context, contactID string, body PrismObjectContactRestoreParams, opts ...option.RequestOption) (res *PrismObjectContactRestoreResponse, err error)

Restore object

func (*PrismObjectContactService) Update added in v0.2.0 

func (r *PrismObjectContactService) Update(ctx context.Context, contactID string, params PrismObjectContactUpdateParams, opts ...option.RequestOption) (res *PrismObjectContactUpdateResponse, err error)

Patch object

type PrismObjectContactUpdateParams added in v0.2.0 

type PrismObjectContactUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectContactUpdateParams) MarshalJSON added in v0.2.0 

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

type PrismObjectContactUpdateResponse added in v0.2.0 

type PrismObjectContactUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}               `json:"default"`
	List    interface{}                          `json:"list"`
	JSON    prismObjectContactUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectContactUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDealBulkNewParams 

type PrismObjectDealBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]        `json:"objects" api:"required"`
	Options param.Field[PrismObjectDealBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectDealBulkNewParams) MarshalJSON 

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

type PrismObjectDealBulkNewParamsOptions 

type PrismObjectDealBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectDealBulkNewParamsOptions) MarshalJSON 

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

type PrismObjectDealBulkNewResponse 

type PrismObjectDealBulkNewResponse struct {
	Results []PrismObjectDealBulkNewResponseResult `json:"results"`
	Status  PrismObjectDealBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectDealBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectDealBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectDealBulkNewResponse) UnmarshalJSON 

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

type PrismObjectDealBulkNewResponseResult 

type PrismObjectDealBulkNewResponseResult struct {
	ID       string                                   `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                     `json:"created"`
	Error    string                                   `json:"error"`
	Existing bool                                     `json:"existing"`
	JSON     prismObjectDealBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectDealBulkNewResponseResult) UnmarshalJSON 

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

type PrismObjectDealBulkNewResponseStatus 

type PrismObjectDealBulkNewResponseStatus string
const (
	PrismObjectDealBulkNewResponseStatusComplete PrismObjectDealBulkNewResponseStatus = "complete"
)

func (PrismObjectDealBulkNewResponseStatus) IsKnown 

func (r PrismObjectDealBulkNewResponseStatus) IsKnown() bool

type PrismObjectDealBulkNewResponseSummary 

type PrismObjectDealBulkNewResponseSummary struct {
	Created  int64                                     `json:"created"`
	Errors   int64                                     `json:"errors"`
	Existing int64                                     `json:"existing"`
	Total    int64                                     `json:"total"`
	JSON     prismObjectDealBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectDealBulkNewResponseSummary) UnmarshalJSON 

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

type PrismObjectDealDeleteParams 

type PrismObjectDealDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDealDuplicateParams 

type PrismObjectDealDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDealDuplicateResponse 

type PrismObjectDealDuplicateResponse struct {
	ID   string                               `json:"id" format:"uuid"`
	JSON prismObjectDealDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectDealDuplicateResponse) UnmarshalJSON 

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

type PrismObjectDealGetParams 

type PrismObjectDealGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDealGetResponse added in v0.2.0 

type PrismObjectDealGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}         `json:"default"`
	List    interface{}                    `json:"list"`
	JSON    prismObjectDealGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDealGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDealGrantGetParams 

type PrismObjectDealGrantGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDealGrantGetResponse 

type PrismObjectDealGrantGetResponse struct {
	TeamGroupID []map[string]PrismObjectDealGrantGetResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectDealGrantGetResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectDealGrantGetResponseUserID      `json:"user_id"`
	JSON        prismObjectDealGrantGetResponseJSON                     `json:"-"`
}

func (*PrismObjectDealGrantGetResponse) UnmarshalJSON 

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

type PrismObjectDealGrantGetResponseTeamGroupID 

type PrismObjectDealGrantGetResponseTeamGroupID string
const (
	PrismObjectDealGrantGetResponseTeamGroupIDA PrismObjectDealGrantGetResponseTeamGroupID = "a"
	PrismObjectDealGrantGetResponseTeamGroupIDR PrismObjectDealGrantGetResponseTeamGroupID = "r"
	PrismObjectDealGrantGetResponseTeamGroupIDW PrismObjectDealGrantGetResponseTeamGroupID = "w"
)

func (PrismObjectDealGrantGetResponseTeamGroupID) IsKnown 

func (r PrismObjectDealGrantGetResponseTeamGroupID) IsKnown() bool

type PrismObjectDealGrantGetResponseTeamID 

type PrismObjectDealGrantGetResponseTeamID string
const (
	PrismObjectDealGrantGetResponseTeamIDA PrismObjectDealGrantGetResponseTeamID = "a"
	PrismObjectDealGrantGetResponseTeamIDR PrismObjectDealGrantGetResponseTeamID = "r"
	PrismObjectDealGrantGetResponseTeamIDW PrismObjectDealGrantGetResponseTeamID = "w"
)

func (PrismObjectDealGrantGetResponseTeamID) IsKnown 

func (r PrismObjectDealGrantGetResponseTeamID) IsKnown() bool

type PrismObjectDealGrantGetResponseUserID 

type PrismObjectDealGrantGetResponseUserID string
const (
	PrismObjectDealGrantGetResponseUserIDA PrismObjectDealGrantGetResponseUserID = "a"
	PrismObjectDealGrantGetResponseUserIDR PrismObjectDealGrantGetResponseUserID = "r"
	PrismObjectDealGrantGetResponseUserIDW PrismObjectDealGrantGetResponseUserID = "w"
)

func (PrismObjectDealGrantGetResponseUserID) IsKnown 

func (r PrismObjectDealGrantGetResponseUserID) IsKnown() bool

type PrismObjectDealGrantService 

type PrismObjectDealGrantService struct {
	Options []option.RequestOption
}

PrismObjectDealGrantService contains methods and other services that help with interacting with the micro 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 NewPrismObjectDealGrantService method instead.

func NewPrismObjectDealGrantService 

func NewPrismObjectDealGrantService(opts ...option.RequestOption) (r *PrismObjectDealGrantService)

NewPrismObjectDealGrantService 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 (*PrismObjectDealGrantService) Get 

func (r *PrismObjectDealGrantService) Get(ctx context.Context, dealID string, query PrismObjectDealGrantGetParams, opts ...option.RequestOption) (res *PrismObjectDealGrantGetResponse, err error)

Get grant

func (*PrismObjectDealGrantService) Update 

func (r *PrismObjectDealGrantService) Update(ctx context.Context, dealID string, params PrismObjectDealGrantUpdateParams, opts ...option.RequestOption) (res *PrismObjectDealGrantUpdateResponse, err error)

Update grant

type PrismObjectDealGrantUpdateParams 

type PrismObjectDealGrantUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID  param.Field[string]                                                   `path:"teamId" api:"required" format:"uuid"`
	TeamGroupID param.Field[[]map[string]PrismObjectDealGrantUpdateParamsTeamGroupID] `json:"team_group_id"`
	BodyTeamID  param.Field[map[string]PrismObjectDealGrantUpdateParamsTeamID]        `json:"team_id"`
	UserID      param.Field[[]map[string]PrismObjectDealGrantUpdateParamsUserID]      `json:"user_id"`
}

func (PrismObjectDealGrantUpdateParams) MarshalJSON 

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

type PrismObjectDealGrantUpdateParamsTeamGroupID 

type PrismObjectDealGrantUpdateParamsTeamGroupID string
const (
	PrismObjectDealGrantUpdateParamsTeamGroupIDA PrismObjectDealGrantUpdateParamsTeamGroupID = "a"
	PrismObjectDealGrantUpdateParamsTeamGroupIDR PrismObjectDealGrantUpdateParamsTeamGroupID = "r"
	PrismObjectDealGrantUpdateParamsTeamGroupIDW PrismObjectDealGrantUpdateParamsTeamGroupID = "w"
)

func (PrismObjectDealGrantUpdateParamsTeamGroupID) IsKnown 

func (r PrismObjectDealGrantUpdateParamsTeamGroupID) IsKnown() bool

type PrismObjectDealGrantUpdateParamsTeamID 

type PrismObjectDealGrantUpdateParamsTeamID string
const (
	PrismObjectDealGrantUpdateParamsTeamIDA PrismObjectDealGrantUpdateParamsTeamID = "a"
	PrismObjectDealGrantUpdateParamsTeamIDR PrismObjectDealGrantUpdateParamsTeamID = "r"
	PrismObjectDealGrantUpdateParamsTeamIDW PrismObjectDealGrantUpdateParamsTeamID = "w"
)

func (PrismObjectDealGrantUpdateParamsTeamID) IsKnown 

func (r PrismObjectDealGrantUpdateParamsTeamID) IsKnown() bool

type PrismObjectDealGrantUpdateParamsUserID 

type PrismObjectDealGrantUpdateParamsUserID string
const (
	PrismObjectDealGrantUpdateParamsUserIDA PrismObjectDealGrantUpdateParamsUserID = "a"
	PrismObjectDealGrantUpdateParamsUserIDR PrismObjectDealGrantUpdateParamsUserID = "r"
	PrismObjectDealGrantUpdateParamsUserIDW PrismObjectDealGrantUpdateParamsUserID = "w"
)

func (PrismObjectDealGrantUpdateParamsUserID) IsKnown 

func (r PrismObjectDealGrantUpdateParamsUserID) IsKnown() bool

type PrismObjectDealGrantUpdateResponse 

type PrismObjectDealGrantUpdateResponse struct {
	TeamGroupID []map[string]PrismObjectDealGrantUpdateResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectDealGrantUpdateResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectDealGrantUpdateResponseUserID      `json:"user_id"`
	JSON        prismObjectDealGrantUpdateResponseJSON                     `json:"-"`
}

func (*PrismObjectDealGrantUpdateResponse) UnmarshalJSON 

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

type PrismObjectDealGrantUpdateResponseTeamGroupID 

type PrismObjectDealGrantUpdateResponseTeamGroupID string
const (
	PrismObjectDealGrantUpdateResponseTeamGroupIDA PrismObjectDealGrantUpdateResponseTeamGroupID = "a"
	PrismObjectDealGrantUpdateResponseTeamGroupIDR PrismObjectDealGrantUpdateResponseTeamGroupID = "r"
	PrismObjectDealGrantUpdateResponseTeamGroupIDW PrismObjectDealGrantUpdateResponseTeamGroupID = "w"
)

func (PrismObjectDealGrantUpdateResponseTeamGroupID) IsKnown 

func (r PrismObjectDealGrantUpdateResponseTeamGroupID) IsKnown() bool

type PrismObjectDealGrantUpdateResponseTeamID 

type PrismObjectDealGrantUpdateResponseTeamID string
const (
	PrismObjectDealGrantUpdateResponseTeamIDA PrismObjectDealGrantUpdateResponseTeamID = "a"
	PrismObjectDealGrantUpdateResponseTeamIDR PrismObjectDealGrantUpdateResponseTeamID = "r"
	PrismObjectDealGrantUpdateResponseTeamIDW PrismObjectDealGrantUpdateResponseTeamID = "w"
)

func (PrismObjectDealGrantUpdateResponseTeamID) IsKnown 

func (r PrismObjectDealGrantUpdateResponseTeamID) IsKnown() bool

type PrismObjectDealGrantUpdateResponseUserID 

type PrismObjectDealGrantUpdateResponseUserID string
const (
	PrismObjectDealGrantUpdateResponseUserIDA PrismObjectDealGrantUpdateResponseUserID = "a"
	PrismObjectDealGrantUpdateResponseUserIDR PrismObjectDealGrantUpdateResponseUserID = "r"
	PrismObjectDealGrantUpdateResponseUserIDW PrismObjectDealGrantUpdateResponseUserID = "w"
)

func (PrismObjectDealGrantUpdateResponseUserID) IsKnown 

func (r PrismObjectDealGrantUpdateResponseUserID) IsKnown() bool

type PrismObjectDealNewParams 

type PrismObjectDealNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectDealNewParams) MarshalJSON 

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

type PrismObjectDealNewResponse added in v0.2.0 

type PrismObjectDealNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}         `json:"default"`
	List    interface{}                    `json:"list"`
	JSON    prismObjectDealNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDealNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDealQueryParams 

type PrismObjectDealQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                            `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectDealQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectDealQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                          `json:"boxes"`
	Deleted param.Field[bool]                              `json:"deleted"`
	Sources param.Field[[]string]                          `json:"sources" format:"uuid"`
}

func (PrismObjectDealQueryParams) MarshalJSON 

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

type PrismObjectDealQueryParamsIDArray 

type PrismObjectDealQueryParamsIDArray []string

func (PrismObjectDealQueryParamsIDArray) ImplementsPrismObjectDealQueryParamsIDUnion 

func (r PrismObjectDealQueryParamsIDArray) ImplementsPrismObjectDealQueryParamsIDUnion()

type PrismObjectDealQueryParamsIDUnion 

type PrismObjectDealQueryParamsIDUnion interface {
	ImplementsPrismObjectDealQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectDealQueryParamsIDArray.

type PrismObjectDealQueryParamsQuery 

type PrismObjectDealQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectDealQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectDealQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                   `json:"limit"`
	ListID param.Field[string]                                                  `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                   `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectDealQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectDealQueryParamsQuery) MarshalJSON 

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

type PrismObjectDealQueryParamsQueryCombinator 

type PrismObjectDealQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectDealQueryParamsQueryCombinatorAnd PrismObjectDealQueryParamsQueryCombinator = "AND"
	PrismObjectDealQueryParamsQueryCombinatorOr  PrismObjectDealQueryParamsQueryCombinator = "OR"
)

func (PrismObjectDealQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectDealQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectDealQueryParamsQueryFilter added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectDealQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectDealQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectDealQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectDealQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilter, PrismObjectDealQueryParamsQueryFilterLikeRegex, PrismObjectDealQueryParamsQueryFilterBeginsWith, PrismObjectDealQueryParamsQueryFilterEndsWith, PrismObjectDealQueryParamsQueryFilterNotContains, PrismObjectDealQueryParamsQueryFilterExists, PrismObjectDealQueryParamsQueryFilterNotExists, PrismObjectDealQueryParamsQueryFilterIn, PrismObjectDealQueryParamsQueryFilterNotIn, PrismObjectDealQueryParamsQueryFilter.

type PrismObjectDealQueryParamsQuerySort 

type PrismObjectDealQueryParamsQuerySort string
const (
	PrismObjectDealQueryParamsQuerySortAsc  PrismObjectDealQueryParamsQuerySort = "asc"
	PrismObjectDealQueryParamsQuerySortDesc PrismObjectDealQueryParamsQuerySort = "desc"
)

func (PrismObjectDealQueryParamsQuerySort) IsKnown 

func (r PrismObjectDealQueryParamsQuerySort) IsKnown() bool

type PrismObjectDealQueryResponse 

type PrismObjectDealQueryResponse struct {
	Data []PrismObjectDealQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                             `json:"has_more"`
	JSON    prismObjectDealQueryResponseJSON `json:"-"`
}

func (*PrismObjectDealQueryResponse) UnmarshalJSON 

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

type PrismObjectDealQueryResponseData added in v0.2.0 

type PrismObjectDealQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}               `json:"default"`
	List    interface{}                          `json:"list"`
	JSON    prismObjectDealQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDealQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDealRestoreParams 

type PrismObjectDealRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDealRestoreResponse added in v0.2.0 

type PrismObjectDealRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}             `json:"default"`
	List    interface{}                        `json:"list"`
	JSON    prismObjectDealRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDealRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDealService 

type PrismObjectDealService struct {
	Options []option.RequestOption
	Grant   *PrismObjectDealGrantService
}

PrismObjectDealService contains methods and other services that help with interacting with the micro 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 NewPrismObjectDealService method instead.

func NewPrismObjectDealService 

func NewPrismObjectDealService(opts ...option.RequestOption) (r *PrismObjectDealService)

NewPrismObjectDealService 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 (*PrismObjectDealService) BulkNew 

func (r *PrismObjectDealService) BulkNew(ctx context.Context, params PrismObjectDealBulkNewParams, opts ...option.RequestOption) (res *PrismObjectDealBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectDealService) Delete 

func (r *PrismObjectDealService) Delete(ctx context.Context, dealID string, body PrismObjectDealDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectDealService) Duplicate 

func (r *PrismObjectDealService) Duplicate(ctx context.Context, dealID string, body PrismObjectDealDuplicateParams, opts ...option.RequestOption) (res *PrismObjectDealDuplicateResponse, err error)

Duplicate object

func (*PrismObjectDealService) Get 

func (r *PrismObjectDealService) Get(ctx context.Context, dealID string, query PrismObjectDealGetParams, opts ...option.RequestOption) (res *PrismObjectDealGetResponse, err error)

Get object

func (*PrismObjectDealService) New 

func (r *PrismObjectDealService) New(ctx context.Context, params PrismObjectDealNewParams, opts ...option.RequestOption) (res *PrismObjectDealNewResponse, err error)

Create object

func (*PrismObjectDealService) Query 

func (r *PrismObjectDealService) Query(ctx context.Context, params PrismObjectDealQueryParams, opts ...option.RequestOption) (res *PrismObjectDealQueryResponse, err error)

Query

func (*PrismObjectDealService) Restore 

func (r *PrismObjectDealService) Restore(ctx context.Context, dealID string, body PrismObjectDealRestoreParams, opts ...option.RequestOption) (res *PrismObjectDealRestoreResponse, err error)

Restore object

func (*PrismObjectDealService) Update 

func (r *PrismObjectDealService) Update(ctx context.Context, dealID string, params PrismObjectDealUpdateParams, opts ...option.RequestOption) (res *PrismObjectDealUpdateResponse, err error)

Patch object

type PrismObjectDealUpdateParams 

type PrismObjectDealUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectDealUpdateParams) MarshalJSON 

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

type PrismObjectDealUpdateResponse added in v0.2.0 

type PrismObjectDealUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}            `json:"default"`
	List    interface{}                       `json:"list"`
	JSON    prismObjectDealUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDealUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDocumentBulkNewParams 

type PrismObjectDocumentBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]            `json:"objects" api:"required"`
	Options param.Field[PrismObjectDocumentBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectDocumentBulkNewParams) MarshalJSON 

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

type PrismObjectDocumentBulkNewParamsOptions 

type PrismObjectDocumentBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectDocumentBulkNewParamsOptions) MarshalJSON 

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

type PrismObjectDocumentBulkNewResponse 

type PrismObjectDocumentBulkNewResponse struct {
	Results []PrismObjectDocumentBulkNewResponseResult `json:"results"`
	Status  PrismObjectDocumentBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectDocumentBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectDocumentBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectDocumentBulkNewResponse) UnmarshalJSON 

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

type PrismObjectDocumentBulkNewResponseResult 

type PrismObjectDocumentBulkNewResponseResult struct {
	ID       string                                       `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                         `json:"created"`
	Error    string                                       `json:"error"`
	Existing bool                                         `json:"existing"`
	JSON     prismObjectDocumentBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectDocumentBulkNewResponseResult) UnmarshalJSON 

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

type PrismObjectDocumentBulkNewResponseStatus 

type PrismObjectDocumentBulkNewResponseStatus string
const (
	PrismObjectDocumentBulkNewResponseStatusComplete PrismObjectDocumentBulkNewResponseStatus = "complete"
)

func (PrismObjectDocumentBulkNewResponseStatus) IsKnown 

func (r PrismObjectDocumentBulkNewResponseStatus) IsKnown() bool

type PrismObjectDocumentBulkNewResponseSummary 

type PrismObjectDocumentBulkNewResponseSummary struct {
	Created  int64                                         `json:"created"`
	Errors   int64                                         `json:"errors"`
	Existing int64                                         `json:"existing"`
	Total    int64                                         `json:"total"`
	JSON     prismObjectDocumentBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectDocumentBulkNewResponseSummary) UnmarshalJSON 

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

type PrismObjectDocumentDeleteParams 

type PrismObjectDocumentDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDocumentDuplicateParams 

type PrismObjectDocumentDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDocumentDuplicateResponse 

type PrismObjectDocumentDuplicateResponse struct {
	ID   string                                   `json:"id" format:"uuid"`
	JSON prismObjectDocumentDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectDocumentDuplicateResponse) UnmarshalJSON 

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

type PrismObjectDocumentGetParams 

type PrismObjectDocumentGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDocumentGetResponse added in v0.2.0 

type PrismObjectDocumentGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}             `json:"default"`
	List    interface{}                        `json:"list"`
	JSON    prismObjectDocumentGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDocumentGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDocumentGrantGetParams 

type PrismObjectDocumentGrantGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDocumentGrantGetResponse 

type PrismObjectDocumentGrantGetResponse struct {
	TeamGroupID []map[string]PrismObjectDocumentGrantGetResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectDocumentGrantGetResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectDocumentGrantGetResponseUserID      `json:"user_id"`
	JSON        prismObjectDocumentGrantGetResponseJSON                     `json:"-"`
}

func (*PrismObjectDocumentGrantGetResponse) UnmarshalJSON 

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

type PrismObjectDocumentGrantGetResponseTeamGroupID 

type PrismObjectDocumentGrantGetResponseTeamGroupID string
const (
	PrismObjectDocumentGrantGetResponseTeamGroupIDA PrismObjectDocumentGrantGetResponseTeamGroupID = "a"
	PrismObjectDocumentGrantGetResponseTeamGroupIDR PrismObjectDocumentGrantGetResponseTeamGroupID = "r"
	PrismObjectDocumentGrantGetResponseTeamGroupIDW PrismObjectDocumentGrantGetResponseTeamGroupID = "w"
)

func (PrismObjectDocumentGrantGetResponseTeamGroupID) IsKnown 

func (r PrismObjectDocumentGrantGetResponseTeamGroupID) IsKnown() bool

type PrismObjectDocumentGrantGetResponseTeamID 

type PrismObjectDocumentGrantGetResponseTeamID string
const (
	PrismObjectDocumentGrantGetResponseTeamIDA PrismObjectDocumentGrantGetResponseTeamID = "a"
	PrismObjectDocumentGrantGetResponseTeamIDR PrismObjectDocumentGrantGetResponseTeamID = "r"
	PrismObjectDocumentGrantGetResponseTeamIDW PrismObjectDocumentGrantGetResponseTeamID = "w"
)

func (PrismObjectDocumentGrantGetResponseTeamID) IsKnown 

func (r PrismObjectDocumentGrantGetResponseTeamID) IsKnown() bool

type PrismObjectDocumentGrantGetResponseUserID 

type PrismObjectDocumentGrantGetResponseUserID string
const (
	PrismObjectDocumentGrantGetResponseUserIDA PrismObjectDocumentGrantGetResponseUserID = "a"
	PrismObjectDocumentGrantGetResponseUserIDR PrismObjectDocumentGrantGetResponseUserID = "r"
	PrismObjectDocumentGrantGetResponseUserIDW PrismObjectDocumentGrantGetResponseUserID = "w"
)

func (PrismObjectDocumentGrantGetResponseUserID) IsKnown 

func (r PrismObjectDocumentGrantGetResponseUserID) IsKnown() bool

type PrismObjectDocumentGrantService 

type PrismObjectDocumentGrantService struct {
	Options []option.RequestOption
}

PrismObjectDocumentGrantService contains methods and other services that help with interacting with the micro 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 NewPrismObjectDocumentGrantService method instead.

func NewPrismObjectDocumentGrantService 

func NewPrismObjectDocumentGrantService(opts ...option.RequestOption) (r *PrismObjectDocumentGrantService)

NewPrismObjectDocumentGrantService 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 (*PrismObjectDocumentGrantService) Get 

func (r *PrismObjectDocumentGrantService) Get(ctx context.Context, documentID string, query PrismObjectDocumentGrantGetParams, opts ...option.RequestOption) (res *PrismObjectDocumentGrantGetResponse, err error)

Get grant

func (*PrismObjectDocumentGrantService) Update 

func (r *PrismObjectDocumentGrantService) Update(ctx context.Context, documentID string, params PrismObjectDocumentGrantUpdateParams, opts ...option.RequestOption) (res *PrismObjectDocumentGrantUpdateResponse, err error)

Update grant

type PrismObjectDocumentGrantUpdateParams 

type PrismObjectDocumentGrantUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID  param.Field[string]                                                       `path:"teamId" api:"required" format:"uuid"`
	TeamGroupID param.Field[[]map[string]PrismObjectDocumentGrantUpdateParamsTeamGroupID] `json:"team_group_id"`
	BodyTeamID  param.Field[map[string]PrismObjectDocumentGrantUpdateParamsTeamID]        `json:"team_id"`
	UserID      param.Field[[]map[string]PrismObjectDocumentGrantUpdateParamsUserID]      `json:"user_id"`
}

func (PrismObjectDocumentGrantUpdateParams) MarshalJSON 

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

type PrismObjectDocumentGrantUpdateParamsTeamGroupID 

type PrismObjectDocumentGrantUpdateParamsTeamGroupID string
const (
	PrismObjectDocumentGrantUpdateParamsTeamGroupIDA PrismObjectDocumentGrantUpdateParamsTeamGroupID = "a"
	PrismObjectDocumentGrantUpdateParamsTeamGroupIDR PrismObjectDocumentGrantUpdateParamsTeamGroupID = "r"
	PrismObjectDocumentGrantUpdateParamsTeamGroupIDW PrismObjectDocumentGrantUpdateParamsTeamGroupID = "w"
)

func (PrismObjectDocumentGrantUpdateParamsTeamGroupID) IsKnown 

func (r PrismObjectDocumentGrantUpdateParamsTeamGroupID) IsKnown() bool

type PrismObjectDocumentGrantUpdateParamsTeamID 

type PrismObjectDocumentGrantUpdateParamsTeamID string
const (
	PrismObjectDocumentGrantUpdateParamsTeamIDA PrismObjectDocumentGrantUpdateParamsTeamID = "a"
	PrismObjectDocumentGrantUpdateParamsTeamIDR PrismObjectDocumentGrantUpdateParamsTeamID = "r"
	PrismObjectDocumentGrantUpdateParamsTeamIDW PrismObjectDocumentGrantUpdateParamsTeamID = "w"
)

func (PrismObjectDocumentGrantUpdateParamsTeamID) IsKnown 

func (r PrismObjectDocumentGrantUpdateParamsTeamID) IsKnown() bool

type PrismObjectDocumentGrantUpdateParamsUserID 

type PrismObjectDocumentGrantUpdateParamsUserID string
const (
	PrismObjectDocumentGrantUpdateParamsUserIDA PrismObjectDocumentGrantUpdateParamsUserID = "a"
	PrismObjectDocumentGrantUpdateParamsUserIDR PrismObjectDocumentGrantUpdateParamsUserID = "r"
	PrismObjectDocumentGrantUpdateParamsUserIDW PrismObjectDocumentGrantUpdateParamsUserID = "w"
)

func (PrismObjectDocumentGrantUpdateParamsUserID) IsKnown 

func (r PrismObjectDocumentGrantUpdateParamsUserID) IsKnown() bool

type PrismObjectDocumentGrantUpdateResponse 

type PrismObjectDocumentGrantUpdateResponse struct {
	TeamGroupID []map[string]PrismObjectDocumentGrantUpdateResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectDocumentGrantUpdateResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectDocumentGrantUpdateResponseUserID      `json:"user_id"`
	JSON        prismObjectDocumentGrantUpdateResponseJSON                     `json:"-"`
}

func (*PrismObjectDocumentGrantUpdateResponse) UnmarshalJSON 

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

type PrismObjectDocumentGrantUpdateResponseTeamGroupID 

type PrismObjectDocumentGrantUpdateResponseTeamGroupID string
const (
	PrismObjectDocumentGrantUpdateResponseTeamGroupIDA PrismObjectDocumentGrantUpdateResponseTeamGroupID = "a"
	PrismObjectDocumentGrantUpdateResponseTeamGroupIDR PrismObjectDocumentGrantUpdateResponseTeamGroupID = "r"
	PrismObjectDocumentGrantUpdateResponseTeamGroupIDW PrismObjectDocumentGrantUpdateResponseTeamGroupID = "w"
)

func (PrismObjectDocumentGrantUpdateResponseTeamGroupID) IsKnown 

func (r PrismObjectDocumentGrantUpdateResponseTeamGroupID) IsKnown() bool

type PrismObjectDocumentGrantUpdateResponseTeamID 

type PrismObjectDocumentGrantUpdateResponseTeamID string
const (
	PrismObjectDocumentGrantUpdateResponseTeamIDA PrismObjectDocumentGrantUpdateResponseTeamID = "a"
	PrismObjectDocumentGrantUpdateResponseTeamIDR PrismObjectDocumentGrantUpdateResponseTeamID = "r"
	PrismObjectDocumentGrantUpdateResponseTeamIDW PrismObjectDocumentGrantUpdateResponseTeamID = "w"
)

func (PrismObjectDocumentGrantUpdateResponseTeamID) IsKnown 

func (r PrismObjectDocumentGrantUpdateResponseTeamID) IsKnown() bool

type PrismObjectDocumentGrantUpdateResponseUserID 

type PrismObjectDocumentGrantUpdateResponseUserID string
const (
	PrismObjectDocumentGrantUpdateResponseUserIDA PrismObjectDocumentGrantUpdateResponseUserID = "a"
	PrismObjectDocumentGrantUpdateResponseUserIDR PrismObjectDocumentGrantUpdateResponseUserID = "r"
	PrismObjectDocumentGrantUpdateResponseUserIDW PrismObjectDocumentGrantUpdateResponseUserID = "w"
)

func (PrismObjectDocumentGrantUpdateResponseUserID) IsKnown 

func (r PrismObjectDocumentGrantUpdateResponseUserID) IsKnown() bool

type PrismObjectDocumentNewParams 

type PrismObjectDocumentNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectDocumentNewParams) MarshalJSON 

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

type PrismObjectDocumentNewResponse added in v0.2.0 

type PrismObjectDocumentNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}             `json:"default"`
	List    interface{}                        `json:"list"`
	JSON    prismObjectDocumentNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDocumentNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDocumentQueryParams 

type PrismObjectDocumentQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                                `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectDocumentQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectDocumentQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                              `json:"boxes"`
	Deleted param.Field[bool]                                  `json:"deleted"`
	Sources param.Field[[]string]                              `json:"sources" format:"uuid"`
}

func (PrismObjectDocumentQueryParams) MarshalJSON 

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

type PrismObjectDocumentQueryParamsIDArray 

type PrismObjectDocumentQueryParamsIDArray []string

func (PrismObjectDocumentQueryParamsIDArray) ImplementsPrismObjectDocumentQueryParamsIDUnion 

func (r PrismObjectDocumentQueryParamsIDArray) ImplementsPrismObjectDocumentQueryParamsIDUnion()

type PrismObjectDocumentQueryParamsIDUnion 

type PrismObjectDocumentQueryParamsIDUnion interface {
	ImplementsPrismObjectDocumentQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectDocumentQueryParamsIDArray.

type PrismObjectDocumentQueryParamsQuery 

type PrismObjectDocumentQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectDocumentQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectDocumentQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                       `json:"limit"`
	ListID param.Field[string]                                                      `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                       `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectDocumentQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectDocumentQueryParamsQuery) MarshalJSON 

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

type PrismObjectDocumentQueryParamsQueryCombinator 

type PrismObjectDocumentQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectDocumentQueryParamsQueryCombinatorAnd PrismObjectDocumentQueryParamsQueryCombinator = "AND"
	PrismObjectDocumentQueryParamsQueryCombinatorOr  PrismObjectDocumentQueryParamsQueryCombinator = "OR"
)

func (PrismObjectDocumentQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectDocumentQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectDocumentQueryParamsQueryFilter added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectDocumentQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectDocumentQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectDocumentQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectDocumentQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilter, PrismObjectDocumentQueryParamsQueryFilterLikeRegex, PrismObjectDocumentQueryParamsQueryFilterBeginsWith, PrismObjectDocumentQueryParamsQueryFilterEndsWith, PrismObjectDocumentQueryParamsQueryFilterNotContains, PrismObjectDocumentQueryParamsQueryFilterExists, PrismObjectDocumentQueryParamsQueryFilterNotExists, PrismObjectDocumentQueryParamsQueryFilterIn, PrismObjectDocumentQueryParamsQueryFilterNotIn, PrismObjectDocumentQueryParamsQueryFilter.

type PrismObjectDocumentQueryParamsQuerySort 

type PrismObjectDocumentQueryParamsQuerySort string
const (
	PrismObjectDocumentQueryParamsQuerySortAsc  PrismObjectDocumentQueryParamsQuerySort = "asc"
	PrismObjectDocumentQueryParamsQuerySortDesc PrismObjectDocumentQueryParamsQuerySort = "desc"
)

func (PrismObjectDocumentQueryParamsQuerySort) IsKnown 

func (r PrismObjectDocumentQueryParamsQuerySort) IsKnown() bool

type PrismObjectDocumentQueryResponse 

type PrismObjectDocumentQueryResponse struct {
	Data []PrismObjectDocumentQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                                 `json:"has_more"`
	JSON    prismObjectDocumentQueryResponseJSON `json:"-"`
}

func (*PrismObjectDocumentQueryResponse) UnmarshalJSON 

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

type PrismObjectDocumentQueryResponseData added in v0.2.0 

type PrismObjectDocumentQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                   `json:"default"`
	List    interface{}                              `json:"list"`
	JSON    prismObjectDocumentQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDocumentQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDocumentRestoreParams 

type PrismObjectDocumentRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectDocumentRestoreResponse added in v0.2.0 

type PrismObjectDocumentRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                 `json:"default"`
	List    interface{}                            `json:"list"`
	JSON    prismObjectDocumentRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDocumentRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectDocumentService 

type PrismObjectDocumentService struct {
	Options []option.RequestOption
	Grant   *PrismObjectDocumentGrantService
}

PrismObjectDocumentService contains methods and other services that help with interacting with the micro 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 NewPrismObjectDocumentService method instead.

func NewPrismObjectDocumentService 

func NewPrismObjectDocumentService(opts ...option.RequestOption) (r *PrismObjectDocumentService)

NewPrismObjectDocumentService 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 (*PrismObjectDocumentService) BulkNew 

func (r *PrismObjectDocumentService) BulkNew(ctx context.Context, params PrismObjectDocumentBulkNewParams, opts ...option.RequestOption) (res *PrismObjectDocumentBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectDocumentService) Delete 

func (r *PrismObjectDocumentService) Delete(ctx context.Context, documentID string, body PrismObjectDocumentDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectDocumentService) Duplicate 

func (r *PrismObjectDocumentService) Duplicate(ctx context.Context, documentID string, body PrismObjectDocumentDuplicateParams, opts ...option.RequestOption) (res *PrismObjectDocumentDuplicateResponse, err error)

Duplicate object

func (*PrismObjectDocumentService) Get 

func (r *PrismObjectDocumentService) Get(ctx context.Context, documentID string, query PrismObjectDocumentGetParams, opts ...option.RequestOption) (res *PrismObjectDocumentGetResponse, err error)

Get object

func (*PrismObjectDocumentService) New 

func (r *PrismObjectDocumentService) New(ctx context.Context, params PrismObjectDocumentNewParams, opts ...option.RequestOption) (res *PrismObjectDocumentNewResponse, err error)

Create object

func (*PrismObjectDocumentService) Query 

func (r *PrismObjectDocumentService) Query(ctx context.Context, params PrismObjectDocumentQueryParams, opts ...option.RequestOption) (res *PrismObjectDocumentQueryResponse, err error)

Query

func (*PrismObjectDocumentService) Restore 

func (r *PrismObjectDocumentService) Restore(ctx context.Context, documentID string, body PrismObjectDocumentRestoreParams, opts ...option.RequestOption) (res *PrismObjectDocumentRestoreResponse, err error)

Restore object

func (*PrismObjectDocumentService) Update 

func (r *PrismObjectDocumentService) Update(ctx context.Context, documentID string, params PrismObjectDocumentUpdateParams, opts ...option.RequestOption) (res *PrismObjectDocumentUpdateResponse, err error)

Patch object

type PrismObjectDocumentUpdateParams 

type PrismObjectDocumentUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectDocumentUpdateParams) MarshalJSON 

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

type PrismObjectDocumentUpdateResponse added in v0.2.0 

type PrismObjectDocumentUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                `json:"default"`
	List    interface{}                           `json:"list"`
	JSON    prismObjectDocumentUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectDocumentUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectEventGetParams 

type PrismObjectEventGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectEventGetResponse added in v0.2.0 

type PrismObjectEventGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}          `json:"default"`
	List    interface{}                     `json:"list"`
	JSON    prismObjectEventGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectEventGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectEventGrantGetParams 

type PrismObjectEventGrantGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectEventGrantGetResponse 

type PrismObjectEventGrantGetResponse struct {
	TeamGroupID []map[string]PrismObjectEventGrantGetResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectEventGrantGetResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectEventGrantGetResponseUserID      `json:"user_id"`
	JSON        prismObjectEventGrantGetResponseJSON                     `json:"-"`
}

func (*PrismObjectEventGrantGetResponse) UnmarshalJSON 

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

type PrismObjectEventGrantGetResponseTeamGroupID 

type PrismObjectEventGrantGetResponseTeamGroupID string
const (
	PrismObjectEventGrantGetResponseTeamGroupIDA PrismObjectEventGrantGetResponseTeamGroupID = "a"
	PrismObjectEventGrantGetResponseTeamGroupIDR PrismObjectEventGrantGetResponseTeamGroupID = "r"
	PrismObjectEventGrantGetResponseTeamGroupIDW PrismObjectEventGrantGetResponseTeamGroupID = "w"
)

func (PrismObjectEventGrantGetResponseTeamGroupID) IsKnown 

func (r PrismObjectEventGrantGetResponseTeamGroupID) IsKnown() bool

type PrismObjectEventGrantGetResponseTeamID 

type PrismObjectEventGrantGetResponseTeamID string
const (
	PrismObjectEventGrantGetResponseTeamIDA PrismObjectEventGrantGetResponseTeamID = "a"
	PrismObjectEventGrantGetResponseTeamIDR PrismObjectEventGrantGetResponseTeamID = "r"
	PrismObjectEventGrantGetResponseTeamIDW PrismObjectEventGrantGetResponseTeamID = "w"
)

func (PrismObjectEventGrantGetResponseTeamID) IsKnown 

func (r PrismObjectEventGrantGetResponseTeamID) IsKnown() bool

type PrismObjectEventGrantGetResponseUserID 

type PrismObjectEventGrantGetResponseUserID string
const (
	PrismObjectEventGrantGetResponseUserIDA PrismObjectEventGrantGetResponseUserID = "a"
	PrismObjectEventGrantGetResponseUserIDR PrismObjectEventGrantGetResponseUserID = "r"
	PrismObjectEventGrantGetResponseUserIDW PrismObjectEventGrantGetResponseUserID = "w"
)

func (PrismObjectEventGrantGetResponseUserID) IsKnown 

func (r PrismObjectEventGrantGetResponseUserID) IsKnown() bool

type PrismObjectEventGrantService 

type PrismObjectEventGrantService struct {
	Options []option.RequestOption
}

PrismObjectEventGrantService contains methods and other services that help with interacting with the micro 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 NewPrismObjectEventGrantService method instead.

func NewPrismObjectEventGrantService 

func NewPrismObjectEventGrantService(opts ...option.RequestOption) (r *PrismObjectEventGrantService)

NewPrismObjectEventGrantService 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 (*PrismObjectEventGrantService) Get 

func (r *PrismObjectEventGrantService) Get(ctx context.Context, eventID string, query PrismObjectEventGrantGetParams, opts ...option.RequestOption) (res *PrismObjectEventGrantGetResponse, err error)

Get grant

func (*PrismObjectEventGrantService) Update 

func (r *PrismObjectEventGrantService) Update(ctx context.Context, eventID string, params PrismObjectEventGrantUpdateParams, opts ...option.RequestOption) (res *PrismObjectEventGrantUpdateResponse, err error)

Update grant

type PrismObjectEventGrantUpdateParams 

type PrismObjectEventGrantUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID  param.Field[string]                                                    `path:"teamId" api:"required" format:"uuid"`
	TeamGroupID param.Field[[]map[string]PrismObjectEventGrantUpdateParamsTeamGroupID] `json:"team_group_id"`
	BodyTeamID  param.Field[map[string]PrismObjectEventGrantUpdateParamsTeamID]        `json:"team_id"`
	UserID      param.Field[[]map[string]PrismObjectEventGrantUpdateParamsUserID]      `json:"user_id"`
}

func (PrismObjectEventGrantUpdateParams) MarshalJSON 

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

type PrismObjectEventGrantUpdateParamsTeamGroupID 

type PrismObjectEventGrantUpdateParamsTeamGroupID string
const (
	PrismObjectEventGrantUpdateParamsTeamGroupIDA PrismObjectEventGrantUpdateParamsTeamGroupID = "a"
	PrismObjectEventGrantUpdateParamsTeamGroupIDR PrismObjectEventGrantUpdateParamsTeamGroupID = "r"
	PrismObjectEventGrantUpdateParamsTeamGroupIDW PrismObjectEventGrantUpdateParamsTeamGroupID = "w"
)

func (PrismObjectEventGrantUpdateParamsTeamGroupID) IsKnown 

func (r PrismObjectEventGrantUpdateParamsTeamGroupID) IsKnown() bool

type PrismObjectEventGrantUpdateParamsTeamID 

type PrismObjectEventGrantUpdateParamsTeamID string
const (
	PrismObjectEventGrantUpdateParamsTeamIDA PrismObjectEventGrantUpdateParamsTeamID = "a"
	PrismObjectEventGrantUpdateParamsTeamIDR PrismObjectEventGrantUpdateParamsTeamID = "r"
	PrismObjectEventGrantUpdateParamsTeamIDW PrismObjectEventGrantUpdateParamsTeamID = "w"
)

func (PrismObjectEventGrantUpdateParamsTeamID) IsKnown 

func (r PrismObjectEventGrantUpdateParamsTeamID) IsKnown() bool

type PrismObjectEventGrantUpdateParamsUserID 

type PrismObjectEventGrantUpdateParamsUserID string
const (
	PrismObjectEventGrantUpdateParamsUserIDA PrismObjectEventGrantUpdateParamsUserID = "a"
	PrismObjectEventGrantUpdateParamsUserIDR PrismObjectEventGrantUpdateParamsUserID = "r"
	PrismObjectEventGrantUpdateParamsUserIDW PrismObjectEventGrantUpdateParamsUserID = "w"
)

func (PrismObjectEventGrantUpdateParamsUserID) IsKnown 

func (r PrismObjectEventGrantUpdateParamsUserID) IsKnown() bool

type PrismObjectEventGrantUpdateResponse 

type PrismObjectEventGrantUpdateResponse struct {
	TeamGroupID []map[string]PrismObjectEventGrantUpdateResponseTeamGroupID `json:"team_group_id"`
	TeamID      map[string]PrismObjectEventGrantUpdateResponseTeamID        `json:"team_id"`
	UserID      []map[string]PrismObjectEventGrantUpdateResponseUserID      `json:"user_id"`
	JSON        prismObjectEventGrantUpdateResponseJSON                     `json:"-"`
}

func (*PrismObjectEventGrantUpdateResponse) UnmarshalJSON 

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

type PrismObjectEventGrantUpdateResponseTeamGroupID 

type PrismObjectEventGrantUpdateResponseTeamGroupID string
const (
	PrismObjectEventGrantUpdateResponseTeamGroupIDA PrismObjectEventGrantUpdateResponseTeamGroupID = "a"
	PrismObjectEventGrantUpdateResponseTeamGroupIDR PrismObjectEventGrantUpdateResponseTeamGroupID = "r"
	PrismObjectEventGrantUpdateResponseTeamGroupIDW PrismObjectEventGrantUpdateResponseTeamGroupID = "w"
)

func (PrismObjectEventGrantUpdateResponseTeamGroupID) IsKnown 

func (r PrismObjectEventGrantUpdateResponseTeamGroupID) IsKnown() bool

type PrismObjectEventGrantUpdateResponseTeamID 

type PrismObjectEventGrantUpdateResponseTeamID string
const (
	PrismObjectEventGrantUpdateResponseTeamIDA PrismObjectEventGrantUpdateResponseTeamID = "a"
	PrismObjectEventGrantUpdateResponseTeamIDR PrismObjectEventGrantUpdateResponseTeamID = "r"
	PrismObjectEventGrantUpdateResponseTeamIDW PrismObjectEventGrantUpdateResponseTeamID = "w"
)

func (PrismObjectEventGrantUpdateResponseTeamID) IsKnown 

func (r PrismObjectEventGrantUpdateResponseTeamID) IsKnown() bool

type PrismObjectEventGrantUpdateResponseUserID 

type PrismObjectEventGrantUpdateResponseUserID string
const (
	PrismObjectEventGrantUpdateResponseUserIDA PrismObjectEventGrantUpdateResponseUserID = "a"
	PrismObjectEventGrantUpdateResponseUserIDR PrismObjectEventGrantUpdateResponseUserID = "r"
	PrismObjectEventGrantUpdateResponseUserIDW PrismObjectEventGrantUpdateResponseUserID = "w"
)

func (PrismObjectEventGrantUpdateResponseUserID) IsKnown 

func (r PrismObjectEventGrantUpdateResponseUserID) IsKnown() bool

type PrismObjectEventQueryParams 

type PrismObjectEventQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                             `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectEventQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectEventQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                           `json:"boxes"`
	Deleted param.Field[bool]                               `json:"deleted"`
	Sources param.Field[[]string]                           `json:"sources" format:"uuid"`
}

func (PrismObjectEventQueryParams) MarshalJSON 

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

type PrismObjectEventQueryParamsIDArray 

type PrismObjectEventQueryParamsIDArray []string

func (PrismObjectEventQueryParamsIDArray) ImplementsPrismObjectEventQueryParamsIDUnion 

func (r PrismObjectEventQueryParamsIDArray) ImplementsPrismObjectEventQueryParamsIDUnion()

type PrismObjectEventQueryParamsIDUnion 

type PrismObjectEventQueryParamsIDUnion interface {
	ImplementsPrismObjectEventQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectEventQueryParamsIDArray.

type PrismObjectEventQueryParamsQuery 

type PrismObjectEventQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectEventQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectEventQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                    `json:"limit"`
	ListID param.Field[string]                                                   `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                    `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectEventQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectEventQueryParamsQuery) MarshalJSON 

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

type PrismObjectEventQueryParamsQueryCombinator 

type PrismObjectEventQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectEventQueryParamsQueryCombinatorAnd PrismObjectEventQueryParamsQueryCombinator = "AND"
	PrismObjectEventQueryParamsQueryCombinatorOr  PrismObjectEventQueryParamsQueryCombinator = "OR"
)

func (PrismObjectEventQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectEventQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectEventQueryParamsQueryFilter added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectEventQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectEventQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectEventQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectEventQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilter, PrismObjectEventQueryParamsQueryFilterLikeRegex, PrismObjectEventQueryParamsQueryFilterBeginsWith, PrismObjectEventQueryParamsQueryFilterEndsWith, PrismObjectEventQueryParamsQueryFilterNotContains, PrismObjectEventQueryParamsQueryFilterExists, PrismObjectEventQueryParamsQueryFilterNotExists, PrismObjectEventQueryParamsQueryFilterIn, PrismObjectEventQueryParamsQueryFilterNotIn, PrismObjectEventQueryParamsQueryFilter.

type PrismObjectEventQueryParamsQuerySort 

type PrismObjectEventQueryParamsQuerySort string
const (
	PrismObjectEventQueryParamsQuerySortAsc  PrismObjectEventQueryParamsQuerySort = "asc"
	PrismObjectEventQueryParamsQuerySortDesc PrismObjectEventQueryParamsQuerySort = "desc"
)

func (PrismObjectEventQueryParamsQuerySort) IsKnown 

func (r PrismObjectEventQueryParamsQuerySort) IsKnown() bool

type PrismObjectEventQueryResponse 

type PrismObjectEventQueryResponse struct {
	Data []PrismObjectEventQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                              `json:"has_more"`
	JSON    prismObjectEventQueryResponseJSON `json:"-"`
}

func (*PrismObjectEventQueryResponse) UnmarshalJSON 

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

type PrismObjectEventQueryResponseData added in v0.2.0 

type PrismObjectEventQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                `json:"default"`
	List    interface{}                           `json:"list"`
	JSON    prismObjectEventQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectEventQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectEventService 

type PrismObjectEventService struct {
	Options []option.RequestOption
	Grant   *PrismObjectEventGrantService
}

PrismObjectEventService contains methods and other services that help with interacting with the micro 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 NewPrismObjectEventService method instead.

func NewPrismObjectEventService 

func NewPrismObjectEventService(opts ...option.RequestOption) (r *PrismObjectEventService)

NewPrismObjectEventService 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 (*PrismObjectEventService) Get 

func (r *PrismObjectEventService) Get(ctx context.Context, eventID string, query PrismObjectEventGetParams, opts ...option.RequestOption) (res *PrismObjectEventGetResponse, err error)

Get object

func (*PrismObjectEventService) Query 

func (r *PrismObjectEventService) Query(ctx context.Context, params PrismObjectEventQueryParams, opts ...option.RequestOption) (res *PrismObjectEventQueryResponse, err error)

Query

type PrismObjectIdentityBulkNewParams 

type PrismObjectIdentityBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]            `json:"objects" api:"required"`
	Options param.Field[PrismObjectIdentityBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectIdentityBulkNewParams) MarshalJSON 

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

type PrismObjectIdentityBulkNewParamsOptions 

type PrismObjectIdentityBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectIdentityBulkNewParamsOptions) MarshalJSON 

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

type PrismObjectIdentityBulkNewResponse 

type PrismObjectIdentityBulkNewResponse struct {
	Results []PrismObjectIdentityBulkNewResponseResult `json:"results"`
	Status  PrismObjectIdentityBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectIdentityBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectIdentityBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectIdentityBulkNewResponse) UnmarshalJSON 

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

type PrismObjectIdentityBulkNewResponseResult 

type PrismObjectIdentityBulkNewResponseResult struct {
	ID       string                                       `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                         `json:"created"`
	Error    string                                       `json:"error"`
	Existing bool                                         `json:"existing"`
	JSON     prismObjectIdentityBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectIdentityBulkNewResponseResult) UnmarshalJSON 

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

type PrismObjectIdentityBulkNewResponseStatus 

type PrismObjectIdentityBulkNewResponseStatus string
const (
	PrismObjectIdentityBulkNewResponseStatusComplete PrismObjectIdentityBulkNewResponseStatus = "complete"
)

func (PrismObjectIdentityBulkNewResponseStatus) IsKnown 

func (r PrismObjectIdentityBulkNewResponseStatus) IsKnown() bool

type PrismObjectIdentityBulkNewResponseSummary 

type PrismObjectIdentityBulkNewResponseSummary struct {
	Created  int64                                         `json:"created"`
	Errors   int64                                         `json:"errors"`
	Existing int64                                         `json:"existing"`
	Total    int64                                         `json:"total"`
	JSON     prismObjectIdentityBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectIdentityBulkNewResponseSummary) UnmarshalJSON 

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

type PrismObjectIdentityDeleteParams 

type PrismObjectIdentityDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectIdentityDuplicateParams 

type PrismObjectIdentityDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectIdentityDuplicateResponse 

type PrismObjectIdentityDuplicateResponse struct {
	ID   string                                   `json:"id" format:"uuid"`
	JSON prismObjectIdentityDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectIdentityDuplicateResponse) UnmarshalJSON 

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

type PrismObjectIdentityGetParams 

type PrismObjectIdentityGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectIdentityGetResponse added in v0.2.0 

type PrismObjectIdentityGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}             `json:"default"`
	List    interface{}                        `json:"list"`
	JSON    prismObjectIdentityGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectIdentityGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectIdentityNewParams 

type PrismObjectIdentityNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectIdentityNewParams) MarshalJSON 

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

type PrismObjectIdentityNewResponse added in v0.2.0 

type PrismObjectIdentityNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}             `json:"default"`
	List    interface{}                        `json:"list"`
	JSON    prismObjectIdentityNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectIdentityNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectIdentityQueryParams 

type PrismObjectIdentityQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                                `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectIdentityQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectIdentityQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                              `json:"boxes"`
	Deleted param.Field[bool]                                  `json:"deleted"`
	Sources param.Field[[]string]                              `json:"sources" format:"uuid"`
}

func (PrismObjectIdentityQueryParams) MarshalJSON 

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

type PrismObjectIdentityQueryParamsIDArray 

type PrismObjectIdentityQueryParamsIDArray []string

func (PrismObjectIdentityQueryParamsIDArray) ImplementsPrismObjectIdentityQueryParamsIDUnion 

func (r PrismObjectIdentityQueryParamsIDArray) ImplementsPrismObjectIdentityQueryParamsIDUnion()

type PrismObjectIdentityQueryParamsIDUnion 

type PrismObjectIdentityQueryParamsIDUnion interface {
	ImplementsPrismObjectIdentityQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectIdentityQueryParamsIDArray.

type PrismObjectIdentityQueryParamsQuery 

type PrismObjectIdentityQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectIdentityQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectIdentityQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                       `json:"limit"`
	ListID param.Field[string]                                                      `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                       `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectIdentityQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectIdentityQueryParamsQuery) MarshalJSON 

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

type PrismObjectIdentityQueryParamsQueryCombinator 

type PrismObjectIdentityQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectIdentityQueryParamsQueryCombinatorAnd PrismObjectIdentityQueryParamsQueryCombinator = "AND"
	PrismObjectIdentityQueryParamsQueryCombinatorOr  PrismObjectIdentityQueryParamsQueryCombinator = "OR"
)

func (PrismObjectIdentityQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectIdentityQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectIdentityQueryParamsQueryFilter added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectIdentityQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectIdentityQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectIdentityQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectIdentityQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilter, PrismObjectIdentityQueryParamsQueryFilterLikeRegex, PrismObjectIdentityQueryParamsQueryFilterBeginsWith, PrismObjectIdentityQueryParamsQueryFilterEndsWith, PrismObjectIdentityQueryParamsQueryFilterNotContains, PrismObjectIdentityQueryParamsQueryFilterExists, PrismObjectIdentityQueryParamsQueryFilterNotExists, PrismObjectIdentityQueryParamsQueryFilterIn, PrismObjectIdentityQueryParamsQueryFilterNotIn, PrismObjectIdentityQueryParamsQueryFilter.

type PrismObjectIdentityQueryParamsQuerySort 

type PrismObjectIdentityQueryParamsQuerySort string
const (
	PrismObjectIdentityQueryParamsQuerySortAsc  PrismObjectIdentityQueryParamsQuerySort = "asc"
	PrismObjectIdentityQueryParamsQuerySortDesc PrismObjectIdentityQueryParamsQuerySort = "desc"
)

func (PrismObjectIdentityQueryParamsQuerySort) IsKnown 

func (r PrismObjectIdentityQueryParamsQuerySort) IsKnown() bool

type PrismObjectIdentityQueryResponse 

type PrismObjectIdentityQueryResponse struct {
	Data []PrismObjectIdentityQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                                 `json:"has_more"`
	JSON    prismObjectIdentityQueryResponseJSON `json:"-"`
}

func (*PrismObjectIdentityQueryResponse) UnmarshalJSON 

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

type PrismObjectIdentityQueryResponseData added in v0.2.0 

type PrismObjectIdentityQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                   `json:"default"`
	List    interface{}                              `json:"list"`
	JSON    prismObjectIdentityQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectIdentityQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectIdentityRestoreParams 

type PrismObjectIdentityRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectIdentityRestoreResponse added in v0.2.0 

type PrismObjectIdentityRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                 `json:"default"`
	List    interface{}                            `json:"list"`
	JSON    prismObjectIdentityRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectIdentityRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectIdentityService 

type PrismObjectIdentityService struct {
	Options []option.RequestOption
}

PrismObjectIdentityService contains methods and other services that help with interacting with the micro 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 NewPrismObjectIdentityService method instead.

func NewPrismObjectIdentityService 

func NewPrismObjectIdentityService(opts ...option.RequestOption) (r *PrismObjectIdentityService)

NewPrismObjectIdentityService 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 (*PrismObjectIdentityService) BulkNew 

func (r *PrismObjectIdentityService) BulkNew(ctx context.Context, params PrismObjectIdentityBulkNewParams, opts ...option.RequestOption) (res *PrismObjectIdentityBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectIdentityService) Delete 

func (r *PrismObjectIdentityService) Delete(ctx context.Context, identityID string, body PrismObjectIdentityDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectIdentityService) Duplicate 

func (r *PrismObjectIdentityService) Duplicate(ctx context.Context, identityID string, body PrismObjectIdentityDuplicateParams, opts ...option.RequestOption) (res *PrismObjectIdentityDuplicateResponse, err error)

Duplicate object

func (*PrismObjectIdentityService) Get 

func (r *PrismObjectIdentityService) Get(ctx context.Context, identityID string, query PrismObjectIdentityGetParams, opts ...option.RequestOption) (res *PrismObjectIdentityGetResponse, err error)

Get object

func (*PrismObjectIdentityService) New 

func (r *PrismObjectIdentityService) New(ctx context.Context, params PrismObjectIdentityNewParams, opts ...option.RequestOption) (res *PrismObjectIdentityNewResponse, err error)

Create object

func (*PrismObjectIdentityService) Query 

func (r *PrismObjectIdentityService) Query(ctx context.Context, params PrismObjectIdentityQueryParams, opts ...option.RequestOption) (res *PrismObjectIdentityQueryResponse, err error)

Query

func (*PrismObjectIdentityService) Restore 

func (r *PrismObjectIdentityService) Restore(ctx context.Context, identityID string, body PrismObjectIdentityRestoreParams, opts ...option.RequestOption) (res *PrismObjectIdentityRestoreResponse, err error)

Restore object

func (*PrismObjectIdentityService) Update 

func (r *PrismObjectIdentityService) Update(ctx context.Context, identityID string, params PrismObjectIdentityUpdateParams, opts ...option.RequestOption) (res *PrismObjectIdentityUpdateResponse, err error)

Patch object

type PrismObjectIdentityUpdateParams 

type PrismObjectIdentityUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectIdentityUpdateParams) MarshalJSON 

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

type PrismObjectIdentityUpdateResponse added in v0.2.0 

type PrismObjectIdentityUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                `json:"default"`
	List    interface{}                           `json:"list"`
	JSON    prismObjectIdentityUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectIdentityUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationBulkNewParams added in v0.2.0 

type PrismObjectOrganizationBulkNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	// Array of objects to import with property values keyed by slug
	Objects param.Field[[]PrismObjectPropertiesParam]                `json:"objects" api:"required"`
	Options param.Field[PrismObjectOrganizationBulkNewParamsOptions] `json:"options"`
}

func (PrismObjectOrganizationBulkNewParams) MarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationBulkNewParamsOptions added in v0.2.0 

type PrismObjectOrganizationBulkNewParamsOptions struct {
	// Whether deduplication should be case insensitive
	CaseInsensitive param.Field[bool] `json:"caseInsensitive"`
	// Property slug to deduplicate on
	DedupeBy param.Field[string] `json:"dedupe_by"`
	// App/CRM ID for context (optional)
	ListID param.Field[string] `json:"list_id" format:"uuid"`
}

func (PrismObjectOrganizationBulkNewParamsOptions) MarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationBulkNewResponse added in v0.2.0 

type PrismObjectOrganizationBulkNewResponse struct {
	Results []PrismObjectOrganizationBulkNewResponseResult `json:"results"`
	Status  PrismObjectOrganizationBulkNewResponseStatus   `json:"status"`
	Summary PrismObjectOrganizationBulkNewResponseSummary  `json:"summary"`
	JSON    prismObjectOrganizationBulkNewResponseJSON     `json:"-"`
}

func (*PrismObjectOrganizationBulkNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationBulkNewResponseResult added in v0.2.0 

type PrismObjectOrganizationBulkNewResponseResult struct {
	ID       string                                           `json:"id" api:"nullable" format:"uuid"`
	Created  bool                                             `json:"created"`
	Error    string                                           `json:"error"`
	Existing bool                                             `json:"existing"`
	JSON     prismObjectOrganizationBulkNewResponseResultJSON `json:"-"`
}

func (*PrismObjectOrganizationBulkNewResponseResult) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationBulkNewResponseStatus added in v0.2.0 

type PrismObjectOrganizationBulkNewResponseStatus string
const (
	PrismObjectOrganizationBulkNewResponseStatusComplete PrismObjectOrganizationBulkNewResponseStatus = "complete"
)

func (PrismObjectOrganizationBulkNewResponseStatus) IsKnown added in v0.2.0 

func (r PrismObjectOrganizationBulkNewResponseStatus) IsKnown() bool

type PrismObjectOrganizationBulkNewResponseSummary added in v0.2.0 

type PrismObjectOrganizationBulkNewResponseSummary struct {
	Created  int64                                             `json:"created"`
	Errors   int64                                             `json:"errors"`
	Existing int64                                             `json:"existing"`
	Total    int64                                             `json:"total"`
	JSON     prismObjectOrganizationBulkNewResponseSummaryJSON `json:"-"`
}

func (*PrismObjectOrganizationBulkNewResponseSummary) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationDeleteParams added in v0.2.0 

type PrismObjectOrganizationDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectOrganizationDuplicateParams added in v0.2.0 

type PrismObjectOrganizationDuplicateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectOrganizationDuplicateResponse added in v0.2.0 

type PrismObjectOrganizationDuplicateResponse struct {
	ID   string                                       `json:"id" format:"uuid"`
	JSON prismObjectOrganizationDuplicateResponseJSON `json:"-"`
}

func (*PrismObjectOrganizationDuplicateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationGetParams added in v0.2.0 

type PrismObjectOrganizationGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectOrganizationGetResponse added in v0.2.0 

type PrismObjectOrganizationGetResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                 `json:"default"`
	List    interface{}                            `json:"list"`
	JSON    prismObjectOrganizationGetResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectOrganizationGetResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationNewParams added in v0.2.0 

type PrismObjectOrganizationNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectOrganizationNewParams) MarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationNewResponse added in v0.2.0 

type PrismObjectOrganizationNewResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                 `json:"default"`
	List    interface{}                            `json:"list"`
	JSON    prismObjectOrganizationNewResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectOrganizationNewResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationQueryParams 

type PrismObjectOrganizationQueryParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID  param.Field[string]                                    `path:"teamId" api:"required" format:"uuid"`
	Query   param.Field[PrismObjectOrganizationQueryParamsQuery]   `json:"query" api:"required"`
	ID      param.Field[PrismObjectOrganizationQueryParamsIDUnion] `json:"id" format:"uuid"`
	Boxes   param.Field[[]string]                                  `json:"boxes"`
	Deleted param.Field[bool]                                      `json:"deleted"`
	Sources param.Field[[]string]                                  `json:"sources" format:"uuid"`
}

func (PrismObjectOrganizationQueryParams) MarshalJSON 

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

type PrismObjectOrganizationQueryParamsIDArray 

type PrismObjectOrganizationQueryParamsIDArray []string

func (PrismObjectOrganizationQueryParamsIDArray) ImplementsPrismObjectOrganizationQueryParamsIDUnion 

func (r PrismObjectOrganizationQueryParamsIDArray) ImplementsPrismObjectOrganizationQueryParamsIDUnion()

type PrismObjectOrganizationQueryParamsIDUnion 

type PrismObjectOrganizationQueryParamsIDUnion interface {
	ImplementsPrismObjectOrganizationQueryParamsIDUnion()
}

Satisfied by [shared.UnionString], PrismObjectOrganizationQueryParamsIDArray.

type PrismObjectOrganizationQueryParamsQuery 

type PrismObjectOrganizationQueryParamsQuery struct {
	// Property slugs to select. Use dot notation for relationships (e.g.
	// attendee.contact.first_name)
	Select param.Field[[]string] `json:"select" api:"required"`
	// Logical operator for combining filters
	Combinator param.Field[PrismObjectOrganizationQueryParamsQueryCombinator] `json:"combinator"`
	// Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
	// values may be option slugs or option UUIDs.
	Filter param.Field[[]map[string]PrismObjectOrganizationQueryParamsQueryFilterUnion] `json:"filter"`
	Limit  param.Field[int64]                                                           `json:"limit"`
	ListID param.Field[string]                                                          `json:"list_id" format:"uuid"`
	Page   param.Field[int64]                                                           `json:"page"`
	// Sort order as [{ slug: direction }]. Array order determines sort priority
	Sort param.Field[[]map[string]PrismObjectOrganizationQueryParamsQuerySort] `json:"sort"`
}

func (PrismObjectOrganizationQueryParamsQuery) MarshalJSON 

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

type PrismObjectOrganizationQueryParamsQueryCombinator 

type PrismObjectOrganizationQueryParamsQueryCombinator string

Logical operator for combining filters 

const (
	PrismObjectOrganizationQueryParamsQueryCombinatorAnd PrismObjectOrganizationQueryParamsQueryCombinator = "AND"
	PrismObjectOrganizationQueryParamsQueryCombinatorOr  PrismObjectOrganizationQueryParamsQueryCombinator = "OR"
)

func (PrismObjectOrganizationQueryParamsQueryCombinator) IsKnown 

func (r PrismObjectOrganizationQueryParamsQueryCombinator) IsKnown() bool

type PrismObjectOrganizationQueryParamsQueryFilter added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilter struct {
	Equals param.Field[PrismObjectOrganizationQueryParamsQueryFilterUnion] `json:"=" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilter) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterBeginsWith added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterBeginsWith struct {
	BeginsWith param.Field[string] `json:"begins_with" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterBeginsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterEndsWith added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterEndsWith struct {
	EndsWith param.Field[string] `json:"ends_with" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterEndsWith) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterExists added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterExists struct {
	Exists param.Field[bool] `json:"exists" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterExists) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterIn added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterIn struct {
	In param.Field[[]string] `json:"in" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterIn) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterLikeRegex added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterLikeRegex struct {
	LikeRegex param.Field[string] `json:"like_regex" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterLikeRegex) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterNotContains added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterNotContains struct {
	NotContains param.Field[string] `json:"not_contains" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterNotContains) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterNotExists added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterNotExists struct {
	NotExists param.Field[bool] `json:"not_exists" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterNotExists) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterNotIn added in v0.3.0 

type PrismObjectOrganizationQueryParamsQueryFilterNotIn struct {
	NotIn param.Field[[]string] `json:"not_in" api:"required"`
}

func (PrismObjectOrganizationQueryParamsQueryFilterNotIn) MarshalJSON added in v0.3.0 

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

type PrismObjectOrganizationQueryParamsQueryFilterUnion 

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

Satisfied by PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilter, PrismObjectOrganizationQueryParamsQueryFilterLikeRegex, PrismObjectOrganizationQueryParamsQueryFilterBeginsWith, PrismObjectOrganizationQueryParamsQueryFilterEndsWith, PrismObjectOrganizationQueryParamsQueryFilterNotContains, PrismObjectOrganizationQueryParamsQueryFilterExists, PrismObjectOrganizationQueryParamsQueryFilterNotExists, PrismObjectOrganizationQueryParamsQueryFilterIn, PrismObjectOrganizationQueryParamsQueryFilterNotIn, PrismObjectOrganizationQueryParamsQueryFilter.

type PrismObjectOrganizationQueryParamsQuerySort 

type PrismObjectOrganizationQueryParamsQuerySort string
const (
	PrismObjectOrganizationQueryParamsQuerySortAsc  PrismObjectOrganizationQueryParamsQuerySort = "asc"
	PrismObjectOrganizationQueryParamsQuerySortDesc PrismObjectOrganizationQueryParamsQuerySort = "desc"
)

func (PrismObjectOrganizationQueryParamsQuerySort) IsKnown 

func (r PrismObjectOrganizationQueryParamsQuerySort) IsKnown() bool

type PrismObjectOrganizationQueryResponse 

type PrismObjectOrganizationQueryResponse struct {
	Data []PrismObjectOrganizationQueryResponseData `json:"data" api:"required"`
	// True when the page returned the maximum number of rows; another page may exist.
	HasMore bool                                     `json:"has_more"`
	JSON    prismObjectOrganizationQueryResponseJSON `json:"-"`
}

func (*PrismObjectOrganizationQueryResponse) UnmarshalJSON 

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

type PrismObjectOrganizationQueryResponseData added in v0.2.0 

type PrismObjectOrganizationQueryResponseData struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                       `json:"default"`
	List    interface{}                                  `json:"list"`
	JSON    prismObjectOrganizationQueryResponseDataJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectOrganizationQueryResponseData) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationRestoreParams added in v0.2.0 

type PrismObjectOrganizationRestoreParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type PrismObjectOrganizationRestoreResponse added in v0.2.0 

type PrismObjectOrganizationRestoreResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                     `json:"default"`
	List    interface{}                                `json:"list"`
	JSON    prismObjectOrganizationRestoreResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectOrganizationRestoreResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationService 

type PrismObjectOrganizationService struct {
	Options []option.RequestOption
}

PrismObjectOrganizationService contains methods and other services that help with interacting with the micro 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 NewPrismObjectOrganizationService method instead.

func NewPrismObjectOrganizationService 

func NewPrismObjectOrganizationService(opts ...option.RequestOption) (r *PrismObjectOrganizationService)

NewPrismObjectOrganizationService 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 (*PrismObjectOrganizationService) BulkNew added in v0.2.0 

func (r *PrismObjectOrganizationService) BulkNew(ctx context.Context, params PrismObjectOrganizationBulkNewParams, opts ...option.RequestOption) (res *PrismObjectOrganizationBulkNewResponse, err error)

Import multiple objects in batch. Properties are keyed by slug. Automatically routes based on size: <100 records sync (immediate response), >=100 records async (S3/Lambda with WebSocket progress)

func (*PrismObjectOrganizationService) Delete added in v0.2.0 

func (r *PrismObjectOrganizationService) Delete(ctx context.Context, organizationID string, body PrismObjectOrganizationDeleteParams, opts ...option.RequestOption) (err error)

Delete object

func (*PrismObjectOrganizationService) Duplicate added in v0.2.0 

func (r *PrismObjectOrganizationService) Duplicate(ctx context.Context, organizationID string, body PrismObjectOrganizationDuplicateParams, opts ...option.RequestOption) (res *PrismObjectOrganizationDuplicateResponse, err error)

Duplicate object

func (*PrismObjectOrganizationService) Get added in v0.2.0 

func (r *PrismObjectOrganizationService) Get(ctx context.Context, organizationID string, query PrismObjectOrganizationGetParams, opts ...option.RequestOption) (res *PrismObjectOrganizationGetResponse, err error)

Get object

func (*PrismObjectOrganizationService) New added in v0.2.0 

func (r *PrismObjectOrganizationService) New(ctx context.Context, params PrismObjectOrganizationNewParams, opts ...option.RequestOption) (res *PrismObjectOrganizationNewResponse, err error)

Create object

func (*PrismObjectOrganizationService) Query 

func (r *PrismObjectOrganizationService) Query(ctx context.Context, params PrismObjectOrganizationQueryParams, opts ...option.RequestOption) (res *PrismObjectOrganizationQueryResponse, err error)

Query

func (*PrismObjectOrganizationService) Restore added in v0.2.0 

func (r *PrismObjectOrganizationService) Restore(ctx context.Context, organizationID string, body PrismObjectOrganizationRestoreParams, opts ...option.RequestOption) (res *PrismObjectOrganizationRestoreResponse, err error)

Restore object

func (*PrismObjectOrganizationService) Update added in v0.2.0 

func (r *PrismObjectOrganizationService) Update(ctx context.Context, organizationID string, params PrismObjectOrganizationUpdateParams, opts ...option.RequestOption) (res *PrismObjectOrganizationUpdateResponse, err error)

Patch object

type PrismObjectOrganizationUpdateParams added in v0.2.0 

type PrismObjectOrganizationUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID                param.Field[string]        `path:"teamId" api:"required" format:"uuid"`
	PrismObjectProperties PrismObjectPropertiesParam `json:"prism_object_properties" api:"required"`
}

func (PrismObjectOrganizationUpdateParams) MarshalJSON added in v0.2.0 

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

type PrismObjectOrganizationUpdateResponse added in v0.2.0 

type PrismObjectOrganizationUpdateResponse struct {
	ID string `json:"id" api:"required" format:"uuid"`
	// Properties keyed by property slug.
	Default map[string]interface{}                    `json:"default"`
	List    interface{}                               `json:"list"`
	JSON    prismObjectOrganizationUpdateResponseJSON `json:"-"`
}

Object returned by reads (get/create/patch/restore). id is always present.

func (*PrismObjectOrganizationUpdateResponse) UnmarshalJSON added in v0.2.0 

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

type PrismObjectPropertiesParam 

type PrismObjectPropertiesParam struct {
	// Properties keyed by property slug. Values can be strings, numbers, booleans,
	// arrays, or null. For select/multiselect properties, values may be option slugs
	// or option UUIDs on write; option slugs are returned on read.
	Default param.Field[map[string]interface{}] `json:"default"`
	List    param.Field[interface{}]            `json:"list"`
}

func (PrismObjectPropertiesParam) MarshalJSON 

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

type PrismObjectService 

type PrismObjectService struct {
	Options       []option.RequestOption
	Contacts      *PrismObjectContactService
	Organizations *PrismObjectOrganizationService
	Identities    *PrismObjectIdentityService
	Deals         *PrismObjectDealService
	Actions       *PrismObjectActionService
	Documents     *PrismObjectDocumentService
	Events        *PrismObjectEventService
}

PrismObjectService contains methods and other services that help with interacting with the micro 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 NewPrismObjectService method instead.

func NewPrismObjectService 

func NewPrismObjectService(opts ...option.RequestOption) (r *PrismObjectService)

NewPrismObjectService 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 PrismService 

type PrismService struct {
	Options  []option.RequestOption
	Metadata *PrismMetadataService
	Objects  *PrismObjectService
}

PrismService contains methods and other services that help with interacting with the micro 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 NewPrismService method instead.

func NewPrismService 

func NewPrismService(opts ...option.RequestOption) (r *PrismService)

NewPrismService 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 ViewDeleteParams 

type ViewDeleteParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type ViewDeleteParamsViewObjectType 

type ViewDeleteParamsViewObjectType string
const (
	ViewDeleteParamsViewObjectTypeAction       ViewDeleteParamsViewObjectType = "action"
	ViewDeleteParamsViewObjectTypeDeal         ViewDeleteParamsViewObjectType = "deal"
	ViewDeleteParamsViewObjectTypeDocument     ViewDeleteParamsViewObjectType = "document"
	ViewDeleteParamsViewObjectTypeEvent        ViewDeleteParamsViewObjectType = "event"
	ViewDeleteParamsViewObjectTypeIdentity     ViewDeleteParamsViewObjectType = "identity"
	ViewDeleteParamsViewObjectTypeOrganization ViewDeleteParamsViewObjectType = "organization"
)

func (ViewDeleteParamsViewObjectType) IsKnown 

func (r ViewDeleteParamsViewObjectType) IsKnown() bool

type ViewGetParams 

type ViewGetParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type ViewGetParamsViewObjectType 

type ViewGetParamsViewObjectType string
const (
	ViewGetParamsViewObjectTypeAction       ViewGetParamsViewObjectType = "action"
	ViewGetParamsViewObjectTypeDeal         ViewGetParamsViewObjectType = "deal"
	ViewGetParamsViewObjectTypeDocument     ViewGetParamsViewObjectType = "document"
	ViewGetParamsViewObjectTypeEvent        ViewGetParamsViewObjectType = "event"
	ViewGetParamsViewObjectTypeIdentity     ViewGetParamsViewObjectType = "identity"
	ViewGetParamsViewObjectTypeOrganization ViewGetParamsViewObjectType = "organization"
)

func (ViewGetParamsViewObjectType) IsKnown 

func (r ViewGetParamsViewObjectType) IsKnown() bool

type ViewGetResponse 

type ViewGetResponse struct {
	Name                 string                    `json:"name" api:"required"`
	ViewType             string                    `json:"view_type" api:"required"`
	ID                   string                    `json:"id" format:"uuid"`
	AggregationPropDefID string                    `json:"aggregation_prop_def_id" api:"nullable" format:"uuid"`
	AggregationType      string                    `json:"aggregation_type" api:"nullable"`
	ColumnLayout         map[string]interface{}    `json:"column_layout" api:"nullable"`
	Combinator           ViewGetResponseCombinator `json:"combinator"`
	CreatedAt            string                    `json:"created_at"`
	// Each entry is { slug: { comparator: value } }
	Filter []map[string]interface{} `json:"filter"`
	// Property slug to group by
	GroupBy              string        `json:"group_by" api:"nullable"`
	GroupHiddenOptionIDs []interface{} `json:"group_hidden_option_ids" api:"nullable"`
	GroupHideEmpty       bool          `json:"group_hide_empty" api:"nullable"`
	GroupSort            string        `json:"group_sort" api:"nullable"`
	Icon                 string        `json:"icon" api:"nullable"`
	ListID               string        `json:"list_id" api:"nullable" format:"uuid"`
	// Property slugs (dot-paths permitted for refs)
	Select []string `json:"select"`
	// Each entry is { slug: 'asc' | 'desc' }
	Sort      []map[string]interface{} `json:"sort"`
	SortOrder int64                    `json:"sort_order" api:"nullable"`
	TeamID    string                   `json:"team_id" api:"nullable" format:"uuid"`
	UpdatedAt string                   `json:"updated_at" api:"nullable"`
	UserID    string                   `json:"user_id" api:"nullable"`
	JSON      viewGetResponseJSON      `json:"-"`
}

A view (saved configuration for displaying records of a given object type) plus its select/filter/sort children. Properties in select/filter/sort are referenced by slug.

func (*ViewGetResponse) UnmarshalJSON 

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

type ViewGetResponseCombinator 

type ViewGetResponseCombinator string
const (
	ViewGetResponseCombinatorAnd ViewGetResponseCombinator = "AND"
	ViewGetResponseCombinatorOr  ViewGetResponseCombinator = "OR"
)

func (ViewGetResponseCombinator) IsKnown 

func (r ViewGetResponseCombinator) IsKnown() bool

type ViewNewParams 

type ViewNewParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID           param.Field[string]                  `path:"teamId" api:"required" format:"uuid"`
	Name                 param.Field[string]                  `json:"name" api:"required"`
	ViewType             param.Field[string]                  `json:"view_type" api:"required"`
	ID                   param.Field[string]                  `json:"id" format:"uuid"`
	AggregationPropDefID param.Field[string]                  `json:"aggregation_prop_def_id" format:"uuid"`
	AggregationType      param.Field[string]                  `json:"aggregation_type"`
	ColumnLayout         param.Field[map[string]interface{}]  `json:"column_layout"`
	Combinator           param.Field[ViewNewParamsCombinator] `json:"combinator"`
	CreatedAt            param.Field[string]                  `json:"created_at"`
	// Each entry is { slug: { comparator: value } }
	Filter param.Field[[]map[string]interface{}] `json:"filter"`
	// Property slug to group by
	GroupBy              param.Field[string]        `json:"group_by"`
	GroupHiddenOptionIDs param.Field[[]interface{}] `json:"group_hidden_option_ids"`
	GroupHideEmpty       param.Field[bool]          `json:"group_hide_empty"`
	GroupSort            param.Field[string]        `json:"group_sort"`
	Icon                 param.Field[string]        `json:"icon"`
	ListID               param.Field[string]        `json:"list_id" format:"uuid"`
	// Property slugs (dot-paths permitted for refs)
	Select param.Field[[]string] `json:"select"`
	// Each entry is { slug: 'asc' | 'desc' }
	Sort       param.Field[[]map[string]interface{}] `json:"sort"`
	SortOrder  param.Field[int64]                    `json:"sort_order"`
	BodyTeamID param.Field[string]                   `json:"team_id" format:"uuid"`
	UpdatedAt  param.Field[string]                   `json:"updated_at"`
	UserID     param.Field[string]                   `json:"user_id"`
}

func (ViewNewParams) MarshalJSON 

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

type ViewNewParamsCombinator 

type ViewNewParamsCombinator string
const (
	ViewNewParamsCombinatorAnd ViewNewParamsCombinator = "AND"
	ViewNewParamsCombinatorOr  ViewNewParamsCombinator = "OR"
)

func (ViewNewParamsCombinator) IsKnown 

func (r ViewNewParamsCombinator) IsKnown() bool

type ViewNewParamsViewObjectType 

type ViewNewParamsViewObjectType string
const (
	ViewNewParamsViewObjectTypeAction       ViewNewParamsViewObjectType = "action"
	ViewNewParamsViewObjectTypeDeal         ViewNewParamsViewObjectType = "deal"
	ViewNewParamsViewObjectTypeDocument     ViewNewParamsViewObjectType = "document"
	ViewNewParamsViewObjectTypeEvent        ViewNewParamsViewObjectType = "event"
	ViewNewParamsViewObjectTypeIdentity     ViewNewParamsViewObjectType = "identity"
	ViewNewParamsViewObjectTypeOrganization ViewNewParamsViewObjectType = "organization"
)

func (ViewNewParamsViewObjectType) IsKnown 

func (r ViewNewParamsViewObjectType) IsKnown() bool

type ViewNewResponse 

type ViewNewResponse struct {
	Name                 string                    `json:"name" api:"required"`
	ViewType             string                    `json:"view_type" api:"required"`
	ID                   string                    `json:"id" format:"uuid"`
	AggregationPropDefID string                    `json:"aggregation_prop_def_id" api:"nullable" format:"uuid"`
	AggregationType      string                    `json:"aggregation_type" api:"nullable"`
	ColumnLayout         map[string]interface{}    `json:"column_layout" api:"nullable"`
	Combinator           ViewNewResponseCombinator `json:"combinator"`
	CreatedAt            string                    `json:"created_at"`
	// Each entry is { slug: { comparator: value } }
	Filter []map[string]interface{} `json:"filter"`
	// Property slug to group by
	GroupBy              string        `json:"group_by" api:"nullable"`
	GroupHiddenOptionIDs []interface{} `json:"group_hidden_option_ids" api:"nullable"`
	GroupHideEmpty       bool          `json:"group_hide_empty" api:"nullable"`
	GroupSort            string        `json:"group_sort" api:"nullable"`
	Icon                 string        `json:"icon" api:"nullable"`
	ListID               string        `json:"list_id" api:"nullable" format:"uuid"`
	// Property slugs (dot-paths permitted for refs)
	Select []string `json:"select"`
	// Each entry is { slug: 'asc' | 'desc' }
	Sort      []map[string]interface{} `json:"sort"`
	SortOrder int64                    `json:"sort_order" api:"nullable"`
	TeamID    string                   `json:"team_id" api:"nullable" format:"uuid"`
	UpdatedAt string                   `json:"updated_at" api:"nullable"`
	UserID    string                   `json:"user_id" api:"nullable"`
	JSON      viewNewResponseJSON      `json:"-"`
}

A view (saved configuration for displaying records of a given object type) plus its select/filter/sort children. Properties in select/filter/sort are referenced by slug.

func (*ViewNewResponse) UnmarshalJSON 

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

type ViewNewResponseCombinator 

type ViewNewResponseCombinator string
const (
	ViewNewResponseCombinatorAnd ViewNewResponseCombinator = "AND"
	ViewNewResponseCombinatorOr  ViewNewResponseCombinator = "OR"
)

func (ViewNewResponseCombinator) IsKnown 

func (r ViewNewResponseCombinator) IsKnown() bool

type ViewRecordListParams 

type ViewRecordListParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
	Limit  param.Field[int64]  `query:"limit"`
	Page   param.Field[int64]  `query:"page"`
}

func (ViewRecordListParams) URLQuery 

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

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

type ViewRecordListParamsViewObjectType 

type ViewRecordListParamsViewObjectType string
const (
	ViewRecordListParamsViewObjectTypeAction       ViewRecordListParamsViewObjectType = "action"
	ViewRecordListParamsViewObjectTypeDeal         ViewRecordListParamsViewObjectType = "deal"
	ViewRecordListParamsViewObjectTypeDocument     ViewRecordListParamsViewObjectType = "document"
	ViewRecordListParamsViewObjectTypeEvent        ViewRecordListParamsViewObjectType = "event"
	ViewRecordListParamsViewObjectTypeIdentity     ViewRecordListParamsViewObjectType = "identity"
	ViewRecordListParamsViewObjectTypeOrganization ViewRecordListParamsViewObjectType = "organization"
)

func (ViewRecordListParamsViewObjectType) IsKnown 

func (r ViewRecordListParamsViewObjectType) IsKnown() bool

type ViewRecordListResponse 

type ViewRecordListResponse map[string]interface{}

type ViewRecordPinParams 

type ViewRecordPinParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type ViewRecordPinParamsViewObjectType 

type ViewRecordPinParamsViewObjectType string
const (
	ViewRecordPinParamsViewObjectTypeAction       ViewRecordPinParamsViewObjectType = "action"
	ViewRecordPinParamsViewObjectTypeDeal         ViewRecordPinParamsViewObjectType = "deal"
	ViewRecordPinParamsViewObjectTypeDocument     ViewRecordPinParamsViewObjectType = "document"
	ViewRecordPinParamsViewObjectTypeEvent        ViewRecordPinParamsViewObjectType = "event"
	ViewRecordPinParamsViewObjectTypeIdentity     ViewRecordPinParamsViewObjectType = "identity"
	ViewRecordPinParamsViewObjectTypeOrganization ViewRecordPinParamsViewObjectType = "organization"
)

func (ViewRecordPinParamsViewObjectType) IsKnown 

func (r ViewRecordPinParamsViewObjectType) IsKnown() bool

type ViewRecordReorderParams 

type ViewRecordReorderParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID    param.Field[string]   `path:"teamId" api:"required" format:"uuid"`
	ObjectIDs param.Field[[]string] `json:"object_ids" api:"required" format:"uuid"`
}

func (ViewRecordReorderParams) MarshalJSON 

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

type ViewRecordReorderParamsViewObjectType 

type ViewRecordReorderParamsViewObjectType string
const (
	ViewRecordReorderParamsViewObjectTypeAction       ViewRecordReorderParamsViewObjectType = "action"
	ViewRecordReorderParamsViewObjectTypeDeal         ViewRecordReorderParamsViewObjectType = "deal"
	ViewRecordReorderParamsViewObjectTypeDocument     ViewRecordReorderParamsViewObjectType = "document"
	ViewRecordReorderParamsViewObjectTypeEvent        ViewRecordReorderParamsViewObjectType = "event"
	ViewRecordReorderParamsViewObjectTypeIdentity     ViewRecordReorderParamsViewObjectType = "identity"
	ViewRecordReorderParamsViewObjectTypeOrganization ViewRecordReorderParamsViewObjectType = "organization"
)

func (ViewRecordReorderParamsViewObjectType) IsKnown 

func (r ViewRecordReorderParamsViewObjectType) IsKnown() bool

type ViewRecordService 

type ViewRecordService struct {
	Options []option.RequestOption
}

ViewRecordService contains methods and other services that help with interacting with the micro 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 NewViewRecordService method instead.

func NewViewRecordService 

func NewViewRecordService(opts ...option.RequestOption) (r *ViewRecordService)

NewViewRecordService 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 (*ViewRecordService) List 

func (r *ViewRecordService) List(ctx context.Context, viewObjectType ViewRecordListParamsViewObjectType, viewID string, params ViewRecordListParams, opts ...option.RequestOption) (res *[]ViewRecordListResponse, err error)

List records selected by a view (filters and sorts applied; pinned record_order overlaid first)

func (*ViewRecordService) Pin 

func (r *ViewRecordService) Pin(ctx context.Context, viewObjectType ViewRecordPinParamsViewObjectType, viewID string, objectID string, body ViewRecordPinParams, opts ...option.RequestOption) (err error)

Pin a record to the view (append to record_order)

func (*ViewRecordService) Reorder 

func (r *ViewRecordService) Reorder(ctx context.Context, viewObjectType ViewRecordReorderParamsViewObjectType, viewID string, params ViewRecordReorderParams, opts ...option.RequestOption) (err error)

Bulk reorder pinned records

func (*ViewRecordService) Unpin 

func (r *ViewRecordService) Unpin(ctx context.Context, viewObjectType ViewRecordUnpinParamsViewObjectType, viewID string, objectID string, body ViewRecordUnpinParams, opts ...option.RequestOption) (err error)

Unpin a record from the view

type ViewRecordUnpinParams 

type ViewRecordUnpinParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	TeamID param.Field[string] `path:"teamId" api:"required" format:"uuid"`
}

type ViewRecordUnpinParamsViewObjectType 

type ViewRecordUnpinParamsViewObjectType string
const (
	ViewRecordUnpinParamsViewObjectTypeAction       ViewRecordUnpinParamsViewObjectType = "action"
	ViewRecordUnpinParamsViewObjectTypeDeal         ViewRecordUnpinParamsViewObjectType = "deal"
	ViewRecordUnpinParamsViewObjectTypeDocument     ViewRecordUnpinParamsViewObjectType = "document"
	ViewRecordUnpinParamsViewObjectTypeEvent        ViewRecordUnpinParamsViewObjectType = "event"
	ViewRecordUnpinParamsViewObjectTypeIdentity     ViewRecordUnpinParamsViewObjectType = "identity"
	ViewRecordUnpinParamsViewObjectTypeOrganization ViewRecordUnpinParamsViewObjectType = "organization"
)

func (ViewRecordUnpinParamsViewObjectType) IsKnown 

func (r ViewRecordUnpinParamsViewObjectType) IsKnown() bool

type ViewService 

type ViewService struct {
	Options []option.RequestOption
	Records *ViewRecordService
}

ViewService contains methods and other services that help with interacting with the micro 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 NewViewService method instead.

func NewViewService 

func NewViewService(opts ...option.RequestOption) (r *ViewService)

NewViewService 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 (*ViewService) Delete 

func (r *ViewService) Delete(ctx context.Context, viewObjectType ViewDeleteParamsViewObjectType, viewID string, body ViewDeleteParams, opts ...option.RequestOption) (err error)

Delete a view bundle

func (*ViewService) Get 

func (r *ViewService) Get(ctx context.Context, viewObjectType ViewGetParamsViewObjectType, viewID string, query ViewGetParams, opts ...option.RequestOption) (res *ViewGetResponse, err error)

Read a view bundle

func (*ViewService) New 

func (r *ViewService) New(ctx context.Context, viewObjectType ViewNewParamsViewObjectType, params ViewNewParams, opts ...option.RequestOption) (res *ViewNewResponse, err error)

Create a view bundle (view + select/filter/sort)

func (*ViewService) Update 

func (r *ViewService) Update(ctx context.Context, viewObjectType ViewUpdateParamsViewObjectType, viewID string, params ViewUpdateParams, opts ...option.RequestOption) (res *ViewUpdateResponse, err error)

Update a view bundle (select/filter/sort arrays are replaced wholesale when supplied)

type ViewUpdateParams 

type ViewUpdateParams struct {
	// Use [option.WithTeamID] on the client to set a global default for this field.
	PathTeamID           param.Field[string]                     `path:"teamId" api:"required" format:"uuid"`
	AggregationPropDefID param.Field[string]                     `json:"aggregation_prop_def_id" format:"uuid"`
	AggregationType      param.Field[string]                     `json:"aggregation_type"`
	ColumnLayout         param.Field[map[string]interface{}]     `json:"column_layout"`
	Combinator           param.Field[ViewUpdateParamsCombinator] `json:"combinator"`
	Filter               param.Field[[]map[string]interface{}]   `json:"filter"`
	GroupBy              param.Field[string]                     `json:"group_by"`
	GroupHiddenOptionIDs param.Field[[]interface{}]              `json:"group_hidden_option_ids"`
	GroupHideEmpty       param.Field[bool]                       `json:"group_hide_empty"`
	GroupSort            param.Field[string]                     `json:"group_sort"`
	Icon                 param.Field[string]                     `json:"icon"`
	ListID               param.Field[string]                     `json:"list_id" format:"uuid"`
	Name                 param.Field[string]                     `json:"name"`
	Select               param.Field[[]string]                   `json:"select"`
	Sort                 param.Field[[]map[string]interface{}]   `json:"sort"`
	SortOrder            param.Field[int64]                      `json:"sort_order"`
	BodyTeamID           param.Field[string]                     `json:"team_id" format:"uuid"`
	UserID               param.Field[string]                     `json:"user_id"`
	ViewType             param.Field[string]                     `json:"view_type"`
}

func (ViewUpdateParams) MarshalJSON 

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

type ViewUpdateParamsCombinator 

type ViewUpdateParamsCombinator string
const (
	ViewUpdateParamsCombinatorAnd ViewUpdateParamsCombinator = "AND"
	ViewUpdateParamsCombinatorOr  ViewUpdateParamsCombinator = "OR"
)

func (ViewUpdateParamsCombinator) IsKnown 

func (r ViewUpdateParamsCombinator) IsKnown() bool

type ViewUpdateParamsViewObjectType 

type ViewUpdateParamsViewObjectType string
const (
	ViewUpdateParamsViewObjectTypeAction       ViewUpdateParamsViewObjectType = "action"
	ViewUpdateParamsViewObjectTypeDeal         ViewUpdateParamsViewObjectType = "deal"
	ViewUpdateParamsViewObjectTypeDocument     ViewUpdateParamsViewObjectType = "document"
	ViewUpdateParamsViewObjectTypeEvent        ViewUpdateParamsViewObjectType = "event"
	ViewUpdateParamsViewObjectTypeIdentity     ViewUpdateParamsViewObjectType = "identity"
	ViewUpdateParamsViewObjectTypeOrganization ViewUpdateParamsViewObjectType = "organization"
)

func (ViewUpdateParamsViewObjectType) IsKnown 

func (r ViewUpdateParamsViewObjectType) IsKnown() bool

type ViewUpdateResponse 

type ViewUpdateResponse struct {
	Name                 string                       `json:"name" api:"required"`
	ViewType             string                       `json:"view_type" api:"required"`
	ID                   string                       `json:"id" format:"uuid"`
	AggregationPropDefID string                       `json:"aggregation_prop_def_id" api:"nullable" format:"uuid"`
	AggregationType      string                       `json:"aggregation_type" api:"nullable"`
	ColumnLayout         map[string]interface{}       `json:"column_layout" api:"nullable"`
	Combinator           ViewUpdateResponseCombinator `json:"combinator"`
	CreatedAt            string                       `json:"created_at"`
	// Each entry is { slug: { comparator: value } }
	Filter []map[string]interface{} `json:"filter"`
	// Property slug to group by
	GroupBy              string        `json:"group_by" api:"nullable"`
	GroupHiddenOptionIDs []interface{} `json:"group_hidden_option_ids" api:"nullable"`
	GroupHideEmpty       bool          `json:"group_hide_empty" api:"nullable"`
	GroupSort            string        `json:"group_sort" api:"nullable"`
	Icon                 string        `json:"icon" api:"nullable"`
	ListID               string        `json:"list_id" api:"nullable" format:"uuid"`
	// Property slugs (dot-paths permitted for refs)
	Select []string `json:"select"`
	// Each entry is { slug: 'asc' | 'desc' }
	Sort      []map[string]interface{} `json:"sort"`
	SortOrder int64                    `json:"sort_order" api:"nullable"`
	TeamID    string                   `json:"team_id" api:"nullable" format:"uuid"`
	UpdatedAt string                   `json:"updated_at" api:"nullable"`
	UserID    string                   `json:"user_id" api:"nullable"`
	JSON      viewUpdateResponseJSON   `json:"-"`
}

A view (saved configuration for displaying records of a given object type) plus its select/filter/sort children. Properties in select/filter/sort are referenced by slug.

func (*ViewUpdateResponse) UnmarshalJSON 

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

type ViewUpdateResponseCombinator 

type ViewUpdateResponseCombinator string
const (
	ViewUpdateResponseCombinatorAnd ViewUpdateResponseCombinator = "AND"
	ViewUpdateResponseCombinatorOr  ViewUpdateResponseCombinator = "OR"
)

func (ViewUpdateResponseCombinator) IsKnown 

func (r ViewUpdateResponseCombinator) IsKnown() bool

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
param
requestconfig
testutil

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.