common

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

type Association struct {
	// ObjectID is the ID of the associated object.
	ObjectId string `json:"objectId"`
	// AssociationType is the type of association.
	AssociationType string         `json:"associationType,omitempty"`
	Raw             map[string]any `json:"raw,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 CollapsedSubscriptionEvent interface {
	SubscriptionEventList() ([]SubscriptionEvent, error)
	RawMap() (map[string]any, error)
}

type ConnectorParams struct {
	Module ModuleID

	// AuthenticatedClient is a 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
}

type CustomAuthClientOption func(params *customClientParams)

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
}

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 ErrorHandler func(rsp *http.Response, body []byte) error

type ErrorPostProcessor struct {
	Process func(err error) 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 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

	// 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
}

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 HTTPClient struct {
	Base            string                  // optional base URL. If not set, then all URLs must be absolute.
	Client          AuthenticatedHTTPClient // underlying HTTP client. Required.
	ErrorHandler    ErrorHandler            // optional error handler. If not set, then the default error handler is used.
	ResponseHandler ResponseHandler         // optional, Allows mutation of the http.Response from the Saas API response.
}

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 []SubscriptionEventType
	// ["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
	Filter string // 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
}

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. Currently only populated for hubspot GetRecord and GetRecordsWithId function
	Id string `json:"id,omitempty"`
}

type RecordTransformer func(node *ajson.Node) (map[string]any, 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 RequireMetadata struct {
	ExpectedMetadataKeys []string
}

type RequireModule struct {
	ExpectedModules []ModuleID
}

type RequireWorkspace struct{}

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

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 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 map[ObjectName]ObjectEvents
}

type SubscriptionEvent interface {
	EventType() (SubscriptionEventType, error)
	RawEventName() (string, error)
	ObjectName() (string, error)
	Workspace() (string, error)
	RecordId() (string, error)
	EventTimeStampNano() (int64, error)
	RawMap() (map[string]any, error)
}

type SubscriptionEventType string

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

type SubscriptionResult struct {
	Result       any
	ObjectEvents map[ObjectName]ObjectEvents
	Status       SubscriptionStatus

	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
	// GetUpdatedFields returns the fields that were updated in the event.
	UpdatedFields() ([]string, error)
}

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 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
}

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