common

type AWSClient struct {
	// contains filtered or unexported fields
}

type Association struct {
	// ObjectID is the ID of the associated object.
	ObjectId string         `json:"objectId"`
	Raw      map[string]any `json:"raw,omitempty"`
	// ProviderAssociationMetadata holds provider-specific metadata about the association type.
	// For HubSpot, this includes category, typeId, and label from the associations API.
	ProviderAssociationMetadata map[string]any `json:"providerAssociationMetadata,omitempty"`
}

type AssociationCardinality string

type AssociationDefinition struct {
	// AssociationType is the high-level association variety (e.g., 'foreignKey', 'lookup', 'ref').
	// The provider determines the exact behavior.
	AssociationType string `json:"associationType"`
	// TargetObject is the name of the referenced/parent object.
	TargetObject string `json:"targetObject"`
	// TargetField is the name of the referenced field on the target object.
	// Defaults to the target's primary key when omitted.
	TargetField string `json:"targetField,omitempty"`
	// Association cardinality from the referencing field's perspective (e.g., 'many-to-one', 'one-to-one').
	Cardinality AssociationCardinality `json:"cardinality,omitempty"`
	// OnDelete defines the behavior upon foreign object deletion, where supported.
	// E.g., 'cascade', 'restrict', 'setNull'.
	OnDelete AssociationOnDeleteAction `json:"onDelete,omitempty"`
	// Required means that, if true, a referenced record must exist (i.e., NOT NULL foreign key).
	Required bool `json:"required,omitempty"`
	// ReverseLookupFieldName is an optional inverse relationship/property name exposed on the target object.
	ReverseLookupFieldName string `json:"reverseLookupFieldName,omitempty"`
	// Labels represents optional UI labels for the association
	Labels *AssociationLabels `json:"labels,omitempty"`
}

type AssociationLabels struct {
	Singular string `json:"singular"`
	Plural   string `json:"plural"`
}

type AssociationOnDeleteAction string

type AuthToken string

type AuthenticatedHTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
	CloseIdleConnections()
}

type BatchItem struct {
	Record       map[string]any
	Associations any
}

type BatchItems []BatchItem

type BatchPolicy struct {
	// AllOrNone controls whether partial success is allowed.
	// When true, if any record fails, the entire batch is rolled back.
	// When false (default), successful records are committed even if others fail.
	// If nil, defaults to false (partial success allowed).
	AllOrNone *bool `json:"allOrNone,omitempty"`
}

type BatchStatus string

type BatchWriteParam struct {
	// ObjectName identifies the target object for the write operation.
	ObjectName ObjectName
	// Type defines how the records should be processed: create, update, or upsert.
	Type WriteType
	// Batch contains the collection of record payloads to be written.
	Batch BatchItems
	// Headers contains additional headers to be added to the request.
	Headers []WriteHeader // optional
	// Policy configures batch write behavior (partial success, etc.)
	Policy *BatchPolicy
	// Deprecated: Use Policy.AllOrNone instead.
	AllOrNone *bool
}

type BatchWriteResponseMatcher[P, R any] func(index int, payloadItem P) *R

type BatchWriteResponseTransformer[P, R any] func(payloadItem P, respItem *R) (*WriteResult, error)

type BatchWriteResult struct {
	// Status summarizes the batch outcome (success, failure, or partial).
	Status BatchStatus
	// Errors lists top-level errors that are not tied to specific records.
	// While errors that are specific to certain records are found in Results[i].Errors
	Errors []any
	// Results contains the detailed outcomes for each record in the batch.
	Results []WriteResult
	// SuccessCount is the number of successfully written records.
	SuccessCount int `json:"successCount"`
	// FailureCount is the number of failed records.
	FailureCount int `json:"failureCount"`
}

type Classifier interface {
	ErrorClass() ErrorClass
}

type CollapsedSubscriptionEvent interface {
	Event

	// SubscriptionEventList collapses the event response into the list of messages.
	// In case of an error returns ErrSubscriptionEventList.
	SubscriptionEventList() ([]SubscriptionEvent, error)
}

type ConnectorParams struct {
	Module ModuleID

	// AuthenticatedClient is an HTTP client for the connector that knows how to handle authentication for the provider.
	AuthenticatedClient AuthenticatedHTTPClient

	// Workspace is the provider workspace that the connector is connecting to. It could be a part of the metadata
	// map, but it is a common enough field that it is included here.
	Workspace string

	// Metadata is a map of key-value pairs that can be used to pass in additional information to the connector.
	// Generally this is used to substitute placeholders in the providerInfo, like workspace, server, etc, which is
	// information that is specific to the connection.
	Metadata map[string]string

	// CustomAuthenticatedClient [optional] is useful for connectors that work over non-http protocols or want
	// to use custom non-http clients. Connectors that need this will know to check for it & use it if available.
	CustomAuthenticatedClient any
}

type CustomAuthClientOption func(params *customClientParams)

type DeleteMetadataParams struct {
	// Maps object names to field names to delete.
	// For example: {"Account": ["My_Custom_Field__c", "Another_Field__c"]}
	Fields map[ObjectName][]string `json:"fields"`
}

type DeleteMetadataResult struct {
	// Indicates if the delete operation was successful.
	Success bool `json:"success"`
}

type DeleteParams struct {
	// The name of the object we are deleting, e.g. "Account"
	ObjectName string // required

	// The external ID of the object instance we are removing.
	RecordId string // required

	// Headers contains additional headers to be added to the delete request.
	Headers []WriteHeader // optional
}

type DeleteResult struct {
	// Success is true if deletion succeeded.
	Success bool `json:"success"`
}

type DynamicHeadersGenerator func(*http.Request) ([]Header, error)

type DynamicQueryParamsGenerator func(*http.Request) (QueryParams, error)

type ErrorClass string

type ErrorHandler func(rsp *http.Response, body []byte) error

type ErrorPostProcessor struct {
	Process func(err error) error
}

type Event interface {
	RawMap() (map[string]any, error)
}

type FieldDefinition struct {
	// FieldName is the identifier of the field, e.g. "My_Custom_Field".
	FieldName string `json:"fieldName"`
	// DisplayName is the human-readable name of the field, e.g. "My Custom Field".
	DisplayName string `json:"displayName"`
	// Description is an optional description of the field.
	Description string `json:"description,omitempty"`
	// ValueType is the data type of the field.
	ValueType FieldType `json:"valueType"`
	// Required indicates if the field is required.
	Required bool `json:"required,omitempty"`
	// Unique indicates if the field must be unique across all records.
	Unique bool `json:"unique,omitempty"`
	// Indexed indicates if the field should be indexed for faster search.
	Indexed bool `json:"indexed,omitempty"`
	// StringOptions contains additional options for string fields (if any).
	StringOptions *StringFieldOptions `json:"stringOptions,omitempty"`
	// NumericOptions contains additional options for numeric fields (if any).
	NumericOptions *NumericFieldOptions `json:"numericOptions,omitempty"`
	// Association defines association/relationship information for the field (if any).
	Association *AssociationDefinition `json:"association,omitempty"`
}

type FieldFilter struct {
	FieldName string         `json:"fieldName" validate:"required"`
	Operator  FilterOperator `json:"operator"  validate:"required"`
	Value     any            `json:"value"     validate:"required"`
}

type FieldMetadata struct {
	// DisplayName is a human-readable field name.
	DisplayName string

	// ValueType is a set of Ampersand defined field types.
	ValueType ValueType

	// ProviderType is the raw type, a term used by provider API.
	// Each is mapped to an Ampersand ValueType.
	ProviderType string

	// ReadOnly would indicate if field can be modified or only read.
	ReadOnly *bool

	// IsCustom indicates whether the field is user-defined or custom.
	// True means the field was added by the user, false means it is native to the provider.
	IsCustom *bool

	// IsRequired indicates whether a value for the field is mandatory
	// when creating or updating the object.
	// True means the field must have a value, false means it is optional.
	IsRequired *bool

	// FieldId is the provider's unique identifier for this field.
	// It is nil when the provider does not expose field identifiers.
	FieldId *string //nolint:revive

	// Values is a list of possible values for this field.
	// It is applicable only if the type is either singleSelect or multiSelect, otherwise slice is nil.
	Values []FieldValue

	// ReferenceTo is the list of object types this field references.
	// It is applicable only if the ProviderType is "reference" (i.e. a lookup field), otherwise nil.
	ReferenceTo []string
}

type FieldType string

type FieldUpsertResult struct {
	// FieldName is the name of the field.
	FieldName string `json:"fieldName"`
	// Action indicates what action was taken (create, update, none).
	Action UpsertMetadataAction `json:"action"`
	// Metadata contains provider-specific metadata about the field (if any).
	// Specific keys/values will vary by provider. Considered strictly informational.
	Metadata map[string]any `json:"metadata,omitempty"`
	// Warnings contains any warnings that occurred during the upsert operation,
	// such as unsupported field attributes.
	Warnings []string `json:"warnings,omitempty"`
}

type FieldValue struct {
	Value        string
	DisplayValue string
}

type FieldValues []FieldValue

type FieldsMetadata map[string]FieldMetadata

type FilterOperator string

type HTTPClient struct {
	// [Deprecated] URL endpoints are not the responsibility of HTTPClient.
	// NOTE: to avoid linter errors the deprecation comment is not of correct golang formatting.
	// Optional base URL. If unset, all request URLs must be absolute.
	Base string
	// Underlying HTTP client. Required.
	Client AuthenticatedHTTPClient
	// Optional ErrorHandler. If not set, then the default error handler is used.
	ErrorHandler ErrorHandler
	// Optional ResponseHandler, allowing mutation of the http.Response returned by the SaaS API.
	ResponseHandler ResponseHandler
	// Optional predicate deciding whether the ErrorHandler should be invoked.
	ShouldHandleError ShouldHandleError
}

type HTTPError struct {
	// Status is the original HTTP status.
	Status int

	// Headers are the HTTP headers of the response, if available.
	Headers Headers // optional

	// Body is the raw response body, if available.
	Body []byte // optional
	// contains filtered or unexported fields
}

type Header struct {
	Key   string     `json:"key"`
	Value string     `json:"value"`
	Mode  HeaderMode `json:"mode"`
}

type HeaderAuthClientOption func(params *headerClientParams)

type HeaderMode int

type Headers []Header

type JSONHTTPClient struct {
	HTTPClient         *HTTPClient        // underlying HTTP client. Required.
	ErrorPostProcessor ErrorPostProcessor // Errors returned from CRUD methods will go via this method. Optional.
}

type JSONHTTPResponse struct {

	// Code is the HTTP status code of the response.
	Code int

	// Headers are the HTTP headers of the response.
	Headers http.Header
	// contains filtered or unexported fields
}

type ListObjectMetadataResult struct {
	// Result is a map of object names to object metadata
	Result map[string]ObjectMetadata

	// Errors is a map of object names to errors
	Errors map[string]error
}

type MarshalFromNodeFunc func(records []*ajson.Node, fields []string) ([]ReadResultRow, error)

type MarshalFunc func(records []map[string]any, fields []string) ([]ReadResultRow, error)

type Module struct {
	ID      ModuleID
	Label   string // e.g. "crm"
	Version string // e.g. "v3"
}

type ModuleID = string

type ModuleObjectNameToFieldName map[ModuleID]datautils.DefaultMap[string, string]

type Modules = datautils.Map[ModuleID, Module]

type NextPageFunc func(*ajson.Node) (string, error)

type NextPageToken string

type NodeRecordsFunc func(*ajson.Node) ([]*ajson.Node, error)

type NumericFieldOptions struct {
	// Precision is the total number of digits (for decimal types).
	Precision *int `json:"precision,omitempty"`
	// Scale is the number of digits to the right of the decimal point (for decimal types).
	Scale *int `json:"scale,omitempty"`
	// Min is the minimum value for numeric fields (if any).
	Min *float64 `json:"min,omitempty"`
	// Max is the maximum value for numeric fields (if any).
	Max *float64 `json:"max,omitempty"`
	// DefaultValue is the default value for the field (if any).
	DefaultValue *float64 `json:"defaultValue,omitempty"`
}

type OAuthOption func(*oauthClientParams)

type ObjectEvents struct {
	// ["create", "update", "delete"] our regular CRUD operation events
	// we translate to provider-specific names contact.creation
	Events SubscriptionEventTypes
	// ["email", "fax"] fields to watch for an update subscription
	WatchFields []string
	// true if all fields should be watched for an update subscription
	// this is provider specific, and not all providers support this.
	WatchFieldsAll bool
	// any non CRUD operations with provider specific event names
	// eg)  ["contact.merged"] for hubspot or ["jira_issue:restored", "jira_issue:archived"] for jira.
	PassThroughEvents []string
}

type ObjectMetadata struct {
	// Provider's display name for the object.
	DisplayName string

	// Fields is a map of field names to FieldMetadata.
	// Some legacy connectors do not populate this, but only populates FieldsMap.
	Fields FieldsMetadata

	// Deprecated: for new connectors, please only populate and read `ObjectMetadata.Fields`.
	// FieldsMap is a map of field names to field display names.
	// TODO: Remove this field once all connectors populate Fields.
	FieldsMap map[string]string
}

type ObjectName string

type PostAuthInfo struct {
	CatalogVars          *map[string]string
	RawResponse          *JSONHTTPResponse
	ProviderWorkspaceRef string
}

type PrintablePayload struct {
	Base64          bool   `json:"base64,omitempty"`
	Content         string `json:"content"`
	Length          int64  `json:"length"`
	TruncatedLength int64  `json:"truncatedLength,omitempty"`
}

type ProviderReadResponseType interface {
	map[string]any | *ajson.Node
}

type QueryParam struct {
	Key   string         `json:"key"`
	Value string         `json:"value"`
	Mode  QueryParamMode `json:"mode"`
}

type QueryParamAuthClientOption func(params *queryParamClientParams)

type QueryParamMode int

type QueryParams []QueryParam

type ReadParams struct {
	// The name of the object we are reading, e.g. "Account"
	ObjectName string // required

	// The fields we are reading from the object, e.g. ["Id", "Name", "BillingCity"]
	Fields datautils.StringSet // required, at least one field needed

	// NextPage is an opaque token that can be used to get the next page of results.
	NextPage NextPageToken // optional, only set this if you want to read the next page of results

	// Since is an optional timestamp to fetch only records updated **after** this time.
	// Used for incremental reads.
	Since time.Time

	// Until is an optional timestamp to fetch only records updated **up to and including** this time.
	// Pagination stops when records exceed this timestamp.
	Until time.Time

	// Deleted is true if we want to read deleted records instead of active records.
	Deleted bool // optional, defaults to false

	// Filter defines the filtering criteria for supported connectors.
	// It is optional and behaves differently depending on the connector:
	//	* Salesforce: It is a SOQL string that comes after the WHERE clause which will be used to filter the records.
	//		Reference: https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql.htm
	//	* Klaviyo: Comma separated methods following JSON:API filtering syntax.
	//		Note: timing is already handled by Since argument.
	//		Reference: https://developers.klaviyo.com/en/docs/filtering_
	//	* Marketo: Comma-separated activityTypeIds for filtering lead activities.
	//		Note: Only supported when reading Lead Activities (not other endpoints).
	//		Example: "1,6,12" (for visitWebpage, fillOutForm, emailClicked)
	//		Reference: https://developer.adobe.com/marketo-apis/api/mapi/#tag/Activities
	//  * GetResponse: An ampersand-style filter string that maps directly to GetResponse's
	//      bracket-notation query parameters. Supports both `query[...]` and `sort[...]`.
	//      Multiple filters can be separated by '&'.
	//      Examples:
	//          - "query[name]=campaign_name"
	//          - "query[isDefault]=true"
	//          - "sort[name]=ASC"
	//          - "sort[createdOn]=DESC"
	//          - "query[name]=test&sort[createdOn]=DESC"
	//      Reference: https://apireference.getresponse.com/#operation/getCampaignList
	Filter string // optional

	// BuilderFilter is an optional Ampersand-style structured filter for read actions.
	// Multiple field filters are joined by AND. Only the "eq" operator is supported.
	BuilderFilter *SearchFilter // optional

	// AssociatedObjects specifies a list of related objects to fetch along with the main object.
	// It is optional and supported by the following connectors:
	//	* HubSpot: Supported in Read operation, but not Search.
	//	* Stripe: Only nested objects can be expanded. Specify a dot-separated path
	//		to the property to fetch and expand those objects.
	//		Reference: https://docs.stripe.com/expand#how-it-works
	//	* Capsule: Embeds objects in response.
	//		Reference: https://developer.capsulecrm.com/v2/overview/reading-from-the-api
	AssociatedObjects []string // optional

	// PageSize specifies the # of records to request when making a read request.
	PageSize int // optional

	// Additional options for the read operation that the connector may support.
	// This optional map is used for bespoke connector-specific parameters.
	Opts ReadParamsOpts // optional
}

type ReadParamsOpts any

type ReadResult struct {
	// Rows is the number of total rows in the result.
	Rows int64 `json:"rows"`
	// Data is an array where each element represents a ReadResultRow.
	Data []ReadResultRow `json:"data"`
	// NextPage is an opaque token that can be used to get the next page of results.
	NextPage NextPageToken `json:"nextPage,omitempty"`
	// Done is true if there are no more pages to read.
	Done bool `json:"done,omitempty"`
}

type ReadResultRow struct {
	// Fields is a map of requested provider field names to values.
	// All field names are in lowercase (eg: accountid, name, billingcityid)
	Fields map[string]any `json:"fields"`
	// Associations is a map of associated objects to the main object.
	// The key is the associated object name, and the value is an array of associated object ids.
	Associations map[string][]Association `json:"associations,omitempty"`
	// Raw is the raw JSON response from the provider.
	Raw map[string]any `json:"raw"`
	// RecordId is the ID of the record.
	Id string `json:"id,omitempty"`
}

type Record map[string]any

type RecordCountParams struct {
	// ObjectName is the name of the object to count records for.
	ObjectName string

	// SinceTimestamp is an optional timestamp to count only records updated after this time.
	SinceTimestamp *time.Time

	// UntilTimestamp is an optional timestamp to count only records updated up to this time.
	UntilTimestamp *time.Time
}

type RecordCountResult struct {
	// Count is the number of records matching the query.
	Count int
}

type RecordTransformer func(node *ajson.Node) (map[string]any, error)

type RecordsFilterFunc func(ReadParams, *ajson.Node, []*ajson.Node) ([]*ajson.Node, string, error)

type RecordsFunc func(*ajson.Node) ([]map[string]any, error)

type RegistrationResult struct {
	RegistrationRef string
	Result          any // struct depends on the provider
	Status          RegistrationStatus
}

type RegistrationStatus string

type RequestModifier func(req *http.Request)

type RequireAuthenticatedClient struct{}

type RequireCustomAuthenticatedClient struct{}

type RequireMetadata struct {
	ExpectedMetadataKeys []string
}

type RequireModule struct {
	ExpectedModules []ModuleID
}

type RequireWorkspace struct{}

type ResponseHandler func(rsp *http.Response) (*http.Response, error)

type SearchFilter struct {
	// multiple filters are joined by `and` by default.
	FieldFilters []FieldFilter `json:"fieldFilters" validate:"required,dive"`
}

type SearchParams struct {
	ObjectName string `json:"objectName" validate:"required"`

	// Fields to return in the search result.
	Fields   datautils.StringSet `json:"fields"             validate:"required"`
	Filter   SearchFilter        `json:"filter"             validate:"required"`
	NextPage NextPageToken       `json:"nextPage,omitempty"`

	// Page Limit for the search. If omitted, return provider's default limit.
	Limit int64 `json:"limit,omitempty"`

	// AssociatedObjects specifies a list of related objects to fetch along with the main object.
	// Optional.
	AssociatedObjects []string `json:"associatedObjects,omitempty"`
}

type SearchResult = ReadResult

type ShouldHandleError func(response *http.Response) bool

type StringFieldOptions struct {
	// Length is the maximum length of the string field.
	Length *int `json:"length,omitempty"`
	// Pattern is a regex pattern that the string field value must match (if any).
	Pattern string `json:"pattern,omitempty"`
	// Values is a list of allowed values for enum fields (if any).
	Values []string `json:"values,omitempty"`
	// ValuesRestricted indicates if the field value must be limited to what's in Values.
	ValuesRestricted bool `json:"valuesRestricted,omitempty"`
	// DefaultValue is the default value for the field (if any).
	DefaultValue *string `json:"defaultValue,omitempty"`
	// NumDisplayLines defines how many lines of text are shown in the UI.
	// If the text exceeds this number, it will be truncated.
	NumDisplayLines *int `json:"lines,omitempty"`
}

type StringMap map[string]any

type SubscribeParams struct {
	// Request contains provider-specific parameters that are unique to each subscription.
	// These parameters can be either optional or required depending on the provider's API requirements.
	// Each provider defines its own request structure (e.g., webhook URL, secret, unique reference, etc.)
	// that must be provided when creating subscriptions. The structure is provider-specific and should
	// match the provider's expected request format for subscription operations.
	Request any
	// RegistrationResult is the result of the Connector.Register call.
	// Connector.Subscribe requires information from the registration.
	// Not all providers require registration, so this is optional.
	// eg) Salesforce and HubSpot require registration because
	RegistrationResult *RegistrationResult
	// SubscriptionEvents is a normalized view representing the exact subscription state
	// that should be maintained in the provider's system. This field specifies which
	// objects and events the caller wants to subscribe to, using a provider-agnostic
	// format. Connector.Subscribe method will translate these normalized events to its own event
	// naming conventions when creating subscriptions. This represents the desired
	// state, which may differ from the actual state returned in SubscriptionResult.ObjectEvents
	// if some subscription operations fail or are rolled back.
	SubscriptionEvents map[ObjectName]ObjectEvents
}

type SubscriptionEvent interface {
	Event

	EventType() (SubscriptionEventType, error)
	RawEventName() (string, error)
	ObjectName() (string, error)
	Workspace() (string, error)
	RecordId() (string, error)
	EventTimeStampNano() (int64, error)

	// PreLoadData is used to preload data into the subscription event.
	// Assume that the data will include the entire request body in case it is needed for the event processing.
	// This method will be called for every event as the first step in the event processing.
	PreLoadData(data *SubscriptionEventPreLoadData) error
}

type SubscriptionEventPreLoadData struct {
	RequestHeaders *http.Header
}

type SubscriptionEventType string

type SubscriptionEventTypes []SubscriptionEventType

type SubscriptionEventWithRecord interface {
	SubscriptionEvent

	// Record returns the single record carried inline in the webhook payload as a
	// ReadResultRow, marshaled the same way a read returns it: Raw holds the full
	// provider record and Fields holds the requested subset (lowercased), selected
	// from the given fields. This lets callers map the inline record exactly like a
	// fetched read, without a GetRecordsByIds call.
	Record(fields []string) (ReadResultRow, error)
}

type SubscriptionRegistrationParams struct {
	Request any `json:"request" validate:"required"`
}

type SubscriptionResult struct {
	// Result contains the provider's original response data in its raw form.
	// This field preserves the complete, unmodified response from the provider's API,
	// allowing callers to access all original metadata, IDs, timestamps, and other
	// provider-specific information that may not be represented in the transformed ObjectEvents.
	// The structure of Result is provider-specific and should match the provider's actual API response format.
	Result any
	// ObjectEvents represents the transformed view of the subscription state after the operation.
	// This field contains a normalized, provider-agnostic representation of which objects and events
	// are currently subscribed in the provider's system. It reflects the exact state after
	// creating, updating, or deleting subscriptions, and may differ from the requested subscriptions
	// if some operations failed or were rolled back. This transformed view is useful for tracking
	// the actual subscription state without needing to parse provider-specific response formats.
	ObjectEvents map[ObjectName]ObjectEvents
	Status       SubscriptionStatus

	// Below fields are soon to be DEPRECATED, and will be removed in a future release.
	// Use ObjectEvents instead.
	Objects []ObjectName
	Events  []SubscriptionEventType
	// ["create", "update", "delete"]
	// our regular CRUD operation events we translate to provider-specific names contact.creation
	UpdateFields []string
	// ["email", "fax"]
	PassThroughEvents []string
}

type SubscriptionStatus string

type SubscriptionUpdateEvent interface {
	SubscriptionEvent

	// UpdatedFields returns the fields that were updated in the event.
	UpdatedFields() ([]string, error)
}

type TokenHeaderAttachment struct {
	Name   string
	Prefix string
}

type TokenSourceWithContext interface {
	oauth2.TokenSource

	// TokenWithContext returns a token or an error.
	// Token must be safe for concurrent use by multiple goroutines.
	// The returned Token must not be modified.
	// Similar semantics to oauth2.TokenSource, but with a context.
	TokenWithContext(ctx context.Context) (*oauth2.Token, error)
}

type UpsertMetadataAction string

type UpsertMetadataParams struct {
	// Maps object names to field definitions.
	Fields map[string][]FieldDefinition `json:"fields"`
}

type UpsertMetadataResult struct {
	// Indicates if the upsert operation was successful.
	Success bool `json:"success"`

	// Maps object name -> field name -> upsert result.
	Fields map[string]map[string]FieldUpsertResult `json:"fields"`
}

type ValueType string

type VerificationParams struct {
	Param any
}

type WebhookRequest struct {
	Headers http.Header
	Body    []byte
	URL     string
	Method  string
}

type WriteHeader struct {
	Key   string
	Value string
}

type WriteMethod func(context.Context, string, any, ...Header) (*JSONHTTPResponse, error)

type WriteParams struct {
	// The name of the object we are writing, e.g. "Account"
	ObjectName string // required

	// The external ID of the object instance we are updating. Provided in the case of UPDATE, but not CREATE.
	RecordId string // optional

	// RecordData is a JSON node representing the record of data we want to insert in the case of CREATE
	// or fields of data we want to modify in case of an update
	RecordData any // required

	// Associations contains associations between the object and other objects.
	Associations any // optional

	Headers []WriteHeader // optional
}

type WriteResult struct {
	// Success is true if write succeeded.
	Success bool `json:"success"`
	// RecordId is the ID of the written record.
	RecordId string `json:"recordId,omitempty"` // optional
	// Errors is list of error record returned by the API.
	Errors []any `json:"errors,omitempty"` // optional
	// Data is a JSON node containing data about the properties that were updated.
	Data map[string]any `json:"data,omitempty"` // optional
}

type WriteType string

type XMLAttributes struct {
	Key   string `json:"key"   validate:"required,excludesall=<>,excludesrune=<>"`
	Value string `json:"value" validate:"excludesall=<>,excludesrune=<>"`
}

type XMLData struct {
	XMLName     string           `json:"xmlName,omitempty"     validate:"required,excludesall=<>"`
	Attributes  []*XMLAttributes `json:"attributes,omitempty"`
	Children    []XMLSchema      `json:"children,omitempty"`
	SelfClosing bool             `json:"selfClosing,omitempty"`
}

type XMLHTTPClient struct {
	HTTPClient         *HTTPClient        // underlying HTTP client. Required.
	ErrorPostProcessor ErrorPostProcessor // Errors returned from CRUD methods will go via this method. Optional.
}

type XMLHTTPResponse struct {

	// Code is the HTTP status code of the response.
	Code int

	// Headers are the HTTP headers of the response.
	Headers http.Header

	// Body is the unmarshalled response body in XML form. Content is the same as bodyBytes
	Body *xquery.XML
	// contains filtered or unexported fields
}

type XMLSchema interface {
	String() string
	Validate() error
}

type XMLString string