monitor.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package contextdev

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"slices"
	"time"

	"github.com/context-dot-dev/context-go-sdk/v2/internal/apijson"
	"github.com/context-dot-dev/context-go-sdk/v2/internal/apiquery"
	"github.com/context-dot-dev/context-go-sdk/v2/internal/requestconfig"
	"github.com/context-dot-dev/context-go-sdk/v2/option"
	"github.com/context-dot-dev/context-go-sdk/v2/packages/param"
	"github.com/context-dot-dev/context-go-sdk/v2/packages/respjson"
	"github.com/context-dot-dev/context-go-sdk/v2/shared/constant"
)

// Watch websites for exact or meaningful changes.
//
// MonitorService contains methods and other services that help with interacting
// with the context.dev 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 [NewMonitorService] method instead.
type MonitorService struct {
	options []option.RequestOption
}

// NewMonitorService 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 NewMonitorService(opts ...option.RequestOption) (r MonitorService) {
	r = MonitorService{}
	r.options = opts
	return
}

// Watch a page, URL inventory, or extracted website data on a schedule. A run
// starts immediately to capture the baseline.
func (r *MonitorService) New(ctx context.Context, body MonitorNewParams, opts ...option.RequestOption) (res *MonitorNewResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
	return res, err
}

// Retrieve a monitor’s configuration and current state.
func (r *MonitorService) Get(ctx context.Context, monitorID string, opts ...option.RequestOption) (res *MonitorGetResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
	return res, err
}

// Update a monitor. Changing its target or change detection replaces the baseline
// and queues a new baseline run.
func (r *MonitorService) Update(ctx context.Context, monitorID string, body MonitorUpdateParams, opts ...option.RequestOption) (res *MonitorUpdateResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPatch, path, body, &res, opts...)
	return res, err
}

// List your monitors with optional search and filters.
func (r *MonitorService) List(ctx context.Context, query MonitorListParams, opts ...option.RequestOption) (res *MonitorListResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// Delete a monitor and stop future runs and webhook retries.
func (r *MonitorService) Delete(ctx context.Context, monitorID string, opts ...option.RequestOption) (res *MonitorDeleteResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
	return res, err
}

// Return usage per monitor, highest first, for up to the 10,000 most recent runs
// in the requested window.
func (r *MonitorService) GetCreditUsage(ctx context.Context, query MonitorGetCreditUsageParams, opts ...option.RequestOption) (res *MonitorGetCreditUsageResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors/credit-usage"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// Retrieve your organization’s monitor allowance and usage.
func (r *MonitorService) GetLimits(ctx context.Context, opts ...option.RequestOption) (res *MonitorGetLimitsResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors/limits"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
	return res, err
}

// List full change records across your monitors, newest first.
func (r *MonitorService) ListAccountChanges(ctx context.Context, query MonitorListAccountChangesParams, opts ...option.RequestOption) (res *MonitorListAccountChangesResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors/changes"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// List runs across your monitors, newest first.
func (r *MonitorService) ListAccountRuns(ctx context.Context, query MonitorListAccountRunsParams, opts ...option.RequestOption) (res *MonitorListAccountRunsResponse, err error) {
	opts = slices.Concat(r.options, opts)
	path := "monitors/runs"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// List full change records for a monitor, newest first.
func (r *MonitorService) ListChanges(ctx context.Context, monitorID string, query MonitorListChangesParams, opts ...option.RequestOption) (res *MonitorListChangesResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s/changes", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// List a monitor’s runs, newest first.
func (r *MonitorService) ListRuns(ctx context.Context, monitorID string, query MonitorListRunsParams, opts ...option.RequestOption) (res *MonitorListRunsResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s/runs", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// Retrieve a detected change, including its diff and available evidence.
func (r *MonitorService) GetChange(ctx context.Context, changeID string, opts ...option.RequestOption) (res *MonitorGetChangeResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if changeID == "" {
		err = errors.New("missing required change_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/changes/%s", url.PathEscape(changeID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
	return res, err
}

// Retrieve the status, timing, and results of one monitor run.
func (r *MonitorService) GetRun(ctx context.Context, runID string, query MonitorGetRunParams, opts ...option.RequestOption) (res *MonitorGetRunResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if query.MonitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	if runID == "" {
		err = errors.New("missing required run_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s/runs/%s", url.PathEscape(query.MonitorID), url.PathEscape(runID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
	return res, err
}

// Generate and return a new signing secret. It takes effect immediately for all
// subsequent delivery attempts.
func (r *MonitorService) RotateWebhookSecret(ctx context.Context, monitorID string, opts ...option.RequestOption) (res *MonitorRotateWebhookSecretResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s/webhook/rotate-secret", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
	return res, err
}

// Queue a run without changing the regular schedule. Paused monitors return 409.
func (r *MonitorService) Run(ctx context.Context, monitorID string, opts ...option.RequestOption) (res *MonitorRunResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if monitorID == "" {
		err = errors.New("missing required monitor_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("monitors/%s/run", url.PathEscape(monitorID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
	return res, err
}

type WebhookDelivery struct {
	AttemptedAt time.Time            `json:"attempted_at" api:"required" format:"date-time"`
	Error       WebhookDeliveryError `json:"error" api:"required"`
	// The event this delivery carried. Deliveries recorded before event selection
	// existed report change.detected.
	//
	// Any of "change.detected", "run.completed".
	Event WebhookDeliveryEvent `json:"event" api:"required"`
	// Identifier sent in the X-Context-Id header.
	EventID string `json:"event_id" api:"required"`
	// The endpoint's final HTTP response status, or null when no response was
	// received.
	HTTPStatus int64 `json:"http_status" api:"required"`
	// Outcome of the delivery attempt. Any 2xx response counts as delivered.
	//
	// Any of "delivered", "rejected", "failed", "skipped_unsafe_url".
	Status WebhookDeliveryStatus `json:"status" api:"required"`
	// Delivery ID for status checks and retries, when available.
	DeliveryID string `json:"delivery_id"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AttemptedAt respjson.Field
		Error       respjson.Field
		Event       respjson.Field
		EventID     respjson.Field
		HTTPStatus  respjson.Field
		Status      respjson.Field
		DeliveryID  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r WebhookDelivery) RawJSON() string { return r.JSON.raw }
func (r *WebhookDelivery) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type WebhookDeliveryError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r WebhookDeliveryError) RawJSON() string { return r.JSON.raw }
func (r *WebhookDeliveryError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The event this delivery carried. Deliveries recorded before event selection
// existed report change.detected.
type WebhookDeliveryEvent string

const (
	WebhookDeliveryEventChangeDetected WebhookDeliveryEvent = "change.detected"
	WebhookDeliveryEventRunCompleted   WebhookDeliveryEvent = "run.completed"
)

// Outcome of the delivery attempt. Any 2xx response counts as delivered.
type WebhookDeliveryStatus string

const (
	WebhookDeliveryStatusDelivered        WebhookDeliveryStatus = "delivered"
	WebhookDeliveryStatusRejected         WebhookDeliveryStatus = "rejected"
	WebhookDeliveryStatusFailed           WebhookDeliveryStatus = "failed"
	WebhookDeliveryStatusSkippedUnsafeURL WebhookDeliveryStatus = "skipped_unsafe_url"
)

type MonitorNewResponse struct {
	ID string `json:"id" api:"required"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorNewResponseChangeDetectionUnion `json:"change_detection" api:"required"`
	CreatedAt       time.Time                              `json:"created_at" api:"required" format:"date-time"`
	// ID of the baseline run queued at creation; null if it will start on the next
	// scheduled tick.
	InitialRunID string `json:"initial_run_id" api:"required"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode MonitorNewResponseMode `json:"mode" api:"required"`
	Name string                 `json:"name" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Current state. Failed monitors keep running; paused monitors must be resumed
	// with `status: "active"`.
	//
	// Any of "active", "paused", "failed".
	Status MonitorNewResponseStatus `json:"status" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target    MonitorNewResponseTargetUnion `json:"target" api:"required"`
	UpdatedAt time.Time                     `json:"updated_at" api:"required" format:"date-time"`
	// Comparison baseline, included on Retrieve. Null until capture completes or after
	// target changes.
	Baseline MonitorNewResponseBaselineUnion `json:"baseline" api:"nullable"`
	// Credits this request used and your remaining balance.
	KeyMetadata  MonitorNewResponseKeyMetadata `json:"key_metadata"`
	LastChangeAt time.Time                     `json:"last_change_at" api:"nullable" format:"date-time"`
	// Error from the most recent failed run; null when the last run succeeded.
	LastError MonitorNewResponseLastError `json:"last_error" api:"nullable"`
	LastRunAt time.Time                   `json:"last_run_at" api:"nullable" format:"date-time"`
	// When the next scheduled run is due; null while paused.
	NextRunAt time.Time `json:"next_run_at" api:"nullable" format:"date-time"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorNewResponseSchedule `json:"schedule"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorNewResponseWebhook `json:"webhook" api:"nullable"`
	// Present while webhook deliveries are failing consecutively; null when deliveries
	// are healthy or no webhook is configured. Cleared on the next successful delivery
	// and when the webhook URL changes.
	WebhookFailure MonitorNewResponseWebhookFailure `json:"webhook_failure" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID              respjson.Field
		ChangeDetection respjson.Field
		CreatedAt       respjson.Field
		InitialRunID    respjson.Field
		Mode            respjson.Field
		Name            respjson.Field
		RequestID       respjson.Field
		Status          respjson.Field
		Target          respjson.Field
		UpdatedAt       respjson.Field
		Baseline        respjson.Field
		KeyMetadata     respjson.Field
		LastChangeAt    respjson.Field
		LastError       respjson.Field
		LastRunAt       respjson.Field
		NextRunAt       respjson.Field
		Schedule        respjson.Field
		Tags            respjson.Field
		Webhook         respjson.Field
		WebhookFailure  respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorNewResponseChangeDetectionUnion contains all possible properties and
// values from [MonitorNewResponseChangeDetectionExact],
// [MonitorNewResponseChangeDetectionSemantic].
//
// Use the [MonitorNewResponseChangeDetectionUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorNewResponseChangeDetectionUnion struct {
	// Any of "exact", "semantic".
	Type string `json:"type"`
	// This field is from variant [MonitorNewResponseChangeDetectionSemantic].
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	JSON                struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorNewResponseChangeDetection is implemented by each variant of
// [MonitorNewResponseChangeDetectionUnion] to add type safety for the return type
// of [MonitorNewResponseChangeDetectionUnion.AsAny]
type anyMonitorNewResponseChangeDetection interface {
	implMonitorNewResponseChangeDetectionUnion()
}

func (MonitorNewResponseChangeDetectionExact) implMonitorNewResponseChangeDetectionUnion()    {}
func (MonitorNewResponseChangeDetectionSemantic) implMonitorNewResponseChangeDetectionUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorNewResponseChangeDetectionUnion.AsAny().(type) {
//	case contextdev.MonitorNewResponseChangeDetectionExact:
//	case contextdev.MonitorNewResponseChangeDetectionSemantic:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorNewResponseChangeDetectionUnion) AsAny() anyMonitorNewResponseChangeDetection {
	switch u.Type {
	case "exact":
		return u.AsExact()
	case "semantic":
		return u.AsSemantic()
	}
	return nil
}

func (u MonitorNewResponseChangeDetectionUnion) AsExact() (v MonitorNewResponseChangeDetectionExact) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseChangeDetectionUnion) AsSemantic() (v MonitorNewResponseChangeDetectionSemantic) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorNewResponseChangeDetectionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorNewResponseChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
type MonitorNewResponseChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseChangeDetectionExact) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
type MonitorNewResponseChangeDetectionSemantic struct {
	// Use `semantic` to judge changes against the target instructions.
	Type constant.Semantic `json:"type" default:"semantic"`
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseChangeDetectionSemantic) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Always `web`. Optional.
type MonitorNewResponseMode string

const (
	MonitorNewResponseModeWeb MonitorNewResponseMode = "web"
)

// Current state. Failed monitors keep running; paused monitors must be resumed
// with `status: "active"`.
type MonitorNewResponseStatus string

const (
	MonitorNewResponseStatusActive MonitorNewResponseStatus = "active"
	MonitorNewResponseStatusPaused MonitorNewResponseStatus = "paused"
	MonitorNewResponseStatusFailed MonitorNewResponseStatus = "failed"
)

// MonitorNewResponseTargetUnion contains all possible properties and values from
// [MonitorNewResponseTargetPage], [MonitorNewResponseTargetSitemap],
// [MonitorNewResponseTargetExtract].
//
// Use the [MonitorNewResponseTargetUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorNewResponseTargetUnion struct {
	// Any of "page", "sitemap", "extract".
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [MonitorNewResponseTargetPage].
	Actions []MonitorNewResponseTargetPageActionUnion `json:"actions"`
	// This field is from variant [MonitorNewResponseTargetPage].
	ExcludeSelectors []string `json:"exclude_selectors"`
	// This field is from variant [MonitorNewResponseTargetPage].
	IncludeSelectors []string `json:"include_selectors"`
	Instructions     string   `json:"instructions"`
	// This field is from variant [MonitorNewResponseTargetPage].
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// This field is from variant [MonitorNewResponseTargetSitemap].
	Exclude []string `json:"exclude"`
	// This field is from variant [MonitorNewResponseTargetSitemap].
	Include []string `json:"include"`
	// This field is from variant [MonitorNewResponseTargetSitemap].
	MaxURLs int64 `json:"max_urls"`
	// This field is from variant [MonitorNewResponseTargetExtract].
	FollowSubdomains bool `json:"follow_subdomains"`
	// This field is from variant [MonitorNewResponseTargetExtract].
	MaxDepth int64 `json:"max_depth"`
	// This field is from variant [MonitorNewResponseTargetExtract].
	MaxPages int64 `json:"max_pages"`
	// This field is from variant [MonitorNewResponseTargetExtract].
	Schema map[string]any `json:"schema"`
	JSON   struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		Exclude             respjson.Field
		Include             respjson.Field
		MaxURLs             respjson.Field
		FollowSubdomains    respjson.Field
		MaxDepth            respjson.Field
		MaxPages            respjson.Field
		Schema              respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorNewResponseTarget is implemented by each variant of
// [MonitorNewResponseTargetUnion] to add type safety for the return type of
// [MonitorNewResponseTargetUnion.AsAny]
type anyMonitorNewResponseTarget interface {
	implMonitorNewResponseTargetUnion()
}

func (MonitorNewResponseTargetPage) implMonitorNewResponseTargetUnion()    {}
func (MonitorNewResponseTargetSitemap) implMonitorNewResponseTargetUnion() {}
func (MonitorNewResponseTargetExtract) implMonitorNewResponseTargetUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorNewResponseTargetUnion.AsAny().(type) {
//	case contextdev.MonitorNewResponseTargetPage:
//	case contextdev.MonitorNewResponseTargetSitemap:
//	case contextdev.MonitorNewResponseTargetExtract:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorNewResponseTargetUnion) AsAny() anyMonitorNewResponseTarget {
	switch u.Type {
	case "page":
		return u.AsPage()
	case "sitemap":
		return u.AsSitemap()
	case "extract":
		return u.AsExtract()
	}
	return nil
}

func (u MonitorNewResponseTargetUnion) AsPage() (v MonitorNewResponseTargetPage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseTargetUnion) AsSitemap() (v MonitorNewResponseTargetSitemap) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseTargetUnion) AsExtract() (v MonitorNewResponseTargetExtract) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorNewResponseTargetUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorNewResponseTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
type MonitorNewResponseTargetPage struct {
	// Use `page` to watch one web page.
	Type constant.Page `json:"type" default:"page"`
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorNewResponseTargetPageActionUnion `json:"actions" api:"nullable"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions string `json:"instructions"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetPage) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorNewResponseTargetPageActionUnion contains all possible properties and
// values from [MonitorNewResponseTargetPageActionWait],
// [MonitorNewResponseTargetPageActionPerform],
// [MonitorNewResponseTargetPageActionScroll].
//
// Use the [MonitorNewResponseTargetPageActionUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorNewResponseTargetPageActionUnion struct {
	// Any of "wait", "perform", "scroll".
	Do string `json:"do"`
	// This field is from variant [MonitorNewResponseTargetPageActionWait].
	TimeMs int64 `json:"timeMs"`
	// This field is from variant [MonitorNewResponseTargetPageActionPerform].
	Action string `json:"action"`
	// This field is from variant [MonitorNewResponseTargetPageActionScroll].
	Amount MonitorNewResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// This field is from variant [MonitorNewResponseTargetPageActionScroll].
	Container string `json:"container"`
	// This field is from variant [MonitorNewResponseTargetPageActionScroll].
	Direction string `json:"direction"`
	// This field is from variant [MonitorNewResponseTargetPageActionScroll].
	MaxScrolls int64 `json:"maxScrolls"`
	JSON       struct {
		Do         respjson.Field
		TimeMs     respjson.Field
		Action     respjson.Field
		Amount     respjson.Field
		Container  respjson.Field
		Direction  respjson.Field
		MaxScrolls respjson.Field
		raw        string
	} `json:"-"`
}

// anyMonitorNewResponseTargetPageAction is implemented by each variant of
// [MonitorNewResponseTargetPageActionUnion] to add type safety for the return type
// of [MonitorNewResponseTargetPageActionUnion.AsAny]
type anyMonitorNewResponseTargetPageAction interface {
	implMonitorNewResponseTargetPageActionUnion()
}

func (MonitorNewResponseTargetPageActionWait) implMonitorNewResponseTargetPageActionUnion()    {}
func (MonitorNewResponseTargetPageActionPerform) implMonitorNewResponseTargetPageActionUnion() {}
func (MonitorNewResponseTargetPageActionScroll) implMonitorNewResponseTargetPageActionUnion()  {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorNewResponseTargetPageActionUnion.AsAny().(type) {
//	case contextdev.MonitorNewResponseTargetPageActionWait:
//	case contextdev.MonitorNewResponseTargetPageActionPerform:
//	case contextdev.MonitorNewResponseTargetPageActionScroll:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorNewResponseTargetPageActionUnion) AsAny() anyMonitorNewResponseTargetPageAction {
	switch u.Do {
	case "wait":
		return u.AsWait()
	case "perform":
		return u.AsPerform()
	case "scroll":
		return u.AsScroll()
	}
	return nil
}

func (u MonitorNewResponseTargetPageActionUnion) AsWait() (v MonitorNewResponseTargetPageActionWait) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseTargetPageActionUnion) AsPerform() (v MonitorNewResponseTargetPageActionPerform) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseTargetPageActionUnion) AsScroll() (v MonitorNewResponseTargetPageActionScroll) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorNewResponseTargetPageActionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorNewResponseTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
type MonitorNewResponseTargetPageActionWait struct {
	// Use `wait` to pause for a fixed duration.
	Do constant.Wait `json:"do" default:"wait"`
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		TimeMs      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetPageActionWait) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
type MonitorNewResponseTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	Do constant.Perform `json:"do" default:"perform"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Do          respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetPageActionPerform) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
type MonitorNewResponseTargetPageActionScroll struct {
	// Use `scroll` to move through the page or a container.
	Do constant.Scroll `json:"do" default:"scroll"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorNewResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container string `json:"container"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls int64 `json:"maxScrolls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		Amount      respjson.Field
		Container   respjson.Field
		Direction   respjson.Field
		MaxScrolls  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetPageActionScroll) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorNewResponseTargetPageActionScrollAmountUnion contains all possible
// properties and values from [int64], [string].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfInt OfMonitorNewResponseTargetPageActionScrollAmountString]
type MonitorNewResponseTargetPageActionScrollAmountUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfMonitorNewResponseTargetPageActionScrollAmountString string `json:",inline"`
	JSON                                                   struct {
		OfInt                                                  respjson.Field
		OfMonitorNewResponseTargetPageActionScrollAmountString respjson.Field
		raw                                                    string
	} `json:"-"`
}

func (u MonitorNewResponseTargetPageActionScrollAmountUnion) AsInt() (v int64) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseTargetPageActionScrollAmountUnion) AsMonitorNewResponseTargetPageActionScrollAmountString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorNewResponseTargetPageActionScrollAmountUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorNewResponseTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorNewResponseTargetPageActionScrollAmountString string

const (
	MonitorNewResponseTargetPageActionScrollAmountStringViewport MonitorNewResponseTargetPageActionScrollAmountString = "viewport"
	MonitorNewResponseTargetPageActionScrollAmountStringMax      MonitorNewResponseTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
type MonitorNewResponseTargetSitemap struct {
	// Use `sitemap` to watch a site for added or removed URLs.
	Type constant.Sitemap `json:"type" default:"sitemap"`
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude"`
	// URL path patterns to include (max 50).
	Include []string `json:"include"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs int64 `json:"max_urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Exclude     respjson.Field
		Include     respjson.Field
		MaxURLs     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetSitemap) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
type MonitorNewResponseTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Use `extract` to watch structured data across selected pages.
	Type constant.Extract `json:"type" default:"extract"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains bool `json:"follow_subdomains"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth int64 `json:"max_depth"`
	// Maximum number of pages to track.
	MaxPages int64 `json:"max_pages"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions     respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		FollowSubdomains respjson.Field
		MaxDepth         respjson.Field
		MaxPages         respjson.Field
		Schema           respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseTargetExtract) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorNewResponseBaselineUnion contains all possible properties and values from
// [MonitorNewResponseBaselinePageBaseline],
// [MonitorNewResponseBaselineSitemapBaseline],
// [MonitorNewResponseBaselineExtractBaseline].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorNewResponseBaselineUnion struct {
	CapturedAt time.Time `json:"captured_at"`
	// This field is from variant [MonitorNewResponseBaselinePageBaseline].
	Text string `json:"text"`
	// This field is from variant [MonitorNewResponseBaselineSitemapBaseline].
	URLCount int64 `json:"url_count"`
	// This field is from variant [MonitorNewResponseBaselineSitemapBaseline].
	URLs []string `json:"urls"`
	// This field is from variant [MonitorNewResponseBaselineExtractBaseline].
	Data any `json:"data"`
	// This field is from variant [MonitorNewResponseBaselineExtractBaseline].
	URLsAnalyzed []string `json:"urls_analyzed"`
	JSON         struct {
		CapturedAt   respjson.Field
		Text         respjson.Field
		URLCount     respjson.Field
		URLs         respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		raw          string
	} `json:"-"`
}

func (u MonitorNewResponseBaselineUnion) AsPageBaseline() (v MonitorNewResponseBaselinePageBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseBaselineUnion) AsSitemapBaseline() (v MonitorNewResponseBaselineSitemapBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorNewResponseBaselineUnion) AsExtractBaseline() (v MonitorNewResponseBaselineExtractBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorNewResponseBaselineUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorNewResponseBaselineUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `page` monitor: the visible page text as last observed.
type MonitorNewResponseBaselinePageBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// The page's visible text as last observed.
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseBaselinePageBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseBaselinePageBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `sitemap` monitor: the normalized URL set as last
// observed.
type MonitorNewResponseBaselineSitemapBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Number of URLs in the baseline.
	URLCount int64 `json:"url_count" api:"required"`
	// The sitemap URLs as last observed (sorted, normalized).
	URLs []string `json:"urls" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		URLCount    respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseBaselineSitemapBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseBaselineSitemapBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of an `extract` monitor: the pages it tracks and the structured
// data as last extracted.
type MonitorNewResponseBaselineExtractBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Latest structured snapshot matching the extraction schema, refreshed at most
	// daily; `null` before capture.
	Data any `json:"data" api:"required"`
	// The page URLs the monitor tracks and analyzes for changes.
	URLsAnalyzed []string `json:"urls_analyzed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt   respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseBaselineExtractBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseBaselineExtractBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorNewResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Error from the most recent failed run; null when the last run succeeded.
type MonitorNewResponseLastError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseLastError) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseLastError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
type MonitorNewResponseSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Frequency   respjson.Field
		Type        respjson.Field
		Unit        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseSchedule) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
type MonitorNewResponseWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfig `json:"retry"`
	// API-generated signing secret. Visible only with full access or `monitors:write`
	// permission.
	Secret string `json:"secret"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		Events      respjson.Field
		Retry       respjson.Field
		Secret      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseWebhook) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Present while webhook deliveries are failing consecutively; null when deliveries
// are healthy or no webhook is configured. Cleared on the next successful delivery
// and when the webhook URL changes.
type MonitorNewResponseWebhookFailure struct {
	// Number of consecutive delivery attempts that did not succeed.
	ConsecutiveFailures int64     `json:"consecutive_failures" api:"required"`
	LastFailedAt        time.Time `json:"last_failed_at" api:"required" format:"date-time"`
	// Human-readable description of the most recent failure.
	LastMessage string `json:"last_message" api:"required"`
	// Outcome of the most recent failed delivery. rejected means a non-2xx response;
	// failed means no HTTP response was received; skipped_unsafe_url means the URL
	// failed the public-endpoint safety check.
	//
	// Any of "rejected", "failed", "skipped_unsafe_url".
	LastStatus string `json:"last_status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsecutiveFailures respjson.Field
		LastFailedAt        respjson.Field
		LastMessage         respjson.Field
		LastStatus          respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorNewResponseWebhookFailure) RawJSON() string { return r.JSON.raw }
func (r *MonitorNewResponseWebhookFailure) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetResponse struct {
	ID string `json:"id" api:"required"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorGetResponseChangeDetectionUnion `json:"change_detection" api:"required"`
	CreatedAt       time.Time                              `json:"created_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode MonitorGetResponseMode `json:"mode" api:"required"`
	Name string                 `json:"name" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Current state. Failed monitors keep running; paused monitors must be resumed
	// with `status: "active"`.
	//
	// Any of "active", "paused", "failed".
	Status MonitorGetResponseStatus `json:"status" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target    MonitorGetResponseTargetUnion `json:"target" api:"required"`
	UpdatedAt time.Time                     `json:"updated_at" api:"required" format:"date-time"`
	// Comparison baseline, included on Retrieve. Null until capture completes or after
	// target changes.
	Baseline MonitorGetResponseBaselineUnion `json:"baseline" api:"nullable"`
	// Credits this request used and your remaining balance.
	KeyMetadata  MonitorGetResponseKeyMetadata `json:"key_metadata"`
	LastChangeAt time.Time                     `json:"last_change_at" api:"nullable" format:"date-time"`
	// Error from the most recent failed run; null when the last run succeeded.
	LastError MonitorGetResponseLastError `json:"last_error" api:"nullable"`
	LastRunAt time.Time                   `json:"last_run_at" api:"nullable" format:"date-time"`
	// When the next scheduled run is due; null while paused.
	NextRunAt time.Time `json:"next_run_at" api:"nullable" format:"date-time"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorGetResponseSchedule `json:"schedule"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorGetResponseWebhook `json:"webhook" api:"nullable"`
	// Present while webhook deliveries are failing consecutively; null when deliveries
	// are healthy or no webhook is configured. Cleared on the next successful delivery
	// and when the webhook URL changes.
	WebhookFailure MonitorGetResponseWebhookFailure `json:"webhook_failure" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID              respjson.Field
		ChangeDetection respjson.Field
		CreatedAt       respjson.Field
		Mode            respjson.Field
		Name            respjson.Field
		RequestID       respjson.Field
		Status          respjson.Field
		Target          respjson.Field
		UpdatedAt       respjson.Field
		Baseline        respjson.Field
		KeyMetadata     respjson.Field
		LastChangeAt    respjson.Field
		LastError       respjson.Field
		LastRunAt       respjson.Field
		NextRunAt       respjson.Field
		Schedule        respjson.Field
		Tags            respjson.Field
		Webhook         respjson.Field
		WebhookFailure  respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorGetResponseChangeDetectionUnion contains all possible properties and
// values from [MonitorGetResponseChangeDetectionExact],
// [MonitorGetResponseChangeDetectionSemantic].
//
// Use the [MonitorGetResponseChangeDetectionUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorGetResponseChangeDetectionUnion struct {
	// Any of "exact", "semantic".
	Type string `json:"type"`
	// This field is from variant [MonitorGetResponseChangeDetectionSemantic].
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	JSON                struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorGetResponseChangeDetection is implemented by each variant of
// [MonitorGetResponseChangeDetectionUnion] to add type safety for the return type
// of [MonitorGetResponseChangeDetectionUnion.AsAny]
type anyMonitorGetResponseChangeDetection interface {
	implMonitorGetResponseChangeDetectionUnion()
}

func (MonitorGetResponseChangeDetectionExact) implMonitorGetResponseChangeDetectionUnion()    {}
func (MonitorGetResponseChangeDetectionSemantic) implMonitorGetResponseChangeDetectionUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorGetResponseChangeDetectionUnion.AsAny().(type) {
//	case contextdev.MonitorGetResponseChangeDetectionExact:
//	case contextdev.MonitorGetResponseChangeDetectionSemantic:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorGetResponseChangeDetectionUnion) AsAny() anyMonitorGetResponseChangeDetection {
	switch u.Type {
	case "exact":
		return u.AsExact()
	case "semantic":
		return u.AsSemantic()
	}
	return nil
}

func (u MonitorGetResponseChangeDetectionUnion) AsExact() (v MonitorGetResponseChangeDetectionExact) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseChangeDetectionUnion) AsSemantic() (v MonitorGetResponseChangeDetectionSemantic) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorGetResponseChangeDetectionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorGetResponseChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
type MonitorGetResponseChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseChangeDetectionExact) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
type MonitorGetResponseChangeDetectionSemantic struct {
	// Use `semantic` to judge changes against the target instructions.
	Type constant.Semantic `json:"type" default:"semantic"`
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseChangeDetectionSemantic) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Always `web`. Optional.
type MonitorGetResponseMode string

const (
	MonitorGetResponseModeWeb MonitorGetResponseMode = "web"
)

// Current state. Failed monitors keep running; paused monitors must be resumed
// with `status: "active"`.
type MonitorGetResponseStatus string

const (
	MonitorGetResponseStatusActive MonitorGetResponseStatus = "active"
	MonitorGetResponseStatusPaused MonitorGetResponseStatus = "paused"
	MonitorGetResponseStatusFailed MonitorGetResponseStatus = "failed"
)

// MonitorGetResponseTargetUnion contains all possible properties and values from
// [MonitorGetResponseTargetPage], [MonitorGetResponseTargetSitemap],
// [MonitorGetResponseTargetExtract].
//
// Use the [MonitorGetResponseTargetUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorGetResponseTargetUnion struct {
	// Any of "page", "sitemap", "extract".
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [MonitorGetResponseTargetPage].
	Actions []MonitorGetResponseTargetPageActionUnion `json:"actions"`
	// This field is from variant [MonitorGetResponseTargetPage].
	ExcludeSelectors []string `json:"exclude_selectors"`
	// This field is from variant [MonitorGetResponseTargetPage].
	IncludeSelectors []string `json:"include_selectors"`
	Instructions     string   `json:"instructions"`
	// This field is from variant [MonitorGetResponseTargetPage].
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// This field is from variant [MonitorGetResponseTargetSitemap].
	Exclude []string `json:"exclude"`
	// This field is from variant [MonitorGetResponseTargetSitemap].
	Include []string `json:"include"`
	// This field is from variant [MonitorGetResponseTargetSitemap].
	MaxURLs int64 `json:"max_urls"`
	// This field is from variant [MonitorGetResponseTargetExtract].
	FollowSubdomains bool `json:"follow_subdomains"`
	// This field is from variant [MonitorGetResponseTargetExtract].
	MaxDepth int64 `json:"max_depth"`
	// This field is from variant [MonitorGetResponseTargetExtract].
	MaxPages int64 `json:"max_pages"`
	// This field is from variant [MonitorGetResponseTargetExtract].
	Schema map[string]any `json:"schema"`
	JSON   struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		Exclude             respjson.Field
		Include             respjson.Field
		MaxURLs             respjson.Field
		FollowSubdomains    respjson.Field
		MaxDepth            respjson.Field
		MaxPages            respjson.Field
		Schema              respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorGetResponseTarget is implemented by each variant of
// [MonitorGetResponseTargetUnion] to add type safety for the return type of
// [MonitorGetResponseTargetUnion.AsAny]
type anyMonitorGetResponseTarget interface {
	implMonitorGetResponseTargetUnion()
}

func (MonitorGetResponseTargetPage) implMonitorGetResponseTargetUnion()    {}
func (MonitorGetResponseTargetSitemap) implMonitorGetResponseTargetUnion() {}
func (MonitorGetResponseTargetExtract) implMonitorGetResponseTargetUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorGetResponseTargetUnion.AsAny().(type) {
//	case contextdev.MonitorGetResponseTargetPage:
//	case contextdev.MonitorGetResponseTargetSitemap:
//	case contextdev.MonitorGetResponseTargetExtract:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorGetResponseTargetUnion) AsAny() anyMonitorGetResponseTarget {
	switch u.Type {
	case "page":
		return u.AsPage()
	case "sitemap":
		return u.AsSitemap()
	case "extract":
		return u.AsExtract()
	}
	return nil
}

func (u MonitorGetResponseTargetUnion) AsPage() (v MonitorGetResponseTargetPage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseTargetUnion) AsSitemap() (v MonitorGetResponseTargetSitemap) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseTargetUnion) AsExtract() (v MonitorGetResponseTargetExtract) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorGetResponseTargetUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorGetResponseTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
type MonitorGetResponseTargetPage struct {
	// Use `page` to watch one web page.
	Type constant.Page `json:"type" default:"page"`
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorGetResponseTargetPageActionUnion `json:"actions" api:"nullable"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions string `json:"instructions"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetPage) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorGetResponseTargetPageActionUnion contains all possible properties and
// values from [MonitorGetResponseTargetPageActionWait],
// [MonitorGetResponseTargetPageActionPerform],
// [MonitorGetResponseTargetPageActionScroll].
//
// Use the [MonitorGetResponseTargetPageActionUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorGetResponseTargetPageActionUnion struct {
	// Any of "wait", "perform", "scroll".
	Do string `json:"do"`
	// This field is from variant [MonitorGetResponseTargetPageActionWait].
	TimeMs int64 `json:"timeMs"`
	// This field is from variant [MonitorGetResponseTargetPageActionPerform].
	Action string `json:"action"`
	// This field is from variant [MonitorGetResponseTargetPageActionScroll].
	Amount MonitorGetResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// This field is from variant [MonitorGetResponseTargetPageActionScroll].
	Container string `json:"container"`
	// This field is from variant [MonitorGetResponseTargetPageActionScroll].
	Direction string `json:"direction"`
	// This field is from variant [MonitorGetResponseTargetPageActionScroll].
	MaxScrolls int64 `json:"maxScrolls"`
	JSON       struct {
		Do         respjson.Field
		TimeMs     respjson.Field
		Action     respjson.Field
		Amount     respjson.Field
		Container  respjson.Field
		Direction  respjson.Field
		MaxScrolls respjson.Field
		raw        string
	} `json:"-"`
}

// anyMonitorGetResponseTargetPageAction is implemented by each variant of
// [MonitorGetResponseTargetPageActionUnion] to add type safety for the return type
// of [MonitorGetResponseTargetPageActionUnion.AsAny]
type anyMonitorGetResponseTargetPageAction interface {
	implMonitorGetResponseTargetPageActionUnion()
}

func (MonitorGetResponseTargetPageActionWait) implMonitorGetResponseTargetPageActionUnion()    {}
func (MonitorGetResponseTargetPageActionPerform) implMonitorGetResponseTargetPageActionUnion() {}
func (MonitorGetResponseTargetPageActionScroll) implMonitorGetResponseTargetPageActionUnion()  {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorGetResponseTargetPageActionUnion.AsAny().(type) {
//	case contextdev.MonitorGetResponseTargetPageActionWait:
//	case contextdev.MonitorGetResponseTargetPageActionPerform:
//	case contextdev.MonitorGetResponseTargetPageActionScroll:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorGetResponseTargetPageActionUnion) AsAny() anyMonitorGetResponseTargetPageAction {
	switch u.Do {
	case "wait":
		return u.AsWait()
	case "perform":
		return u.AsPerform()
	case "scroll":
		return u.AsScroll()
	}
	return nil
}

func (u MonitorGetResponseTargetPageActionUnion) AsWait() (v MonitorGetResponseTargetPageActionWait) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseTargetPageActionUnion) AsPerform() (v MonitorGetResponseTargetPageActionPerform) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseTargetPageActionUnion) AsScroll() (v MonitorGetResponseTargetPageActionScroll) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorGetResponseTargetPageActionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorGetResponseTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
type MonitorGetResponseTargetPageActionWait struct {
	// Use `wait` to pause for a fixed duration.
	Do constant.Wait `json:"do" default:"wait"`
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		TimeMs      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetPageActionWait) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
type MonitorGetResponseTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	Do constant.Perform `json:"do" default:"perform"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Do          respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetPageActionPerform) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
type MonitorGetResponseTargetPageActionScroll struct {
	// Use `scroll` to move through the page or a container.
	Do constant.Scroll `json:"do" default:"scroll"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorGetResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container string `json:"container"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls int64 `json:"maxScrolls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		Amount      respjson.Field
		Container   respjson.Field
		Direction   respjson.Field
		MaxScrolls  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetPageActionScroll) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorGetResponseTargetPageActionScrollAmountUnion contains all possible
// properties and values from [int64], [string].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfInt OfMonitorGetResponseTargetPageActionScrollAmountString]
type MonitorGetResponseTargetPageActionScrollAmountUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfMonitorGetResponseTargetPageActionScrollAmountString string `json:",inline"`
	JSON                                                   struct {
		OfInt                                                  respjson.Field
		OfMonitorGetResponseTargetPageActionScrollAmountString respjson.Field
		raw                                                    string
	} `json:"-"`
}

func (u MonitorGetResponseTargetPageActionScrollAmountUnion) AsInt() (v int64) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseTargetPageActionScrollAmountUnion) AsMonitorGetResponseTargetPageActionScrollAmountString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorGetResponseTargetPageActionScrollAmountUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorGetResponseTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetResponseTargetPageActionScrollAmountString string

const (
	MonitorGetResponseTargetPageActionScrollAmountStringViewport MonitorGetResponseTargetPageActionScrollAmountString = "viewport"
	MonitorGetResponseTargetPageActionScrollAmountStringMax      MonitorGetResponseTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
type MonitorGetResponseTargetSitemap struct {
	// Use `sitemap` to watch a site for added or removed URLs.
	Type constant.Sitemap `json:"type" default:"sitemap"`
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude"`
	// URL path patterns to include (max 50).
	Include []string `json:"include"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs int64 `json:"max_urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Exclude     respjson.Field
		Include     respjson.Field
		MaxURLs     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetSitemap) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
type MonitorGetResponseTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Use `extract` to watch structured data across selected pages.
	Type constant.Extract `json:"type" default:"extract"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains bool `json:"follow_subdomains"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth int64 `json:"max_depth"`
	// Maximum number of pages to track.
	MaxPages int64 `json:"max_pages"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions     respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		FollowSubdomains respjson.Field
		MaxDepth         respjson.Field
		MaxPages         respjson.Field
		Schema           respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseTargetExtract) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorGetResponseBaselineUnion contains all possible properties and values from
// [MonitorGetResponseBaselinePageBaseline],
// [MonitorGetResponseBaselineSitemapBaseline],
// [MonitorGetResponseBaselineExtractBaseline].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorGetResponseBaselineUnion struct {
	CapturedAt time.Time `json:"captured_at"`
	// This field is from variant [MonitorGetResponseBaselinePageBaseline].
	Text string `json:"text"`
	// This field is from variant [MonitorGetResponseBaselineSitemapBaseline].
	URLCount int64 `json:"url_count"`
	// This field is from variant [MonitorGetResponseBaselineSitemapBaseline].
	URLs []string `json:"urls"`
	// This field is from variant [MonitorGetResponseBaselineExtractBaseline].
	Data any `json:"data"`
	// This field is from variant [MonitorGetResponseBaselineExtractBaseline].
	URLsAnalyzed []string `json:"urls_analyzed"`
	JSON         struct {
		CapturedAt   respjson.Field
		Text         respjson.Field
		URLCount     respjson.Field
		URLs         respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		raw          string
	} `json:"-"`
}

func (u MonitorGetResponseBaselineUnion) AsPageBaseline() (v MonitorGetResponseBaselinePageBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseBaselineUnion) AsSitemapBaseline() (v MonitorGetResponseBaselineSitemapBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorGetResponseBaselineUnion) AsExtractBaseline() (v MonitorGetResponseBaselineExtractBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorGetResponseBaselineUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorGetResponseBaselineUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `page` monitor: the visible page text as last observed.
type MonitorGetResponseBaselinePageBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// The page's visible text as last observed.
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseBaselinePageBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseBaselinePageBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `sitemap` monitor: the normalized URL set as last
// observed.
type MonitorGetResponseBaselineSitemapBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Number of URLs in the baseline.
	URLCount int64 `json:"url_count" api:"required"`
	// The sitemap URLs as last observed (sorted, normalized).
	URLs []string `json:"urls" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		URLCount    respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseBaselineSitemapBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseBaselineSitemapBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of an `extract` monitor: the pages it tracks and the structured
// data as last extracted.
type MonitorGetResponseBaselineExtractBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Latest structured snapshot matching the extraction schema, refreshed at most
	// daily; `null` before capture.
	Data any `json:"data" api:"required"`
	// The page URLs the monitor tracks and analyzes for changes.
	URLsAnalyzed []string `json:"urls_analyzed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt   respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseBaselineExtractBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseBaselineExtractBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorGetResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Error from the most recent failed run; null when the last run succeeded.
type MonitorGetResponseLastError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseLastError) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseLastError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
type MonitorGetResponseSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Frequency   respjson.Field
		Type        respjson.Field
		Unit        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseSchedule) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
type MonitorGetResponseWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfig `json:"retry"`
	// API-generated signing secret. Visible only with full access or `monitors:write`
	// permission.
	Secret string `json:"secret"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		Events      respjson.Field
		Retry       respjson.Field
		Secret      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseWebhook) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Present while webhook deliveries are failing consecutively; null when deliveries
// are healthy or no webhook is configured. Cleared on the next successful delivery
// and when the webhook URL changes.
type MonitorGetResponseWebhookFailure struct {
	// Number of consecutive delivery attempts that did not succeed.
	ConsecutiveFailures int64     `json:"consecutive_failures" api:"required"`
	LastFailedAt        time.Time `json:"last_failed_at" api:"required" format:"date-time"`
	// Human-readable description of the most recent failure.
	LastMessage string `json:"last_message" api:"required"`
	// Outcome of the most recent failed delivery. rejected means a non-2xx response;
	// failed means no HTTP response was received; skipped_unsafe_url means the URL
	// failed the public-endpoint safety check.
	//
	// Any of "rejected", "failed", "skipped_unsafe_url".
	LastStatus string `json:"last_status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsecutiveFailures respjson.Field
		LastFailedAt        respjson.Field
		LastMessage         respjson.Field
		LastStatus          respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetResponseWebhookFailure) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetResponseWebhookFailure) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorUpdateResponse struct {
	ID string `json:"id" api:"required"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorUpdateResponseChangeDetectionUnion `json:"change_detection" api:"required"`
	CreatedAt       time.Time                                 `json:"created_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode MonitorUpdateResponseMode `json:"mode" api:"required"`
	Name string                    `json:"name" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Current state. Failed monitors keep running; paused monitors must be resumed
	// with `status: "active"`.
	//
	// Any of "active", "paused", "failed".
	Status MonitorUpdateResponseStatus `json:"status" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target    MonitorUpdateResponseTargetUnion `json:"target" api:"required"`
	UpdatedAt time.Time                        `json:"updated_at" api:"required" format:"date-time"`
	// Comparison baseline, included on Retrieve. Null until capture completes or after
	// target changes.
	Baseline MonitorUpdateResponseBaselineUnion `json:"baseline" api:"nullable"`
	// Credits this request used and your remaining balance.
	KeyMetadata  MonitorUpdateResponseKeyMetadata `json:"key_metadata"`
	LastChangeAt time.Time                        `json:"last_change_at" api:"nullable" format:"date-time"`
	// Error from the most recent failed run; null when the last run succeeded.
	LastError MonitorUpdateResponseLastError `json:"last_error" api:"nullable"`
	LastRunAt time.Time                      `json:"last_run_at" api:"nullable" format:"date-time"`
	// When the next scheduled run is due; null while paused.
	NextRunAt time.Time `json:"next_run_at" api:"nullable" format:"date-time"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorUpdateResponseSchedule `json:"schedule"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorUpdateResponseWebhook `json:"webhook" api:"nullable"`
	// Present while webhook deliveries are failing consecutively; null when deliveries
	// are healthy or no webhook is configured. Cleared on the next successful delivery
	// and when the webhook URL changes.
	WebhookFailure MonitorUpdateResponseWebhookFailure `json:"webhook_failure" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID              respjson.Field
		ChangeDetection respjson.Field
		CreatedAt       respjson.Field
		Mode            respjson.Field
		Name            respjson.Field
		RequestID       respjson.Field
		Status          respjson.Field
		Target          respjson.Field
		UpdatedAt       respjson.Field
		Baseline        respjson.Field
		KeyMetadata     respjson.Field
		LastChangeAt    respjson.Field
		LastError       respjson.Field
		LastRunAt       respjson.Field
		NextRunAt       respjson.Field
		Schedule        respjson.Field
		Tags            respjson.Field
		Webhook         respjson.Field
		WebhookFailure  respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorUpdateResponseChangeDetectionUnion contains all possible properties and
// values from [MonitorUpdateResponseChangeDetectionExact],
// [MonitorUpdateResponseChangeDetectionSemantic].
//
// Use the [MonitorUpdateResponseChangeDetectionUnion.AsAny] method to switch on
// the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorUpdateResponseChangeDetectionUnion struct {
	// Any of "exact", "semantic".
	Type string `json:"type"`
	// This field is from variant [MonitorUpdateResponseChangeDetectionSemantic].
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	JSON                struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorUpdateResponseChangeDetection is implemented by each variant of
// [MonitorUpdateResponseChangeDetectionUnion] to add type safety for the return
// type of [MonitorUpdateResponseChangeDetectionUnion.AsAny]
type anyMonitorUpdateResponseChangeDetection interface {
	implMonitorUpdateResponseChangeDetectionUnion()
}

func (MonitorUpdateResponseChangeDetectionExact) implMonitorUpdateResponseChangeDetectionUnion()    {}
func (MonitorUpdateResponseChangeDetectionSemantic) implMonitorUpdateResponseChangeDetectionUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorUpdateResponseChangeDetectionUnion.AsAny().(type) {
//	case contextdev.MonitorUpdateResponseChangeDetectionExact:
//	case contextdev.MonitorUpdateResponseChangeDetectionSemantic:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorUpdateResponseChangeDetectionUnion) AsAny() anyMonitorUpdateResponseChangeDetection {
	switch u.Type {
	case "exact":
		return u.AsExact()
	case "semantic":
		return u.AsSemantic()
	}
	return nil
}

func (u MonitorUpdateResponseChangeDetectionUnion) AsExact() (v MonitorUpdateResponseChangeDetectionExact) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseChangeDetectionUnion) AsSemantic() (v MonitorUpdateResponseChangeDetectionSemantic) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorUpdateResponseChangeDetectionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorUpdateResponseChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
type MonitorUpdateResponseChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseChangeDetectionExact) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
type MonitorUpdateResponseChangeDetectionSemantic struct {
	// Use `semantic` to judge changes against the target instructions.
	Type constant.Semantic `json:"type" default:"semantic"`
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseChangeDetectionSemantic) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Always `web`. Optional.
type MonitorUpdateResponseMode string

const (
	MonitorUpdateResponseModeWeb MonitorUpdateResponseMode = "web"
)

// Current state. Failed monitors keep running; paused monitors must be resumed
// with `status: "active"`.
type MonitorUpdateResponseStatus string

const (
	MonitorUpdateResponseStatusActive MonitorUpdateResponseStatus = "active"
	MonitorUpdateResponseStatusPaused MonitorUpdateResponseStatus = "paused"
	MonitorUpdateResponseStatusFailed MonitorUpdateResponseStatus = "failed"
)

// MonitorUpdateResponseTargetUnion contains all possible properties and values
// from [MonitorUpdateResponseTargetPage], [MonitorUpdateResponseTargetSitemap],
// [MonitorUpdateResponseTargetExtract].
//
// Use the [MonitorUpdateResponseTargetUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorUpdateResponseTargetUnion struct {
	// Any of "page", "sitemap", "extract".
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [MonitorUpdateResponseTargetPage].
	Actions []MonitorUpdateResponseTargetPageActionUnion `json:"actions"`
	// This field is from variant [MonitorUpdateResponseTargetPage].
	ExcludeSelectors []string `json:"exclude_selectors"`
	// This field is from variant [MonitorUpdateResponseTargetPage].
	IncludeSelectors []string `json:"include_selectors"`
	Instructions     string   `json:"instructions"`
	// This field is from variant [MonitorUpdateResponseTargetPage].
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// This field is from variant [MonitorUpdateResponseTargetSitemap].
	Exclude []string `json:"exclude"`
	// This field is from variant [MonitorUpdateResponseTargetSitemap].
	Include []string `json:"include"`
	// This field is from variant [MonitorUpdateResponseTargetSitemap].
	MaxURLs int64 `json:"max_urls"`
	// This field is from variant [MonitorUpdateResponseTargetExtract].
	FollowSubdomains bool `json:"follow_subdomains"`
	// This field is from variant [MonitorUpdateResponseTargetExtract].
	MaxDepth int64 `json:"max_depth"`
	// This field is from variant [MonitorUpdateResponseTargetExtract].
	MaxPages int64 `json:"max_pages"`
	// This field is from variant [MonitorUpdateResponseTargetExtract].
	Schema map[string]any `json:"schema"`
	JSON   struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		Exclude             respjson.Field
		Include             respjson.Field
		MaxURLs             respjson.Field
		FollowSubdomains    respjson.Field
		MaxDepth            respjson.Field
		MaxPages            respjson.Field
		Schema              respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorUpdateResponseTarget is implemented by each variant of
// [MonitorUpdateResponseTargetUnion] to add type safety for the return type of
// [MonitorUpdateResponseTargetUnion.AsAny]
type anyMonitorUpdateResponseTarget interface {
	implMonitorUpdateResponseTargetUnion()
}

func (MonitorUpdateResponseTargetPage) implMonitorUpdateResponseTargetUnion()    {}
func (MonitorUpdateResponseTargetSitemap) implMonitorUpdateResponseTargetUnion() {}
func (MonitorUpdateResponseTargetExtract) implMonitorUpdateResponseTargetUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorUpdateResponseTargetUnion.AsAny().(type) {
//	case contextdev.MonitorUpdateResponseTargetPage:
//	case contextdev.MonitorUpdateResponseTargetSitemap:
//	case contextdev.MonitorUpdateResponseTargetExtract:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorUpdateResponseTargetUnion) AsAny() anyMonitorUpdateResponseTarget {
	switch u.Type {
	case "page":
		return u.AsPage()
	case "sitemap":
		return u.AsSitemap()
	case "extract":
		return u.AsExtract()
	}
	return nil
}

func (u MonitorUpdateResponseTargetUnion) AsPage() (v MonitorUpdateResponseTargetPage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseTargetUnion) AsSitemap() (v MonitorUpdateResponseTargetSitemap) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseTargetUnion) AsExtract() (v MonitorUpdateResponseTargetExtract) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorUpdateResponseTargetUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorUpdateResponseTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
type MonitorUpdateResponseTargetPage struct {
	// Use `page` to watch one web page.
	Type constant.Page `json:"type" default:"page"`
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorUpdateResponseTargetPageActionUnion `json:"actions" api:"nullable"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions string `json:"instructions"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetPage) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorUpdateResponseTargetPageActionUnion contains all possible properties and
// values from [MonitorUpdateResponseTargetPageActionWait],
// [MonitorUpdateResponseTargetPageActionPerform],
// [MonitorUpdateResponseTargetPageActionScroll].
//
// Use the [MonitorUpdateResponseTargetPageActionUnion.AsAny] method to switch on
// the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorUpdateResponseTargetPageActionUnion struct {
	// Any of "wait", "perform", "scroll".
	Do string `json:"do"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionWait].
	TimeMs int64 `json:"timeMs"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionPerform].
	Action string `json:"action"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionScroll].
	Amount MonitorUpdateResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionScroll].
	Container string `json:"container"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionScroll].
	Direction string `json:"direction"`
	// This field is from variant [MonitorUpdateResponseTargetPageActionScroll].
	MaxScrolls int64 `json:"maxScrolls"`
	JSON       struct {
		Do         respjson.Field
		TimeMs     respjson.Field
		Action     respjson.Field
		Amount     respjson.Field
		Container  respjson.Field
		Direction  respjson.Field
		MaxScrolls respjson.Field
		raw        string
	} `json:"-"`
}

// anyMonitorUpdateResponseTargetPageAction is implemented by each variant of
// [MonitorUpdateResponseTargetPageActionUnion] to add type safety for the return
// type of [MonitorUpdateResponseTargetPageActionUnion.AsAny]
type anyMonitorUpdateResponseTargetPageAction interface {
	implMonitorUpdateResponseTargetPageActionUnion()
}

func (MonitorUpdateResponseTargetPageActionWait) implMonitorUpdateResponseTargetPageActionUnion() {}
func (MonitorUpdateResponseTargetPageActionPerform) implMonitorUpdateResponseTargetPageActionUnion() {
}
func (MonitorUpdateResponseTargetPageActionScroll) implMonitorUpdateResponseTargetPageActionUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorUpdateResponseTargetPageActionUnion.AsAny().(type) {
//	case contextdev.MonitorUpdateResponseTargetPageActionWait:
//	case contextdev.MonitorUpdateResponseTargetPageActionPerform:
//	case contextdev.MonitorUpdateResponseTargetPageActionScroll:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorUpdateResponseTargetPageActionUnion) AsAny() anyMonitorUpdateResponseTargetPageAction {
	switch u.Do {
	case "wait":
		return u.AsWait()
	case "perform":
		return u.AsPerform()
	case "scroll":
		return u.AsScroll()
	}
	return nil
}

func (u MonitorUpdateResponseTargetPageActionUnion) AsWait() (v MonitorUpdateResponseTargetPageActionWait) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseTargetPageActionUnion) AsPerform() (v MonitorUpdateResponseTargetPageActionPerform) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseTargetPageActionUnion) AsScroll() (v MonitorUpdateResponseTargetPageActionScroll) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorUpdateResponseTargetPageActionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorUpdateResponseTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
type MonitorUpdateResponseTargetPageActionWait struct {
	// Use `wait` to pause for a fixed duration.
	Do constant.Wait `json:"do" default:"wait"`
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		TimeMs      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetPageActionWait) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
type MonitorUpdateResponseTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	Do constant.Perform `json:"do" default:"perform"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Do          respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetPageActionPerform) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
type MonitorUpdateResponseTargetPageActionScroll struct {
	// Use `scroll` to move through the page or a container.
	Do constant.Scroll `json:"do" default:"scroll"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorUpdateResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container string `json:"container"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls int64 `json:"maxScrolls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		Amount      respjson.Field
		Container   respjson.Field
		Direction   respjson.Field
		MaxScrolls  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetPageActionScroll) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorUpdateResponseTargetPageActionScrollAmountUnion contains all possible
// properties and values from [int64], [string].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfInt OfMonitorUpdateResponseTargetPageActionScrollAmountString]
type MonitorUpdateResponseTargetPageActionScrollAmountUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfMonitorUpdateResponseTargetPageActionScrollAmountString string `json:",inline"`
	JSON                                                      struct {
		OfInt                                                     respjson.Field
		OfMonitorUpdateResponseTargetPageActionScrollAmountString respjson.Field
		raw                                                       string
	} `json:"-"`
}

func (u MonitorUpdateResponseTargetPageActionScrollAmountUnion) AsInt() (v int64) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseTargetPageActionScrollAmountUnion) AsMonitorUpdateResponseTargetPageActionScrollAmountString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorUpdateResponseTargetPageActionScrollAmountUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorUpdateResponseTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorUpdateResponseTargetPageActionScrollAmountString string

const (
	MonitorUpdateResponseTargetPageActionScrollAmountStringViewport MonitorUpdateResponseTargetPageActionScrollAmountString = "viewport"
	MonitorUpdateResponseTargetPageActionScrollAmountStringMax      MonitorUpdateResponseTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
type MonitorUpdateResponseTargetSitemap struct {
	// Use `sitemap` to watch a site for added or removed URLs.
	Type constant.Sitemap `json:"type" default:"sitemap"`
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude"`
	// URL path patterns to include (max 50).
	Include []string `json:"include"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs int64 `json:"max_urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Exclude     respjson.Field
		Include     respjson.Field
		MaxURLs     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetSitemap) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
type MonitorUpdateResponseTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Use `extract` to watch structured data across selected pages.
	Type constant.Extract `json:"type" default:"extract"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains bool `json:"follow_subdomains"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth int64 `json:"max_depth"`
	// Maximum number of pages to track.
	MaxPages int64 `json:"max_pages"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions     respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		FollowSubdomains respjson.Field
		MaxDepth         respjson.Field
		MaxPages         respjson.Field
		Schema           respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseTargetExtract) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorUpdateResponseBaselineUnion contains all possible properties and values
// from [MonitorUpdateResponseBaselinePageBaseline],
// [MonitorUpdateResponseBaselineSitemapBaseline],
// [MonitorUpdateResponseBaselineExtractBaseline].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorUpdateResponseBaselineUnion struct {
	CapturedAt time.Time `json:"captured_at"`
	// This field is from variant [MonitorUpdateResponseBaselinePageBaseline].
	Text string `json:"text"`
	// This field is from variant [MonitorUpdateResponseBaselineSitemapBaseline].
	URLCount int64 `json:"url_count"`
	// This field is from variant [MonitorUpdateResponseBaselineSitemapBaseline].
	URLs []string `json:"urls"`
	// This field is from variant [MonitorUpdateResponseBaselineExtractBaseline].
	Data any `json:"data"`
	// This field is from variant [MonitorUpdateResponseBaselineExtractBaseline].
	URLsAnalyzed []string `json:"urls_analyzed"`
	JSON         struct {
		CapturedAt   respjson.Field
		Text         respjson.Field
		URLCount     respjson.Field
		URLs         respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		raw          string
	} `json:"-"`
}

func (u MonitorUpdateResponseBaselineUnion) AsPageBaseline() (v MonitorUpdateResponseBaselinePageBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseBaselineUnion) AsSitemapBaseline() (v MonitorUpdateResponseBaselineSitemapBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorUpdateResponseBaselineUnion) AsExtractBaseline() (v MonitorUpdateResponseBaselineExtractBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorUpdateResponseBaselineUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorUpdateResponseBaselineUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `page` monitor: the visible page text as last observed.
type MonitorUpdateResponseBaselinePageBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// The page's visible text as last observed.
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseBaselinePageBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseBaselinePageBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `sitemap` monitor: the normalized URL set as last
// observed.
type MonitorUpdateResponseBaselineSitemapBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Number of URLs in the baseline.
	URLCount int64 `json:"url_count" api:"required"`
	// The sitemap URLs as last observed (sorted, normalized).
	URLs []string `json:"urls" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		URLCount    respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseBaselineSitemapBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseBaselineSitemapBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of an `extract` monitor: the pages it tracks and the structured
// data as last extracted.
type MonitorUpdateResponseBaselineExtractBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Latest structured snapshot matching the extraction schema, refreshed at most
	// daily; `null` before capture.
	Data any `json:"data" api:"required"`
	// The page URLs the monitor tracks and analyzes for changes.
	URLsAnalyzed []string `json:"urls_analyzed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt   respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseBaselineExtractBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseBaselineExtractBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorUpdateResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Error from the most recent failed run; null when the last run succeeded.
type MonitorUpdateResponseLastError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseLastError) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseLastError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
type MonitorUpdateResponseSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Frequency   respjson.Field
		Type        respjson.Field
		Unit        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseSchedule) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
type MonitorUpdateResponseWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfig `json:"retry"`
	// API-generated signing secret. Visible only with full access or `monitors:write`
	// permission.
	Secret string `json:"secret"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		Events      respjson.Field
		Retry       respjson.Field
		Secret      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseWebhook) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Present while webhook deliveries are failing consecutively; null when deliveries
// are healthy or no webhook is configured. Cleared on the next successful delivery
// and when the webhook URL changes.
type MonitorUpdateResponseWebhookFailure struct {
	// Number of consecutive delivery attempts that did not succeed.
	ConsecutiveFailures int64     `json:"consecutive_failures" api:"required"`
	LastFailedAt        time.Time `json:"last_failed_at" api:"required" format:"date-time"`
	// Human-readable description of the most recent failure.
	LastMessage string `json:"last_message" api:"required"`
	// Outcome of the most recent failed delivery. rejected means a non-2xx response;
	// failed means no HTTP response was received; skipped_unsafe_url means the URL
	// failed the public-endpoint safety check.
	//
	// Any of "rejected", "failed", "skipped_unsafe_url".
	LastStatus string `json:"last_status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsecutiveFailures respjson.Field
		LastFailedAt        respjson.Field
		LastMessage         respjson.Field
		LastStatus          respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorUpdateResponseWebhookFailure) RawJSON() string { return r.JSON.raw }
func (r *MonitorUpdateResponseWebhookFailure) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListResponse struct {
	Data       []MonitorListResponseData `json:"data" api:"required"`
	HasMore    bool                      `json:"has_more" api:"required"`
	NextCursor string                    `json:"next_cursor" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorListResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		HasMore     respjson.Field
		NextCursor  respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A web monitor. `mode` is the constant `web`; behavior is described by `target`
// (page/sitemap/extract) and `change_detection` (exact/semantic).
type MonitorListResponseData struct {
	ID string `json:"id" api:"required"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorListResponseDataChangeDetectionUnion `json:"change_detection" api:"required"`
	CreatedAt       time.Time                                   `json:"created_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode string `json:"mode" api:"required"`
	Name string `json:"name" api:"required"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorListResponseDataSchedule `json:"schedule" api:"required"`
	// Current state. Failed monitors keep running; paused monitors must be resumed
	// with `status: "active"`.
	//
	// Any of "active", "paused", "failed".
	Status string `json:"status" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target    MonitorListResponseDataTargetUnion `json:"target" api:"required"`
	UpdatedAt time.Time                          `json:"updated_at" api:"required" format:"date-time"`
	// Comparison baseline, included on Retrieve. Null until capture completes or after
	// target changes.
	Baseline     MonitorListResponseDataBaselineUnion `json:"baseline" api:"nullable"`
	LastChangeAt time.Time                            `json:"last_change_at" api:"nullable" format:"date-time"`
	// Error from the most recent failed run; null when the last run succeeded.
	LastError MonitorListResponseDataLastError `json:"last_error" api:"nullable"`
	LastRunAt time.Time                        `json:"last_run_at" api:"nullable" format:"date-time"`
	// When the next scheduled run is due; null while paused.
	NextRunAt time.Time `json:"next_run_at" api:"nullable" format:"date-time"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorListResponseDataWebhook `json:"webhook" api:"nullable"`
	// Present while webhook deliveries are failing consecutively; null when deliveries
	// are healthy or no webhook is configured. Cleared on the next successful delivery
	// and when the webhook URL changes.
	WebhookFailure MonitorListResponseDataWebhookFailure `json:"webhook_failure" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID              respjson.Field
		ChangeDetection respjson.Field
		CreatedAt       respjson.Field
		Mode            respjson.Field
		Name            respjson.Field
		Schedule        respjson.Field
		Status          respjson.Field
		Target          respjson.Field
		UpdatedAt       respjson.Field
		Baseline        respjson.Field
		LastChangeAt    respjson.Field
		LastError       respjson.Field
		LastRunAt       respjson.Field
		NextRunAt       respjson.Field
		Tags            respjson.Field
		Webhook         respjson.Field
		WebhookFailure  respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorListResponseDataChangeDetectionUnion contains all possible properties and
// values from [MonitorListResponseDataChangeDetectionExact],
// [MonitorListResponseDataChangeDetectionSemantic].
//
// Use the [MonitorListResponseDataChangeDetectionUnion.AsAny] method to switch on
// the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorListResponseDataChangeDetectionUnion struct {
	// Any of "exact", "semantic".
	Type string `json:"type"`
	// This field is from variant [MonitorListResponseDataChangeDetectionSemantic].
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	JSON                struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorListResponseDataChangeDetection is implemented by each variant of
// [MonitorListResponseDataChangeDetectionUnion] to add type safety for the return
// type of [MonitorListResponseDataChangeDetectionUnion.AsAny]
type anyMonitorListResponseDataChangeDetection interface {
	implMonitorListResponseDataChangeDetectionUnion()
}

func (MonitorListResponseDataChangeDetectionExact) implMonitorListResponseDataChangeDetectionUnion() {
}
func (MonitorListResponseDataChangeDetectionSemantic) implMonitorListResponseDataChangeDetectionUnion() {
}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorListResponseDataChangeDetectionUnion.AsAny().(type) {
//	case contextdev.MonitorListResponseDataChangeDetectionExact:
//	case contextdev.MonitorListResponseDataChangeDetectionSemantic:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorListResponseDataChangeDetectionUnion) AsAny() anyMonitorListResponseDataChangeDetection {
	switch u.Type {
	case "exact":
		return u.AsExact()
	case "semantic":
		return u.AsSemantic()
	}
	return nil
}

func (u MonitorListResponseDataChangeDetectionUnion) AsExact() (v MonitorListResponseDataChangeDetectionExact) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataChangeDetectionUnion) AsSemantic() (v MonitorListResponseDataChangeDetectionSemantic) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorListResponseDataChangeDetectionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorListResponseDataChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
type MonitorListResponseDataChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataChangeDetectionExact) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
type MonitorListResponseDataChangeDetectionSemantic struct {
	// Use `semantic` to judge changes against the target instructions.
	Type constant.Semantic `json:"type" default:"semantic"`
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataChangeDetectionSemantic) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
type MonitorListResponseDataSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Frequency   respjson.Field
		Type        respjson.Field
		Unit        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataSchedule) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorListResponseDataTargetUnion contains all possible properties and values
// from [MonitorListResponseDataTargetPage],
// [MonitorListResponseDataTargetSitemap], [MonitorListResponseDataTargetExtract].
//
// Use the [MonitorListResponseDataTargetUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorListResponseDataTargetUnion struct {
	// Any of "page", "sitemap", "extract".
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [MonitorListResponseDataTargetPage].
	Actions []MonitorListResponseDataTargetPageActionUnion `json:"actions"`
	// This field is from variant [MonitorListResponseDataTargetPage].
	ExcludeSelectors []string `json:"exclude_selectors"`
	// This field is from variant [MonitorListResponseDataTargetPage].
	IncludeSelectors []string `json:"include_selectors"`
	Instructions     string   `json:"instructions"`
	// This field is from variant [MonitorListResponseDataTargetPage].
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// This field is from variant [MonitorListResponseDataTargetSitemap].
	Exclude []string `json:"exclude"`
	// This field is from variant [MonitorListResponseDataTargetSitemap].
	Include []string `json:"include"`
	// This field is from variant [MonitorListResponseDataTargetSitemap].
	MaxURLs int64 `json:"max_urls"`
	// This field is from variant [MonitorListResponseDataTargetExtract].
	FollowSubdomains bool `json:"follow_subdomains"`
	// This field is from variant [MonitorListResponseDataTargetExtract].
	MaxDepth int64 `json:"max_depth"`
	// This field is from variant [MonitorListResponseDataTargetExtract].
	MaxPages int64 `json:"max_pages"`
	// This field is from variant [MonitorListResponseDataTargetExtract].
	Schema map[string]any `json:"schema"`
	JSON   struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		Exclude             respjson.Field
		Include             respjson.Field
		MaxURLs             respjson.Field
		FollowSubdomains    respjson.Field
		MaxDepth            respjson.Field
		MaxPages            respjson.Field
		Schema              respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorListResponseDataTarget is implemented by each variant of
// [MonitorListResponseDataTargetUnion] to add type safety for the return type of
// [MonitorListResponseDataTargetUnion.AsAny]
type anyMonitorListResponseDataTarget interface {
	implMonitorListResponseDataTargetUnion()
}

func (MonitorListResponseDataTargetPage) implMonitorListResponseDataTargetUnion()    {}
func (MonitorListResponseDataTargetSitemap) implMonitorListResponseDataTargetUnion() {}
func (MonitorListResponseDataTargetExtract) implMonitorListResponseDataTargetUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorListResponseDataTargetUnion.AsAny().(type) {
//	case contextdev.MonitorListResponseDataTargetPage:
//	case contextdev.MonitorListResponseDataTargetSitemap:
//	case contextdev.MonitorListResponseDataTargetExtract:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorListResponseDataTargetUnion) AsAny() anyMonitorListResponseDataTarget {
	switch u.Type {
	case "page":
		return u.AsPage()
	case "sitemap":
		return u.AsSitemap()
	case "extract":
		return u.AsExtract()
	}
	return nil
}

func (u MonitorListResponseDataTargetUnion) AsPage() (v MonitorListResponseDataTargetPage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataTargetUnion) AsSitemap() (v MonitorListResponseDataTargetSitemap) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataTargetUnion) AsExtract() (v MonitorListResponseDataTargetExtract) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorListResponseDataTargetUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorListResponseDataTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
type MonitorListResponseDataTargetPage struct {
	// Use `page` to watch one web page.
	Type constant.Page `json:"type" default:"page"`
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorListResponseDataTargetPageActionUnion `json:"actions" api:"nullable"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions string `json:"instructions"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetPage) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorListResponseDataTargetPageActionUnion contains all possible properties
// and values from [MonitorListResponseDataTargetPageActionWait],
// [MonitorListResponseDataTargetPageActionPerform],
// [MonitorListResponseDataTargetPageActionScroll].
//
// Use the [MonitorListResponseDataTargetPageActionUnion.AsAny] method to switch on
// the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorListResponseDataTargetPageActionUnion struct {
	// Any of "wait", "perform", "scroll".
	Do string `json:"do"`
	// This field is from variant [MonitorListResponseDataTargetPageActionWait].
	TimeMs int64 `json:"timeMs"`
	// This field is from variant [MonitorListResponseDataTargetPageActionPerform].
	Action string `json:"action"`
	// This field is from variant [MonitorListResponseDataTargetPageActionScroll].
	Amount MonitorListResponseDataTargetPageActionScrollAmountUnion `json:"amount"`
	// This field is from variant [MonitorListResponseDataTargetPageActionScroll].
	Container string `json:"container"`
	// This field is from variant [MonitorListResponseDataTargetPageActionScroll].
	Direction string `json:"direction"`
	// This field is from variant [MonitorListResponseDataTargetPageActionScroll].
	MaxScrolls int64 `json:"maxScrolls"`
	JSON       struct {
		Do         respjson.Field
		TimeMs     respjson.Field
		Action     respjson.Field
		Amount     respjson.Field
		Container  respjson.Field
		Direction  respjson.Field
		MaxScrolls respjson.Field
		raw        string
	} `json:"-"`
}

// anyMonitorListResponseDataTargetPageAction is implemented by each variant of
// [MonitorListResponseDataTargetPageActionUnion] to add type safety for the return
// type of [MonitorListResponseDataTargetPageActionUnion.AsAny]
type anyMonitorListResponseDataTargetPageAction interface {
	implMonitorListResponseDataTargetPageActionUnion()
}

func (MonitorListResponseDataTargetPageActionWait) implMonitorListResponseDataTargetPageActionUnion() {
}
func (MonitorListResponseDataTargetPageActionPerform) implMonitorListResponseDataTargetPageActionUnion() {
}
func (MonitorListResponseDataTargetPageActionScroll) implMonitorListResponseDataTargetPageActionUnion() {
}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorListResponseDataTargetPageActionUnion.AsAny().(type) {
//	case contextdev.MonitorListResponseDataTargetPageActionWait:
//	case contextdev.MonitorListResponseDataTargetPageActionPerform:
//	case contextdev.MonitorListResponseDataTargetPageActionScroll:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorListResponseDataTargetPageActionUnion) AsAny() anyMonitorListResponseDataTargetPageAction {
	switch u.Do {
	case "wait":
		return u.AsWait()
	case "perform":
		return u.AsPerform()
	case "scroll":
		return u.AsScroll()
	}
	return nil
}

func (u MonitorListResponseDataTargetPageActionUnion) AsWait() (v MonitorListResponseDataTargetPageActionWait) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataTargetPageActionUnion) AsPerform() (v MonitorListResponseDataTargetPageActionPerform) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataTargetPageActionUnion) AsScroll() (v MonitorListResponseDataTargetPageActionScroll) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorListResponseDataTargetPageActionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorListResponseDataTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
type MonitorListResponseDataTargetPageActionWait struct {
	// Use `wait` to pause for a fixed duration.
	Do constant.Wait `json:"do" default:"wait"`
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		TimeMs      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetPageActionWait) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
type MonitorListResponseDataTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	Do constant.Perform `json:"do" default:"perform"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Do          respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetPageActionPerform) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
type MonitorListResponseDataTargetPageActionScroll struct {
	// Use `scroll` to move through the page or a container.
	Do constant.Scroll `json:"do" default:"scroll"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorListResponseDataTargetPageActionScrollAmountUnion `json:"amount"`
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container string `json:"container"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls int64 `json:"maxScrolls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		Amount      respjson.Field
		Container   respjson.Field
		Direction   respjson.Field
		MaxScrolls  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetPageActionScroll) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorListResponseDataTargetPageActionScrollAmountUnion contains all possible
// properties and values from [int64], [string].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfInt
// OfMonitorListResponseDataTargetPageActionScrollAmountString]
type MonitorListResponseDataTargetPageActionScrollAmountUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfMonitorListResponseDataTargetPageActionScrollAmountString string `json:",inline"`
	JSON                                                        struct {
		OfInt                                                       respjson.Field
		OfMonitorListResponseDataTargetPageActionScrollAmountString respjson.Field
		raw                                                         string
	} `json:"-"`
}

func (u MonitorListResponseDataTargetPageActionScrollAmountUnion) AsInt() (v int64) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataTargetPageActionScrollAmountUnion) AsMonitorListResponseDataTargetPageActionScrollAmountString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorListResponseDataTargetPageActionScrollAmountUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorListResponseDataTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListResponseDataTargetPageActionScrollAmountString string

const (
	MonitorListResponseDataTargetPageActionScrollAmountStringViewport MonitorListResponseDataTargetPageActionScrollAmountString = "viewport"
	MonitorListResponseDataTargetPageActionScrollAmountStringMax      MonitorListResponseDataTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
type MonitorListResponseDataTargetSitemap struct {
	// Use `sitemap` to watch a site for added or removed URLs.
	Type constant.Sitemap `json:"type" default:"sitemap"`
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude"`
	// URL path patterns to include (max 50).
	Include []string `json:"include"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs int64 `json:"max_urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Exclude     respjson.Field
		Include     respjson.Field
		MaxURLs     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetSitemap) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
type MonitorListResponseDataTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Use `extract` to watch structured data across selected pages.
	Type constant.Extract `json:"type" default:"extract"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains bool `json:"follow_subdomains"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth int64 `json:"max_depth"`
	// Maximum number of pages to track.
	MaxPages int64 `json:"max_pages"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions     respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		FollowSubdomains respjson.Field
		MaxDepth         respjson.Field
		MaxPages         respjson.Field
		Schema           respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataTargetExtract) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorListResponseDataBaselineUnion contains all possible properties and values
// from [MonitorListResponseDataBaselinePageBaseline],
// [MonitorListResponseDataBaselineSitemapBaseline],
// [MonitorListResponseDataBaselineExtractBaseline].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorListResponseDataBaselineUnion struct {
	CapturedAt time.Time `json:"captured_at"`
	// This field is from variant [MonitorListResponseDataBaselinePageBaseline].
	Text string `json:"text"`
	// This field is from variant [MonitorListResponseDataBaselineSitemapBaseline].
	URLCount int64 `json:"url_count"`
	// This field is from variant [MonitorListResponseDataBaselineSitemapBaseline].
	URLs []string `json:"urls"`
	// This field is from variant [MonitorListResponseDataBaselineExtractBaseline].
	Data any `json:"data"`
	// This field is from variant [MonitorListResponseDataBaselineExtractBaseline].
	URLsAnalyzed []string `json:"urls_analyzed"`
	JSON         struct {
		CapturedAt   respjson.Field
		Text         respjson.Field
		URLCount     respjson.Field
		URLs         respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		raw          string
	} `json:"-"`
}

func (u MonitorListResponseDataBaselineUnion) AsPageBaseline() (v MonitorListResponseDataBaselinePageBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataBaselineUnion) AsSitemapBaseline() (v MonitorListResponseDataBaselineSitemapBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorListResponseDataBaselineUnion) AsExtractBaseline() (v MonitorListResponseDataBaselineExtractBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorListResponseDataBaselineUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorListResponseDataBaselineUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `page` monitor: the visible page text as last observed.
type MonitorListResponseDataBaselinePageBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// The page's visible text as last observed.
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataBaselinePageBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataBaselinePageBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `sitemap` monitor: the normalized URL set as last
// observed.
type MonitorListResponseDataBaselineSitemapBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Number of URLs in the baseline.
	URLCount int64 `json:"url_count" api:"required"`
	// The sitemap URLs as last observed (sorted, normalized).
	URLs []string `json:"urls" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		URLCount    respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataBaselineSitemapBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataBaselineSitemapBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of an `extract` monitor: the pages it tracks and the structured
// data as last extracted.
type MonitorListResponseDataBaselineExtractBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Latest structured snapshot matching the extraction schema, refreshed at most
	// daily; `null` before capture.
	Data any `json:"data" api:"required"`
	// The page URLs the monitor tracks and analyzes for changes.
	URLsAnalyzed []string `json:"urls_analyzed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt   respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataBaselineExtractBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataBaselineExtractBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Error from the most recent failed run; null when the last run succeeded.
type MonitorListResponseDataLastError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataLastError) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataLastError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
type MonitorListResponseDataWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfig `json:"retry"`
	// API-generated signing secret. Visible only with full access or `monitors:write`
	// permission.
	Secret string `json:"secret"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		Events      respjson.Field
		Retry       respjson.Field
		Secret      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataWebhook) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Present while webhook deliveries are failing consecutively; null when deliveries
// are healthy or no webhook is configured. Cleared on the next successful delivery
// and when the webhook URL changes.
type MonitorListResponseDataWebhookFailure struct {
	// Number of consecutive delivery attempts that did not succeed.
	ConsecutiveFailures int64     `json:"consecutive_failures" api:"required"`
	LastFailedAt        time.Time `json:"last_failed_at" api:"required" format:"date-time"`
	// Human-readable description of the most recent failure.
	LastMessage string `json:"last_message" api:"required"`
	// Outcome of the most recent failed delivery. rejected means a non-2xx response;
	// failed means no HTTP response was received; skipped_unsafe_url means the URL
	// failed the public-endpoint safety check.
	//
	// Any of "rejected", "failed", "skipped_unsafe_url".
	LastStatus string `json:"last_status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsecutiveFailures respjson.Field
		LastFailedAt        respjson.Field
		LastMessage         respjson.Field
		LastStatus          respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseDataWebhookFailure) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseDataWebhookFailure) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorListResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorListResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorDeleteResponse struct {
	ID      string `json:"id" api:"required"`
	Deleted bool   `json:"deleted" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorDeleteResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Deleted     respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorDeleteResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorDeleteResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorDeleteResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorDeleteResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorDeleteResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetCreditUsageResponse struct {
	Data []MonitorGetCreditUsageResponseData `json:"data" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Sum of credits across all monitors in the window.
	TotalCredits int64 `json:"total_credits" api:"required"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorGetCreditUsageResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data         respjson.Field
		RequestID    respjson.Field
		TotalCredits respjson.Field
		KeyMetadata  respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetCreditUsageResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetCreditUsageResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetCreditUsageResponseData struct {
	// Credits charged to this monitor over the window.
	Credits   int64  `json:"credits" api:"required"`
	MonitorID string `json:"monitor_id" api:"required"`
	// Monitor name (falls back to the id when the monitor was deleted).
	Name string `json:"name" api:"required"`
	// Number of billed runs over the window.
	Runs int64 `json:"runs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Credits     respjson.Field
		MonitorID   respjson.Field
		Name        respjson.Field
		Runs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetCreditUsageResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetCreditUsageResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorGetCreditUsageResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetCreditUsageResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetCreditUsageResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetLimitsResponse struct {
	// Most monitors you can have: your plan's allowance or a custom limit.
	MonitorsLimit int64 `json:"monitors_limit" api:"required"`
	// Number of monitors the account currently has.
	MonitorsUsed int64 `json:"monitors_used" api:"required"`
	// `starter` means Developer; `pro` means Pro or Growth; `scale` means Scale or
	// Enterprise.
	//
	// Any of "free", "starter", "pro", "scale".
	Plan MonitorGetLimitsResponsePlan `json:"plan" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorGetLimitsResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MonitorsLimit respjson.Field
		MonitorsUsed  respjson.Field
		Plan          respjson.Field
		RequestID     respjson.Field
		KeyMetadata   respjson.Field
		ExtraFields   map[string]respjson.Field
		raw           string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetLimitsResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetLimitsResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `starter` means Developer; `pro` means Pro or Growth; `scale` means Scale or
// Enterprise.
type MonitorGetLimitsResponsePlan string

const (
	MonitorGetLimitsResponsePlanFree    MonitorGetLimitsResponsePlan = "free"
	MonitorGetLimitsResponsePlanStarter MonitorGetLimitsResponsePlan = "starter"
	MonitorGetLimitsResponsePlanPro     MonitorGetLimitsResponsePlan = "pro"
	MonitorGetLimitsResponsePlanScale   MonitorGetLimitsResponsePlan = "scale"
)

// Credits this request used and your remaining balance.
type MonitorGetLimitsResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetLimitsResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetLimitsResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListAccountChangesResponse struct {
	Data       []MonitorListAccountChangesResponseData `json:"data" api:"required"`
	HasMore    bool                                    `json:"has_more" api:"required"`
	NextCursor string                                  `json:"next_cursor" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorListAccountChangesResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		HasMore     respjson.Field
		NextCursor  respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountChangesResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountChangesResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detected change, including applicable diffs, URLs, and supporting evidence.
type MonitorListAccountChangesResponseData struct {
	ID string `json:"id" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType string    `json:"change_detection_type" api:"required"`
	DetectedAt          time.Time `json:"detected_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode      string `json:"mode" api:"required"`
	MonitorID string `json:"monitor_id" api:"required"`
	// The run that detected this change.
	RunID   string `json:"run_id" api:"required"`
	Summary string `json:"summary" api:"required"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType    string `json:"target_type" api:"required"`
	Title         string `json:"title" api:"required"`
	URL           string `json:"url" api:"required" format:"uri"`
	AddedURLCount int64  `json:"added_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	AddedURLs         []string `json:"added_urls" format:"uri"`
	AfterTextExcerpt  string   `json:"after_text_excerpt"`
	BeforeTextExcerpt string   `json:"before_text_excerpt"`
	Confidence        float64  `json:"confidence"`
	// Text diff between the previous and current page baseline (page targets).
	Diff     string                                          `json:"diff"`
	Evidence []MonitorListAccountChangesResponseDataEvidence `json:"evidence"`
	// Any of "low", "medium", "high".
	Importance      string `json:"importance"`
	MatchedURLCount int64  `json:"matched_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	MatchedURLs     []string `json:"matched_urls" format:"uri"`
	RemovedURLCount int64    `json:"removed_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	RemovedURLs []string `json:"removed_urls" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		ChangeDetectionType respjson.Field
		DetectedAt          respjson.Field
		Mode                respjson.Field
		MonitorID           respjson.Field
		RunID               respjson.Field
		Summary             respjson.Field
		Tags                respjson.Field
		TargetType          respjson.Field
		Title               respjson.Field
		URL                 respjson.Field
		AddedURLCount       respjson.Field
		AddedURLs           respjson.Field
		AfterTextExcerpt    respjson.Field
		BeforeTextExcerpt   respjson.Field
		Confidence          respjson.Field
		Diff                respjson.Field
		Evidence            respjson.Field
		Importance          respjson.Field
		MatchedURLCount     respjson.Field
		MatchedURLs         respjson.Field
		RemovedURLCount     respjson.Field
		RemovedURLs         respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountChangesResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountChangesResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListAccountChangesResponseDataEvidence struct {
	// Snapshot of the content after the change.
	After string `json:"after" api:"required"`
	// Snapshot of the content before the change.
	Before string `json:"before" api:"required"`
	// Optional URL the evidence relates to. Absent for whole-target diffs.
	URL string `json:"url" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		After       respjson.Field
		Before      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountChangesResponseDataEvidence) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountChangesResponseDataEvidence) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorListAccountChangesResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountChangesResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountChangesResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListAccountRunsResponse struct {
	Data       []MonitorListAccountRunsResponseData `json:"data" api:"required"`
	HasMore    bool                                 `json:"has_more" api:"required"`
	NextCursor string                               `json:"next_cursor" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorListAccountRunsResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		HasMore     respjson.Field
		NextCursor  respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountRunsResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountRunsResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListAccountRunsResponseData struct {
	ID string `json:"id" api:"required"`
	// True when this run established the monitor's initial baseline; baseline runs
	// perform no change detection.
	BaselineCreated bool `json:"baseline_created" api:"required"`
	ChangeDetected  bool `json:"change_detected" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType string `json:"change_detection_type" api:"required"`
	// Credits charged for this run (0 for skipped/failed runs).
	CreditsCharged int64  `json:"credits_charged" api:"required"`
	MonitorID      string `json:"monitor_id" api:"required"`
	// A baseline run follows creation or a target or detection change.
	//
	// Any of "baseline", "scheduled".
	RunType string `json:"run_type" api:"required"`
	// Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
	// (insufficient credits, monitor paused, or superseded by a concurrent run).
	//
	// Any of "queued", "running", "completed", "failed", "skipped".
	Status string `json:"status" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType  string                                  `json:"target_type" api:"required"`
	ChangeID    string                                  `json:"change_id" api:"nullable"`
	CompletedAt time.Time                               `json:"completed_at" api:"nullable" format:"date-time"`
	Error       MonitorListAccountRunsResponseDataError `json:"error" api:"nullable"`
	// Why a skipped run never executed; null unless status is `skipped`.
	//
	// Any of "insufficient_credits", "monitor_paused", "superseded".
	SkipReason string    `json:"skip_reason" api:"nullable"`
	StartedAt  time.Time `json:"started_at" api:"nullable" format:"date-time"`
	// All webhook deliveries attempted by this run — one per subscribed event that
	// fired. Omitted when no webhook was attempted, including runs created before
	// event selection was added.
	WebhookDeliveries []WebhookDelivery `json:"webhook_deliveries"`
	// Deprecated. Use `webhook_deliveries` for all attempts.
	//
	// Deprecated: deprecated
	WebhookDelivery WebhookDelivery `json:"webhook_delivery"`
	// Webhook delivery IDs for this run.
	WebhookDeliveryIDs []string `json:"webhook_delivery_ids"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		BaselineCreated     respjson.Field
		ChangeDetected      respjson.Field
		ChangeDetectionType respjson.Field
		CreditsCharged      respjson.Field
		MonitorID           respjson.Field
		RunType             respjson.Field
		Status              respjson.Field
		TargetType          respjson.Field
		ChangeID            respjson.Field
		CompletedAt         respjson.Field
		Error               respjson.Field
		SkipReason          respjson.Field
		StartedAt           respjson.Field
		WebhookDeliveries   respjson.Field
		WebhookDelivery     respjson.Field
		WebhookDeliveryIDs  respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountRunsResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountRunsResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListAccountRunsResponseDataError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountRunsResponseDataError) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountRunsResponseDataError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorListAccountRunsResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListAccountRunsResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorListAccountRunsResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListChangesResponse struct {
	Data       []MonitorListChangesResponseData `json:"data" api:"required"`
	HasMore    bool                             `json:"has_more" api:"required"`
	NextCursor string                           `json:"next_cursor" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorListChangesResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		HasMore     respjson.Field
		NextCursor  respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListChangesResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorListChangesResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detected change, including applicable diffs, URLs, and supporting evidence.
type MonitorListChangesResponseData struct {
	ID string `json:"id" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType string    `json:"change_detection_type" api:"required"`
	DetectedAt          time.Time `json:"detected_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode      string `json:"mode" api:"required"`
	MonitorID string `json:"monitor_id" api:"required"`
	// The run that detected this change.
	RunID   string `json:"run_id" api:"required"`
	Summary string `json:"summary" api:"required"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType    string `json:"target_type" api:"required"`
	Title         string `json:"title" api:"required"`
	URL           string `json:"url" api:"required" format:"uri"`
	AddedURLCount int64  `json:"added_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	AddedURLs         []string `json:"added_urls" format:"uri"`
	AfterTextExcerpt  string   `json:"after_text_excerpt"`
	BeforeTextExcerpt string   `json:"before_text_excerpt"`
	Confidence        float64  `json:"confidence"`
	// Text diff between the previous and current page baseline (page targets).
	Diff     string                                   `json:"diff"`
	Evidence []MonitorListChangesResponseDataEvidence `json:"evidence"`
	// Any of "low", "medium", "high".
	Importance      string `json:"importance"`
	MatchedURLCount int64  `json:"matched_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	MatchedURLs     []string `json:"matched_urls" format:"uri"`
	RemovedURLCount int64    `json:"removed_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	RemovedURLs []string `json:"removed_urls" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		ChangeDetectionType respjson.Field
		DetectedAt          respjson.Field
		Mode                respjson.Field
		MonitorID           respjson.Field
		RunID               respjson.Field
		Summary             respjson.Field
		Tags                respjson.Field
		TargetType          respjson.Field
		Title               respjson.Field
		URL                 respjson.Field
		AddedURLCount       respjson.Field
		AddedURLs           respjson.Field
		AfterTextExcerpt    respjson.Field
		BeforeTextExcerpt   respjson.Field
		Confidence          respjson.Field
		Diff                respjson.Field
		Evidence            respjson.Field
		Importance          respjson.Field
		MatchedURLCount     respjson.Field
		MatchedURLs         respjson.Field
		RemovedURLCount     respjson.Field
		RemovedURLs         respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListChangesResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorListChangesResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListChangesResponseDataEvidence struct {
	// Snapshot of the content after the change.
	After string `json:"after" api:"required"`
	// Snapshot of the content before the change.
	Before string `json:"before" api:"required"`
	// Optional URL the evidence relates to. Absent for whole-target diffs.
	URL string `json:"url" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		After       respjson.Field
		Before      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListChangesResponseDataEvidence) RawJSON() string { return r.JSON.raw }
func (r *MonitorListChangesResponseDataEvidence) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorListChangesResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListChangesResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorListChangesResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListRunsResponse struct {
	Data       []MonitorListRunsResponseData `json:"data" api:"required"`
	HasMore    bool                          `json:"has_more" api:"required"`
	NextCursor string                        `json:"next_cursor" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorListRunsResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		HasMore     respjson.Field
		NextCursor  respjson.Field
		RequestID   respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListRunsResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorListRunsResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListRunsResponseData struct {
	ID string `json:"id" api:"required"`
	// True when this run established the monitor's initial baseline; baseline runs
	// perform no change detection.
	BaselineCreated bool `json:"baseline_created" api:"required"`
	ChangeDetected  bool `json:"change_detected" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType string `json:"change_detection_type" api:"required"`
	// Credits charged for this run (0 for skipped/failed runs).
	CreditsCharged int64  `json:"credits_charged" api:"required"`
	MonitorID      string `json:"monitor_id" api:"required"`
	// A baseline run follows creation or a target or detection change.
	//
	// Any of "baseline", "scheduled".
	RunType string `json:"run_type" api:"required"`
	// Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
	// (insufficient credits, monitor paused, or superseded by a concurrent run).
	//
	// Any of "queued", "running", "completed", "failed", "skipped".
	Status string `json:"status" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType  string                           `json:"target_type" api:"required"`
	ChangeID    string                           `json:"change_id" api:"nullable"`
	CompletedAt time.Time                        `json:"completed_at" api:"nullable" format:"date-time"`
	Error       MonitorListRunsResponseDataError `json:"error" api:"nullable"`
	// Why a skipped run never executed; null unless status is `skipped`.
	//
	// Any of "insufficient_credits", "monitor_paused", "superseded".
	SkipReason string    `json:"skip_reason" api:"nullable"`
	StartedAt  time.Time `json:"started_at" api:"nullable" format:"date-time"`
	// All webhook deliveries attempted by this run — one per subscribed event that
	// fired. Omitted when no webhook was attempted, including runs created before
	// event selection was added.
	WebhookDeliveries []WebhookDelivery `json:"webhook_deliveries"`
	// Deprecated. Use `webhook_deliveries` for all attempts.
	//
	// Deprecated: deprecated
	WebhookDelivery WebhookDelivery `json:"webhook_delivery"`
	// Webhook delivery IDs for this run.
	WebhookDeliveryIDs []string `json:"webhook_delivery_ids"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		BaselineCreated     respjson.Field
		ChangeDetected      respjson.Field
		ChangeDetectionType respjson.Field
		CreditsCharged      respjson.Field
		MonitorID           respjson.Field
		RunType             respjson.Field
		Status              respjson.Field
		TargetType          respjson.Field
		ChangeID            respjson.Field
		CompletedAt         respjson.Field
		Error               respjson.Field
		SkipReason          respjson.Field
		StartedAt           respjson.Field
		WebhookDeliveries   respjson.Field
		WebhookDelivery     respjson.Field
		WebhookDeliveryIDs  respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListRunsResponseData) RawJSON() string { return r.JSON.raw }
func (r *MonitorListRunsResponseData) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListRunsResponseDataError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListRunsResponseDataError) RawJSON() string { return r.JSON.raw }
func (r *MonitorListRunsResponseDataError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorListRunsResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorListRunsResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorListRunsResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetChangeResponse struct {
	ID string `json:"id" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType MonitorGetChangeResponseChangeDetectionType `json:"change_detection_type" api:"required"`
	DetectedAt          time.Time                                   `json:"detected_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode      MonitorGetChangeResponseMode `json:"mode" api:"required"`
	MonitorID string                       `json:"monitor_id" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// The run that detected this change.
	RunID   string `json:"run_id" api:"required"`
	Summary string `json:"summary" api:"required"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType    MonitorGetChangeResponseTargetType `json:"target_type" api:"required"`
	Title         string                             `json:"title" api:"required"`
	URL           string                             `json:"url" api:"required" format:"uri"`
	AddedURLCount int64                              `json:"added_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	AddedURLs         []string `json:"added_urls" format:"uri"`
	AfterTextExcerpt  string   `json:"after_text_excerpt"`
	BeforeTextExcerpt string   `json:"before_text_excerpt"`
	Confidence        float64  `json:"confidence"`
	// Text diff between the previous and current page baseline (page targets).
	Diff     string                             `json:"diff"`
	Evidence []MonitorGetChangeResponseEvidence `json:"evidence"`
	// Any of "low", "medium", "high".
	Importance MonitorGetChangeResponseImportance `json:"importance"`
	// Credits this request used and your remaining balance.
	KeyMetadata     MonitorGetChangeResponseKeyMetadata `json:"key_metadata"`
	MatchedURLCount int64                               `json:"matched_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	MatchedURLs     []string `json:"matched_urls" format:"uri"`
	RemovedURLCount int64    `json:"removed_url_count"`
	// At most 500 URLs are included; the corresponding count field is always exact.
	RemovedURLs []string `json:"removed_urls" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		ChangeDetectionType respjson.Field
		DetectedAt          respjson.Field
		Mode                respjson.Field
		MonitorID           respjson.Field
		RequestID           respjson.Field
		RunID               respjson.Field
		Summary             respjson.Field
		Tags                respjson.Field
		TargetType          respjson.Field
		Title               respjson.Field
		URL                 respjson.Field
		AddedURLCount       respjson.Field
		AddedURLs           respjson.Field
		AfterTextExcerpt    respjson.Field
		BeforeTextExcerpt   respjson.Field
		Confidence          respjson.Field
		Diff                respjson.Field
		Evidence            respjson.Field
		Importance          respjson.Field
		KeyMetadata         respjson.Field
		MatchedURLCount     respjson.Field
		MatchedURLs         respjson.Field
		RemovedURLCount     respjson.Field
		RemovedURLs         respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetChangeResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetChangeResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetChangeResponseChangeDetectionType string

const (
	MonitorGetChangeResponseChangeDetectionTypeExact    MonitorGetChangeResponseChangeDetectionType = "exact"
	MonitorGetChangeResponseChangeDetectionTypeSemantic MonitorGetChangeResponseChangeDetectionType = "semantic"
)

// Always `web`. Optional.
type MonitorGetChangeResponseMode string

const (
	MonitorGetChangeResponseModeWeb MonitorGetChangeResponseMode = "web"
)

type MonitorGetChangeResponseTargetType string

const (
	MonitorGetChangeResponseTargetTypePage    MonitorGetChangeResponseTargetType = "page"
	MonitorGetChangeResponseTargetTypeSitemap MonitorGetChangeResponseTargetType = "sitemap"
	MonitorGetChangeResponseTargetTypeExtract MonitorGetChangeResponseTargetType = "extract"
)

type MonitorGetChangeResponseEvidence struct {
	// Snapshot of the content after the change.
	After string `json:"after" api:"required"`
	// Snapshot of the content before the change.
	Before string `json:"before" api:"required"`
	// Optional URL the evidence relates to. Absent for whole-target diffs.
	URL string `json:"url" format:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		After       respjson.Field
		Before      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetChangeResponseEvidence) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetChangeResponseEvidence) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetChangeResponseImportance string

const (
	MonitorGetChangeResponseImportanceLow    MonitorGetChangeResponseImportance = "low"
	MonitorGetChangeResponseImportanceMedium MonitorGetChangeResponseImportance = "medium"
	MonitorGetChangeResponseImportanceHigh   MonitorGetChangeResponseImportance = "high"
)

// Credits this request used and your remaining balance.
type MonitorGetChangeResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetChangeResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetChangeResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetRunResponse struct {
	ID string `json:"id" api:"required"`
	// True when this run established the monitor's initial baseline; baseline runs
	// perform no change detection.
	BaselineCreated bool `json:"baseline_created" api:"required"`
	ChangeDetected  bool `json:"change_detected" api:"required"`
	// Any of "exact", "semantic".
	ChangeDetectionType MonitorGetRunResponseChangeDetectionType `json:"change_detection_type" api:"required"`
	// Credits charged for this run (0 for skipped/failed runs).
	CreditsCharged int64  `json:"credits_charged" api:"required"`
	MonitorID      string `json:"monitor_id" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// A baseline run follows creation or a target or detection change.
	//
	// Any of "baseline", "scheduled".
	RunType MonitorGetRunResponseRunType `json:"run_type" api:"required"`
	// Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
	// (insufficient credits, monitor paused, or superseded by a concurrent run).
	//
	// Any of "queued", "running", "completed", "failed", "skipped".
	Status MonitorGetRunResponseStatus `json:"status" api:"required"`
	// Any of "page", "sitemap", "extract".
	TargetType  MonitorGetRunResponseTargetType `json:"target_type" api:"required"`
	ChangeID    string                          `json:"change_id" api:"nullable"`
	CompletedAt time.Time                       `json:"completed_at" api:"nullable" format:"date-time"`
	Error       MonitorGetRunResponseError      `json:"error" api:"nullable"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorGetRunResponseKeyMetadata `json:"key_metadata"`
	// Why a skipped run never executed; null unless status is `skipped`.
	//
	// Any of "insufficient_credits", "monitor_paused", "superseded".
	SkipReason MonitorGetRunResponseSkipReason `json:"skip_reason" api:"nullable"`
	StartedAt  time.Time                       `json:"started_at" api:"nullable" format:"date-time"`
	// All webhook deliveries attempted by this run — one per subscribed event that
	// fired. Omitted when no webhook was attempted, including runs created before
	// event selection was added.
	WebhookDeliveries []WebhookDelivery `json:"webhook_deliveries"`
	// Deprecated. Use `webhook_deliveries` for all attempts.
	//
	// Deprecated: deprecated
	WebhookDelivery WebhookDelivery `json:"webhook_delivery"`
	// Webhook delivery IDs for this run.
	WebhookDeliveryIDs []string `json:"webhook_delivery_ids"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                  respjson.Field
		BaselineCreated     respjson.Field
		ChangeDetected      respjson.Field
		ChangeDetectionType respjson.Field
		CreditsCharged      respjson.Field
		MonitorID           respjson.Field
		RequestID           respjson.Field
		RunType             respjson.Field
		Status              respjson.Field
		TargetType          respjson.Field
		ChangeID            respjson.Field
		CompletedAt         respjson.Field
		Error               respjson.Field
		KeyMetadata         respjson.Field
		SkipReason          respjson.Field
		StartedAt           respjson.Field
		WebhookDeliveries   respjson.Field
		WebhookDelivery     respjson.Field
		WebhookDeliveryIDs  respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetRunResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetRunResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorGetRunResponseChangeDetectionType string

const (
	MonitorGetRunResponseChangeDetectionTypeExact    MonitorGetRunResponseChangeDetectionType = "exact"
	MonitorGetRunResponseChangeDetectionTypeSemantic MonitorGetRunResponseChangeDetectionType = "semantic"
)

// A baseline run follows creation or a target or detection change.
type MonitorGetRunResponseRunType string

const (
	MonitorGetRunResponseRunTypeBaseline  MonitorGetRunResponseRunType = "baseline"
	MonitorGetRunResponseRunTypeScheduled MonitorGetRunResponseRunType = "scheduled"
)

// Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
// (insufficient credits, monitor paused, or superseded by a concurrent run).
type MonitorGetRunResponseStatus string

const (
	MonitorGetRunResponseStatusQueued    MonitorGetRunResponseStatus = "queued"
	MonitorGetRunResponseStatusRunning   MonitorGetRunResponseStatus = "running"
	MonitorGetRunResponseStatusCompleted MonitorGetRunResponseStatus = "completed"
	MonitorGetRunResponseStatusFailed    MonitorGetRunResponseStatus = "failed"
	MonitorGetRunResponseStatusSkipped   MonitorGetRunResponseStatus = "skipped"
)

type MonitorGetRunResponseTargetType string

const (
	MonitorGetRunResponseTargetTypePage    MonitorGetRunResponseTargetType = "page"
	MonitorGetRunResponseTargetTypeSitemap MonitorGetRunResponseTargetType = "sitemap"
	MonitorGetRunResponseTargetTypeExtract MonitorGetRunResponseTargetType = "extract"
)

type MonitorGetRunResponseError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetRunResponseError) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetRunResponseError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorGetRunResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorGetRunResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorGetRunResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Why a skipped run never executed; null unless status is `skipped`.
type MonitorGetRunResponseSkipReason string

const (
	MonitorGetRunResponseSkipReasonInsufficientCredits MonitorGetRunResponseSkipReason = "insufficient_credits"
	MonitorGetRunResponseSkipReasonMonitorPaused       MonitorGetRunResponseSkipReason = "monitor_paused"
	MonitorGetRunResponseSkipReasonSuperseded          MonitorGetRunResponseSkipReason = "superseded"
)

type MonitorRotateWebhookSecretResponse struct {
	ID string `json:"id" api:"required"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorRotateWebhookSecretResponseChangeDetectionUnion `json:"change_detection" api:"required"`
	CreatedAt       time.Time                                              `json:"created_at" api:"required" format:"date-time"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode MonitorRotateWebhookSecretResponseMode `json:"mode" api:"required"`
	Name string                                 `json:"name" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// Current state. Failed monitors keep running; paused monitors must be resumed
	// with `status: "active"`.
	//
	// Any of "active", "paused", "failed".
	Status MonitorRotateWebhookSecretResponseStatus `json:"status" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target    MonitorRotateWebhookSecretResponseTargetUnion `json:"target" api:"required"`
	UpdatedAt time.Time                                     `json:"updated_at" api:"required" format:"date-time"`
	// Comparison baseline, included on Retrieve. Null until capture completes or after
	// target changes.
	Baseline MonitorRotateWebhookSecretResponseBaselineUnion `json:"baseline" api:"nullable"`
	// Credits this request used and your remaining balance.
	KeyMetadata  MonitorRotateWebhookSecretResponseKeyMetadata `json:"key_metadata"`
	LastChangeAt time.Time                                     `json:"last_change_at" api:"nullable" format:"date-time"`
	// Error from the most recent failed run; null when the last run succeeded.
	LastError MonitorRotateWebhookSecretResponseLastError `json:"last_error" api:"nullable"`
	LastRunAt time.Time                                   `json:"last_run_at" api:"nullable" format:"date-time"`
	// When the next scheduled run is due; null while paused.
	NextRunAt time.Time `json:"next_run_at" api:"nullable" format:"date-time"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorRotateWebhookSecretResponseSchedule `json:"schedule"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorRotateWebhookSecretResponseWebhook `json:"webhook" api:"nullable"`
	// Present while webhook deliveries are failing consecutively; null when deliveries
	// are healthy or no webhook is configured. Cleared on the next successful delivery
	// and when the webhook URL changes.
	WebhookFailure MonitorRotateWebhookSecretResponseWebhookFailure `json:"webhook_failure" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID              respjson.Field
		ChangeDetection respjson.Field
		CreatedAt       respjson.Field
		Mode            respjson.Field
		Name            respjson.Field
		RequestID       respjson.Field
		Status          respjson.Field
		Target          respjson.Field
		UpdatedAt       respjson.Field
		Baseline        respjson.Field
		KeyMetadata     respjson.Field
		LastChangeAt    respjson.Field
		LastError       respjson.Field
		LastRunAt       respjson.Field
		NextRunAt       respjson.Field
		Schedule        respjson.Field
		Tags            respjson.Field
		Webhook         respjson.Field
		WebhookFailure  respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorRotateWebhookSecretResponseChangeDetectionUnion contains all possible
// properties and values from
// [MonitorRotateWebhookSecretResponseChangeDetectionExact],
// [MonitorRotateWebhookSecretResponseChangeDetectionSemantic].
//
// Use the [MonitorRotateWebhookSecretResponseChangeDetectionUnion.AsAny] method to
// switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorRotateWebhookSecretResponseChangeDetectionUnion struct {
	// Any of "exact", "semantic".
	Type string `json:"type"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseChangeDetectionSemantic].
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	JSON                struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorRotateWebhookSecretResponseChangeDetection is implemented by each
// variant of [MonitorRotateWebhookSecretResponseChangeDetectionUnion] to add type
// safety for the return type of
// [MonitorRotateWebhookSecretResponseChangeDetectionUnion.AsAny]
type anyMonitorRotateWebhookSecretResponseChangeDetection interface {
	implMonitorRotateWebhookSecretResponseChangeDetectionUnion()
}

func (MonitorRotateWebhookSecretResponseChangeDetectionExact) implMonitorRotateWebhookSecretResponseChangeDetectionUnion() {
}
func (MonitorRotateWebhookSecretResponseChangeDetectionSemantic) implMonitorRotateWebhookSecretResponseChangeDetectionUnion() {
}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorRotateWebhookSecretResponseChangeDetectionUnion.AsAny().(type) {
//	case contextdev.MonitorRotateWebhookSecretResponseChangeDetectionExact:
//	case contextdev.MonitorRotateWebhookSecretResponseChangeDetectionSemantic:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorRotateWebhookSecretResponseChangeDetectionUnion) AsAny() anyMonitorRotateWebhookSecretResponseChangeDetection {
	switch u.Type {
	case "exact":
		return u.AsExact()
	case "semantic":
		return u.AsSemantic()
	}
	return nil
}

func (u MonitorRotateWebhookSecretResponseChangeDetectionUnion) AsExact() (v MonitorRotateWebhookSecretResponseChangeDetectionExact) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseChangeDetectionUnion) AsSemantic() (v MonitorRotateWebhookSecretResponseChangeDetectionSemantic) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorRotateWebhookSecretResponseChangeDetectionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorRotateWebhookSecretResponseChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
type MonitorRotateWebhookSecretResponseChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseChangeDetectionExact) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
type MonitorRotateWebhookSecretResponseChangeDetectionSemantic struct {
	// Use `semantic` to judge changes against the target instructions.
	Type constant.Semantic `json:"type" default:"semantic"`
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold float64 `json:"confidence_threshold"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		ConfidenceThreshold respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseChangeDetectionSemantic) RawJSON() string {
	return r.JSON.raw
}
func (r *MonitorRotateWebhookSecretResponseChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Always `web`. Optional.
type MonitorRotateWebhookSecretResponseMode string

const (
	MonitorRotateWebhookSecretResponseModeWeb MonitorRotateWebhookSecretResponseMode = "web"
)

// Current state. Failed monitors keep running; paused monitors must be resumed
// with `status: "active"`.
type MonitorRotateWebhookSecretResponseStatus string

const (
	MonitorRotateWebhookSecretResponseStatusActive MonitorRotateWebhookSecretResponseStatus = "active"
	MonitorRotateWebhookSecretResponseStatusPaused MonitorRotateWebhookSecretResponseStatus = "paused"
	MonitorRotateWebhookSecretResponseStatusFailed MonitorRotateWebhookSecretResponseStatus = "failed"
)

// MonitorRotateWebhookSecretResponseTargetUnion contains all possible properties
// and values from [MonitorRotateWebhookSecretResponseTargetPage],
// [MonitorRotateWebhookSecretResponseTargetSitemap],
// [MonitorRotateWebhookSecretResponseTargetExtract].
//
// Use the [MonitorRotateWebhookSecretResponseTargetUnion.AsAny] method to switch
// on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorRotateWebhookSecretResponseTargetUnion struct {
	// Any of "page", "sitemap", "extract".
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetPage].
	Actions []MonitorRotateWebhookSecretResponseTargetPageActionUnion `json:"actions"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetPage].
	ExcludeSelectors []string `json:"exclude_selectors"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetPage].
	IncludeSelectors []string `json:"include_selectors"`
	Instructions     string   `json:"instructions"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetPage].
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetSitemap].
	Exclude []string `json:"exclude"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetSitemap].
	Include []string `json:"include"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetSitemap].
	MaxURLs int64 `json:"max_urls"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetExtract].
	FollowSubdomains bool `json:"follow_subdomains"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetExtract].
	MaxDepth int64 `json:"max_depth"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetExtract].
	MaxPages int64 `json:"max_pages"`
	// This field is from variant [MonitorRotateWebhookSecretResponseTargetExtract].
	Schema map[string]any `json:"schema"`
	JSON   struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		Exclude             respjson.Field
		Include             respjson.Field
		MaxURLs             respjson.Field
		FollowSubdomains    respjson.Field
		MaxDepth            respjson.Field
		MaxPages            respjson.Field
		Schema              respjson.Field
		raw                 string
	} `json:"-"`
}

// anyMonitorRotateWebhookSecretResponseTarget is implemented by each variant of
// [MonitorRotateWebhookSecretResponseTargetUnion] to add type safety for the
// return type of [MonitorRotateWebhookSecretResponseTargetUnion.AsAny]
type anyMonitorRotateWebhookSecretResponseTarget interface {
	implMonitorRotateWebhookSecretResponseTargetUnion()
}

func (MonitorRotateWebhookSecretResponseTargetPage) implMonitorRotateWebhookSecretResponseTargetUnion() {
}
func (MonitorRotateWebhookSecretResponseTargetSitemap) implMonitorRotateWebhookSecretResponseTargetUnion() {
}
func (MonitorRotateWebhookSecretResponseTargetExtract) implMonitorRotateWebhookSecretResponseTargetUnion() {
}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorRotateWebhookSecretResponseTargetUnion.AsAny().(type) {
//	case contextdev.MonitorRotateWebhookSecretResponseTargetPage:
//	case contextdev.MonitorRotateWebhookSecretResponseTargetSitemap:
//	case contextdev.MonitorRotateWebhookSecretResponseTargetExtract:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorRotateWebhookSecretResponseTargetUnion) AsAny() anyMonitorRotateWebhookSecretResponseTarget {
	switch u.Type {
	case "page":
		return u.AsPage()
	case "sitemap":
		return u.AsSitemap()
	case "extract":
		return u.AsExtract()
	}
	return nil
}

func (u MonitorRotateWebhookSecretResponseTargetUnion) AsPage() (v MonitorRotateWebhookSecretResponseTargetPage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseTargetUnion) AsSitemap() (v MonitorRotateWebhookSecretResponseTargetSitemap) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseTargetUnion) AsExtract() (v MonitorRotateWebhookSecretResponseTargetExtract) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorRotateWebhookSecretResponseTargetUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorRotateWebhookSecretResponseTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
type MonitorRotateWebhookSecretResponseTargetPage struct {
	// Use `page` to watch one web page.
	Type constant.Page `json:"type" default:"page"`
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorRotateWebhookSecretResponseTargetPageActionUnion `json:"actions" api:"nullable"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions string `json:"instructions"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace bool `json:"normalize_whitespace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type                respjson.Field
		URL                 respjson.Field
		Actions             respjson.Field
		ExcludeSelectors    respjson.Field
		IncludeSelectors    respjson.Field
		Instructions        respjson.Field
		NormalizeWhitespace respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetPage) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorRotateWebhookSecretResponseTargetPageActionUnion contains all possible
// properties and values from
// [MonitorRotateWebhookSecretResponseTargetPageActionWait],
// [MonitorRotateWebhookSecretResponseTargetPageActionPerform],
// [MonitorRotateWebhookSecretResponseTargetPageActionScroll].
//
// Use the [MonitorRotateWebhookSecretResponseTargetPageActionUnion.AsAny] method
// to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorRotateWebhookSecretResponseTargetPageActionUnion struct {
	// Any of "wait", "perform", "scroll".
	Do string `json:"do"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionWait].
	TimeMs int64 `json:"timeMs"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionPerform].
	Action string `json:"action"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionScroll].
	Amount MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionScroll].
	Container string `json:"container"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionScroll].
	Direction string `json:"direction"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseTargetPageActionScroll].
	MaxScrolls int64 `json:"maxScrolls"`
	JSON       struct {
		Do         respjson.Field
		TimeMs     respjson.Field
		Action     respjson.Field
		Amount     respjson.Field
		Container  respjson.Field
		Direction  respjson.Field
		MaxScrolls respjson.Field
		raw        string
	} `json:"-"`
}

// anyMonitorRotateWebhookSecretResponseTargetPageAction is implemented by each
// variant of [MonitorRotateWebhookSecretResponseTargetPageActionUnion] to add type
// safety for the return type of
// [MonitorRotateWebhookSecretResponseTargetPageActionUnion.AsAny]
type anyMonitorRotateWebhookSecretResponseTargetPageAction interface {
	implMonitorRotateWebhookSecretResponseTargetPageActionUnion()
}

func (MonitorRotateWebhookSecretResponseTargetPageActionWait) implMonitorRotateWebhookSecretResponseTargetPageActionUnion() {
}
func (MonitorRotateWebhookSecretResponseTargetPageActionPerform) implMonitorRotateWebhookSecretResponseTargetPageActionUnion() {
}
func (MonitorRotateWebhookSecretResponseTargetPageActionScroll) implMonitorRotateWebhookSecretResponseTargetPageActionUnion() {
}

// Use the following switch statement to find the correct variant
//
//	switch variant := MonitorRotateWebhookSecretResponseTargetPageActionUnion.AsAny().(type) {
//	case contextdev.MonitorRotateWebhookSecretResponseTargetPageActionWait:
//	case contextdev.MonitorRotateWebhookSecretResponseTargetPageActionPerform:
//	case contextdev.MonitorRotateWebhookSecretResponseTargetPageActionScroll:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u MonitorRotateWebhookSecretResponseTargetPageActionUnion) AsAny() anyMonitorRotateWebhookSecretResponseTargetPageAction {
	switch u.Do {
	case "wait":
		return u.AsWait()
	case "perform":
		return u.AsPerform()
	case "scroll":
		return u.AsScroll()
	}
	return nil
}

func (u MonitorRotateWebhookSecretResponseTargetPageActionUnion) AsWait() (v MonitorRotateWebhookSecretResponseTargetPageActionWait) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseTargetPageActionUnion) AsPerform() (v MonitorRotateWebhookSecretResponseTargetPageActionPerform) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseTargetPageActionUnion) AsScroll() (v MonitorRotateWebhookSecretResponseTargetPageActionScroll) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorRotateWebhookSecretResponseTargetPageActionUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorRotateWebhookSecretResponseTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
type MonitorRotateWebhookSecretResponseTargetPageActionWait struct {
	// Use `wait` to pause for a fixed duration.
	Do constant.Wait `json:"do" default:"wait"`
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		TimeMs      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetPageActionWait) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
type MonitorRotateWebhookSecretResponseTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	Do constant.Perform `json:"do" default:"perform"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Do          respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetPageActionPerform) RawJSON() string {
	return r.JSON.raw
}
func (r *MonitorRotateWebhookSecretResponseTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
type MonitorRotateWebhookSecretResponseTargetPageActionScroll struct {
	// Use `scroll` to move through the page or a container.
	Do constant.Scroll `json:"do" default:"scroll"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion `json:"amount"`
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container string `json:"container"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls int64 `json:"maxScrolls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Do          respjson.Field
		Amount      respjson.Field
		Container   respjson.Field
		Direction   respjson.Field
		MaxScrolls  respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetPageActionScroll) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion contains all
// possible properties and values from [int64], [string].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfInt
// OfMonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString]
type MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfMonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString string `json:",inline"`
	JSON                                                                   struct {
		OfInt                                                                  respjson.Field
		OfMonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString respjson.Field
		raw                                                                    string
	} `json:"-"`
}

func (u MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion) AsInt() (v int64) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion) AsMonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion) RawJSON() string {
	return u.JSON.raw
}

func (r *MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString string

const (
	MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountStringViewport MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString = "viewport"
	MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountStringMax      MonitorRotateWebhookSecretResponseTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
type MonitorRotateWebhookSecretResponseTargetSitemap struct {
	// Use `sitemap` to watch a site for added or removed URLs.
	Type constant.Sitemap `json:"type" default:"sitemap"`
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude"`
	// URL path patterns to include (max 50).
	Include []string `json:"include"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs int64 `json:"max_urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Exclude     respjson.Field
		Include     respjson.Field
		MaxURLs     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetSitemap) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
type MonitorRotateWebhookSecretResponseTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Use `extract` to watch structured data across selected pages.
	Type constant.Extract `json:"type" default:"extract"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains bool `json:"follow_subdomains"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth int64 `json:"max_depth"`
	// Maximum number of pages to track.
	MaxPages int64 `json:"max_pages"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions     respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		FollowSubdomains respjson.Field
		MaxDepth         respjson.Field
		MaxPages         respjson.Field
		Schema           respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseTargetExtract) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// MonitorRotateWebhookSecretResponseBaselineUnion contains all possible properties
// and values from [MonitorRotateWebhookSecretResponseBaselinePageBaseline],
// [MonitorRotateWebhookSecretResponseBaselineSitemapBaseline],
// [MonitorRotateWebhookSecretResponseBaselineExtractBaseline].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type MonitorRotateWebhookSecretResponseBaselineUnion struct {
	CapturedAt time.Time `json:"captured_at"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseBaselinePageBaseline].
	Text string `json:"text"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseBaselineSitemapBaseline].
	URLCount int64 `json:"url_count"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseBaselineSitemapBaseline].
	URLs []string `json:"urls"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseBaselineExtractBaseline].
	Data any `json:"data"`
	// This field is from variant
	// [MonitorRotateWebhookSecretResponseBaselineExtractBaseline].
	URLsAnalyzed []string `json:"urls_analyzed"`
	JSON         struct {
		CapturedAt   respjson.Field
		Text         respjson.Field
		URLCount     respjson.Field
		URLs         respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		raw          string
	} `json:"-"`
}

func (u MonitorRotateWebhookSecretResponseBaselineUnion) AsPageBaseline() (v MonitorRotateWebhookSecretResponseBaselinePageBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseBaselineUnion) AsSitemapBaseline() (v MonitorRotateWebhookSecretResponseBaselineSitemapBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u MonitorRotateWebhookSecretResponseBaselineUnion) AsExtractBaseline() (v MonitorRotateWebhookSecretResponseBaselineExtractBaseline) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u MonitorRotateWebhookSecretResponseBaselineUnion) RawJSON() string { return u.JSON.raw }

func (r *MonitorRotateWebhookSecretResponseBaselineUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `page` monitor: the visible page text as last observed.
type MonitorRotateWebhookSecretResponseBaselinePageBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// The page's visible text as last observed.
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseBaselinePageBaseline) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseBaselinePageBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of a `sitemap` monitor: the normalized URL set as last
// observed.
type MonitorRotateWebhookSecretResponseBaselineSitemapBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Number of URLs in the baseline.
	URLCount int64 `json:"url_count" api:"required"`
	// The sitemap URLs as last observed (sorted, normalized).
	URLs []string `json:"urls" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt  respjson.Field
		URLCount    respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseBaselineSitemapBaseline) RawJSON() string {
	return r.JSON.raw
}
func (r *MonitorRotateWebhookSecretResponseBaselineSitemapBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Current baseline of an `extract` monitor: the pages it tracks and the structured
// data as last extracted.
type MonitorRotateWebhookSecretResponseBaselineExtractBaseline struct {
	// When this baseline was last captured or replaced.
	CapturedAt time.Time `json:"captured_at" api:"required" format:"date-time"`
	// Latest structured snapshot matching the extraction schema, refreshed at most
	// daily; `null` before capture.
	Data any `json:"data" api:"required"`
	// The page URLs the monitor tracks and analyzes for changes.
	URLsAnalyzed []string `json:"urls_analyzed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CapturedAt   respjson.Field
		Data         respjson.Field
		URLsAnalyzed respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseBaselineExtractBaseline) RawJSON() string {
	return r.JSON.raw
}
func (r *MonitorRotateWebhookSecretResponseBaselineExtractBaseline) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorRotateWebhookSecretResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Error from the most recent failed run; null when the last run succeeded.
type MonitorRotateWebhookSecretResponseLastError struct {
	Code    string `json:"code" api:"required"`
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Code        respjson.Field
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseLastError) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseLastError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
type MonitorRotateWebhookSecretResponseSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Frequency   respjson.Field
		Type        respjson.Field
		Unit        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseSchedule) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
type MonitorRotateWebhookSecretResponseWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfig `json:"retry"`
	// API-generated signing secret. Visible only with full access or `monitors:write`
	// permission.
	Secret string `json:"secret"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		Events      respjson.Field
		Retry       respjson.Field
		Secret      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseWebhook) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Present while webhook deliveries are failing consecutively; null when deliveries
// are healthy or no webhook is configured. Cleared on the next successful delivery
// and when the webhook URL changes.
type MonitorRotateWebhookSecretResponseWebhookFailure struct {
	// Number of consecutive delivery attempts that did not succeed.
	ConsecutiveFailures int64     `json:"consecutive_failures" api:"required"`
	LastFailedAt        time.Time `json:"last_failed_at" api:"required" format:"date-time"`
	// Human-readable description of the most recent failure.
	LastMessage string `json:"last_message" api:"required"`
	// Outcome of the most recent failed delivery. rejected means a non-2xx response;
	// failed means no HTTP response was received; skipped_unsafe_url means the URL
	// failed the public-endpoint safety check.
	//
	// Any of "rejected", "failed", "skipped_unsafe_url".
	LastStatus string `json:"last_status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsecutiveFailures respjson.Field
		LastFailedAt        respjson.Field
		LastMessage         respjson.Field
		LastStatus          respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRotateWebhookSecretResponseWebhookFailure) RawJSON() string { return r.JSON.raw }
func (r *MonitorRotateWebhookSecretResponseWebhookFailure) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorRunResponse struct {
	MonitorID string `json:"monitor_id" api:"required"`
	Queued    bool   `json:"queued" api:"required"`
	// Unique ID of this request, also in `X-Request-Id`. Include it when contacting
	// support.
	RequestID string `json:"request_id" api:"required" format:"uuid"`
	// ID of the queued run; pass it to Retrieve a monitor run.
	RunID string `json:"run_id" api:"required"`
	// Credits this request used and your remaining balance.
	KeyMetadata MonitorRunResponseKeyMetadata `json:"key_metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MonitorID   respjson.Field
		Queued      respjson.Field
		RequestID   respjson.Field
		RunID       respjson.Field
		KeyMetadata respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRunResponse) RawJSON() string { return r.JSON.raw }
func (r *MonitorRunResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Credits this request used and your remaining balance.
type MonitorRunResponseKeyMetadata struct {
	// Credits charged for this request.
	CreditsConsumed int64 `json:"credits_consumed" api:"required"`
	// Credits remaining for your organization.
	CreditsRemaining int64 `json:"credits_remaining" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CreditsConsumed  respjson.Field
		CreditsRemaining respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r MonitorRunResponseKeyMetadata) RawJSON() string { return r.JSON.raw }
func (r *MonitorRunResponseKeyMetadata) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorNewParams struct {
	// Display name for the monitor.
	Name string `json:"name" api:"required"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target MonitorNewParamsTargetUnion `json:"target,omitzero" api:"required"`
	// Webhook destination and delivery settings. Null means no webhook is configured.
	Webhook MonitorNewParamsWebhook `json:"webhook,omitzero"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorNewParamsChangeDetectionUnion `json:"change_detection,omitzero"`
	// Always `web`. Optional.
	//
	// Any of "web".
	Mode MonitorNewParamsMode `json:"mode,omitzero"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorNewParamsSchedule `json:"schedule,omitzero"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags,omitzero"`
	paramObj
}

func (r MonitorNewParams) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorNewParamsTargetUnion struct {
	OfPage    *MonitorNewParamsTargetPage    `json:",omitzero,inline"`
	OfSitemap *MonitorNewParamsTargetSitemap `json:",omitzero,inline"`
	OfExtract *MonitorNewParamsTargetExtract `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorNewParamsTargetUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfPage, u.OfSitemap, u.OfExtract)
}
func (u *MonitorNewParamsTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorNewParamsTargetUnion](
		"type",
		apijson.Discriminator[MonitorNewParamsTargetPage]("page"),
		apijson.Discriminator[MonitorNewParamsTargetSitemap]("sitemap"),
		apijson.Discriminator[MonitorNewParamsTargetExtract]("extract"),
	)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
//
// The properties Type, URL are required.
type MonitorNewParamsTargetPage struct {
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions param.Opt[string] `json:"instructions,omitzero"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace param.Opt[bool] `json:"normalize_whitespace,omitzero"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorNewParamsTargetPageActionUnion `json:"actions,omitzero"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors,omitzero"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors,omitzero"`
	// Use `page` to watch one web page.
	//
	// This field can be elided, and will marshal its zero value as "page".
	Type constant.Page `json:"type" default:"page"`
	paramObj
}

func (r MonitorNewParamsTargetPage) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetPage
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorNewParamsTargetPageActionUnion struct {
	OfWait    *MonitorNewParamsTargetPageActionWait    `json:",omitzero,inline"`
	OfPerform *MonitorNewParamsTargetPageActionPerform `json:",omitzero,inline"`
	OfScroll  *MonitorNewParamsTargetPageActionScroll  `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorNewParamsTargetPageActionUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfWait, u.OfPerform, u.OfScroll)
}
func (u *MonitorNewParamsTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorNewParamsTargetPageActionUnion](
		"do",
		apijson.Discriminator[MonitorNewParamsTargetPageActionWait]("wait"),
		apijson.Discriminator[MonitorNewParamsTargetPageActionPerform]("perform"),
		apijson.Discriminator[MonitorNewParamsTargetPageActionScroll]("scroll"),
	)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
//
// The properties Do, TimeMs are required.
type MonitorNewParamsTargetPageActionWait struct {
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// Use `wait` to pause for a fixed duration.
	//
	// This field can be elided, and will marshal its zero value as "wait".
	Do constant.Wait `json:"do" default:"wait"`
	paramObj
}

func (r MonitorNewParamsTargetPageActionWait) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetPageActionWait
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
//
// The properties Action, Do are required.
type MonitorNewParamsTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	//
	// This field can be elided, and will marshal its zero value as "perform".
	Do constant.Perform `json:"do" default:"perform"`
	paramObj
}

func (r MonitorNewParamsTargetPageActionPerform) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetPageActionPerform
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
//
// The property Do is required.
type MonitorNewParamsTargetPageActionScroll struct {
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container param.Opt[string] `json:"container,omitzero"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls param.Opt[int64] `json:"maxScrolls,omitzero"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorNewParamsTargetPageActionScrollAmountUnion `json:"amount,omitzero"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction,omitzero"`
	// Use `scroll` to move through the page or a container.
	//
	// This field can be elided, and will marshal its zero value as "scroll".
	Do constant.Scroll `json:"do" default:"scroll"`
	paramObj
}

func (r MonitorNewParamsTargetPageActionScroll) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetPageActionScroll
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func init() {
	apijson.RegisterFieldValidator[MonitorNewParamsTargetPageActionScroll](
		"direction", "up", "down", "left", "right",
	)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorNewParamsTargetPageActionScrollAmountUnion struct {
	OfInt param.Opt[int64] `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfMonitorNewsTargetPageActionScrollAmountString)
	OfMonitorNewsTargetPageActionScrollAmountString param.Opt[string] `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorNewParamsTargetPageActionScrollAmountUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfInt, u.OfMonitorNewsTargetPageActionScrollAmountString)
}
func (u *MonitorNewParamsTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

type MonitorNewParamsTargetPageActionScrollAmountString string

const (
	MonitorNewParamsTargetPageActionScrollAmountStringViewport MonitorNewParamsTargetPageActionScrollAmountString = "viewport"
	MonitorNewParamsTargetPageActionScrollAmountStringMax      MonitorNewParamsTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
//
// The properties Type, URL are required.
type MonitorNewParamsTargetSitemap struct {
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs param.Opt[int64] `json:"max_urls,omitzero"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude,omitzero"`
	// URL path patterns to include (max 50).
	Include []string `json:"include,omitzero"`
	// Use `sitemap` to watch a site for added or removed URLs.
	//
	// This field can be elided, and will marshal its zero value as "sitemap".
	Type constant.Sitemap `json:"type" default:"sitemap"`
	paramObj
}

func (r MonitorNewParamsTargetSitemap) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetSitemap
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
//
// The properties Instructions, Type, URL are required.
type MonitorNewParamsTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains param.Opt[bool] `json:"follow_subdomains,omitzero"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth param.Opt[int64] `json:"max_depth,omitzero"`
	// Maximum number of pages to track.
	MaxPages param.Opt[int64] `json:"max_pages,omitzero"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema,omitzero"`
	// Use `extract` to watch structured data across selected pages.
	//
	// This field can be elided, and will marshal its zero value as "extract".
	Type constant.Extract `json:"type" default:"extract"`
	paramObj
}

func (r MonitorNewParamsTargetExtract) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsTargetExtract
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorNewParamsChangeDetectionUnion struct {
	OfExact    *MonitorNewParamsChangeDetectionExact    `json:",omitzero,inline"`
	OfSemantic *MonitorNewParamsChangeDetectionSemantic `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorNewParamsChangeDetectionUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfExact, u.OfSemantic)
}
func (u *MonitorNewParamsChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorNewParamsChangeDetectionUnion](
		"type",
		apijson.Discriminator[MonitorNewParamsChangeDetectionExact]("exact"),
		apijson.Discriminator[MonitorNewParamsChangeDetectionSemantic]("semantic"),
	)
}

func NewMonitorNewParamsChangeDetectionExact() MonitorNewParamsChangeDetectionExact {
	return MonitorNewParamsChangeDetectionExact{
		Type: "exact",
	}
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
//
// This struct has a constant value, construct it with
// [NewMonitorNewParamsChangeDetectionExact].
type MonitorNewParamsChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	paramObj
}

func (r MonitorNewParamsChangeDetectionExact) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsChangeDetectionExact
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
//
// The property Type is required.
type MonitorNewParamsChangeDetectionSemantic struct {
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold param.Opt[float64] `json:"confidence_threshold,omitzero"`
	// Use `semantic` to judge changes against the target instructions.
	//
	// This field can be elided, and will marshal its zero value as "semantic".
	Type constant.Semantic `json:"type" default:"semantic"`
	paramObj
}

func (r MonitorNewParamsChangeDetectionSemantic) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsChangeDetectionSemantic
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Always `web`. Optional.
type MonitorNewParamsMode string

const (
	MonitorNewParamsModeWeb MonitorNewParamsMode = "web"
)

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
//
// The properties Frequency, Type, Unit are required.
type MonitorNewParamsSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type,omitzero" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit,omitzero" api:"required"`
	paramObj
}

func (r MonitorNewParamsSchedule) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsSchedule
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func init() {
	apijson.RegisterFieldValidator[MonitorNewParamsSchedule](
		"type", "interval",
	)
	apijson.RegisterFieldValidator[MonitorNewParamsSchedule](
		"unit", "minutes", "hours", "days",
	)
}

// Webhook destination and delivery settings. Null means no webhook is configured.
//
// The property URL is required.
type MonitorNewParamsWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events,omitzero"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfigParam `json:"retry,omitzero"`
	paramObj
}

func (r MonitorNewParamsWebhook) MarshalJSON() (data []byte, err error) {
	type shadow MonitorNewParamsWebhook
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorNewParamsWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorUpdateParams struct {
	// Display name for the monitor.
	Name param.Opt[string] `json:"name,omitzero"`
	// Set to null to remove the webhook. Changing `url` issues a new secret.
	Webhook MonitorUpdateParamsWebhook `json:"webhook,omitzero"`
	// How changes are judged. Defaults to `semantic` for extract targets and page
	// targets with `instructions`, otherwise `exact`.
	ChangeDetection MonitorUpdateParamsChangeDetectionUnion `json:"change_detection,omitzero"`
	// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
	// every 6 hours or every 2 days. The total interval (frequency × unit) must be
	// between 10 minutes and 1 year.
	Schedule MonitorUpdateParamsSchedule `json:"schedule,omitzero"`
	// Set `paused` to stop scheduled runs or `active` to resume them.
	//
	// Any of "active", "paused".
	Status MonitorUpdateParamsStatus `json:"status,omitzero"`
	// Labels for filtering monitors, their changes, and their usage.
	Tags []string `json:"tags,omitzero"`
	// What to watch: a page, a sitemap, or data extracted from a site.
	Target MonitorUpdateParamsTargetUnion `json:"target,omitzero"`
	paramObj
}

func (r MonitorUpdateParams) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorUpdateParamsChangeDetectionUnion struct {
	OfExact    *MonitorUpdateParamsChangeDetectionExact    `json:",omitzero,inline"`
	OfSemantic *MonitorUpdateParamsChangeDetectionSemantic `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorUpdateParamsChangeDetectionUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfExact, u.OfSemantic)
}
func (u *MonitorUpdateParamsChangeDetectionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorUpdateParamsChangeDetectionUnion](
		"type",
		apijson.Discriminator[MonitorUpdateParamsChangeDetectionExact]("exact"),
		apijson.Discriminator[MonitorUpdateParamsChangeDetectionSemantic]("semantic"),
	)
}

func NewMonitorUpdateParamsChangeDetectionExact() MonitorUpdateParamsChangeDetectionExact {
	return MonitorUpdateParamsChangeDetectionExact{
		Type: "exact",
	}
}

// Detect exact changes. For page targets, this means visible text diffs. For
// sitemap targets, this means URL additions and removals.
//
// This struct has a constant value, construct it with
// [NewMonitorUpdateParamsChangeDetectionExact].
type MonitorUpdateParamsChangeDetectionExact struct {
	// Use `exact` to compare visible text or sitemap URLs.
	Type constant.Exact `json:"type" default:"exact"`
	paramObj
}

func (r MonitorUpdateParamsChangeDetectionExact) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsChangeDetectionExact
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsChangeDetectionExact) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Detect meaningful content changes using the target’s instructions and optional
// schema.
//
// The property Type is required.
type MonitorUpdateParamsChangeDetectionSemantic struct {
	// Minimum confidence required to report a meaningful change, from 0 to 1.
	ConfidenceThreshold param.Opt[float64] `json:"confidence_threshold,omitzero"`
	// Use `semantic` to judge changes against the target instructions.
	//
	// This field can be elided, and will marshal its zero value as "semantic".
	Type constant.Semantic `json:"type" default:"semantic"`
	paramObj
}

func (r MonitorUpdateParamsChangeDetectionSemantic) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsChangeDetectionSemantic
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsChangeDetectionSemantic) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
// every 6 hours or every 2 days. The total interval (frequency × unit) must be
// between 10 minutes and 1 year.
//
// The properties Frequency, Type, Unit are required.
type MonitorUpdateParamsSchedule struct {
	// Number of units between runs. The resulting interval (frequency × unit) must be
	// at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes;
	// maximum 365 when unit is days).
	Frequency int64 `json:"frequency" api:"required"`
	// Use `interval` to run on a repeating schedule.
	//
	// Any of "interval".
	Type string `json:"type,omitzero" api:"required"`
	// Time unit used with `frequency` to set the run interval.
	//
	// Any of "minutes", "hours", "days".
	Unit string `json:"unit,omitzero" api:"required"`
	paramObj
}

func (r MonitorUpdateParamsSchedule) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsSchedule
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsSchedule) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func init() {
	apijson.RegisterFieldValidator[MonitorUpdateParamsSchedule](
		"type", "interval",
	)
	apijson.RegisterFieldValidator[MonitorUpdateParamsSchedule](
		"unit", "minutes", "hours", "days",
	)
}

// Set `paused` to stop scheduled runs or `active` to resume them.
type MonitorUpdateParamsStatus string

const (
	MonitorUpdateParamsStatusActive MonitorUpdateParamsStatus = "active"
	MonitorUpdateParamsStatusPaused MonitorUpdateParamsStatus = "paused"
)

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorUpdateParamsTargetUnion struct {
	OfPage    *MonitorUpdateParamsTargetPage    `json:",omitzero,inline"`
	OfSitemap *MonitorUpdateParamsTargetSitemap `json:",omitzero,inline"`
	OfExtract *MonitorUpdateParamsTargetExtract `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorUpdateParamsTargetUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfPage, u.OfSitemap, u.OfExtract)
}
func (u *MonitorUpdateParamsTargetUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorUpdateParamsTargetUnion](
		"type",
		apijson.Discriminator[MonitorUpdateParamsTargetPage]("page"),
		apijson.Discriminator[MonitorUpdateParamsTargetSitemap]("sitemap"),
		apijson.Discriminator[MonitorUpdateParamsTargetExtract]("extract"),
	)
}

// Watch a single web page. Exact detection reports visible-text diffs; semantic
// detection judges confirmed stable diffs against `instructions`.
//
// The properties Type, URL are required.
type MonitorUpdateParamsTargetPage struct {
	// Public HTTP(S) page URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Plain-language goal describing which page changes matter. When provided without
	// change_detection, semantic detection is inferred.
	Instructions param.Opt[string] `json:"instructions,omitzero"`
	// Normalize whitespace before comparing or analyzing text.
	NormalizeWhitespace param.Opt[bool] `json:"normalize_whitespace,omitzero"`
	// Optional browser actions executed in array order after the page loads, before
	// content is captured, on every run. Requires a paid plan. Maximum: 5 actions.
	// Changes create a new baseline.
	Actions []MonitorUpdateParamsTargetPageActionUnion `json:"actions,omitzero"`
	// Remove matching regions after inclusions. Changes create a new baseline.
	ExcludeSelectors []string `json:"exclude_selectors,omitzero"`
	// Monitor these CSS-selected regions. Empty or omitted uses main content. Changes
	// create a new baseline.
	IncludeSelectors []string `json:"include_selectors,omitzero"`
	// Use `page` to watch one web page.
	//
	// This field can be elided, and will marshal its zero value as "page".
	Type constant.Page `json:"type" default:"page"`
	paramObj
}

func (r MonitorUpdateParamsTargetPage) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetPage
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetPage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorUpdateParamsTargetPageActionUnion struct {
	OfWait    *MonitorUpdateParamsTargetPageActionWait    `json:",omitzero,inline"`
	OfPerform *MonitorUpdateParamsTargetPageActionPerform `json:",omitzero,inline"`
	OfScroll  *MonitorUpdateParamsTargetPageActionScroll  `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorUpdateParamsTargetPageActionUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfWait, u.OfPerform, u.OfScroll)
}
func (u *MonitorUpdateParamsTargetPageActionUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func init() {
	apijson.RegisterUnion[MonitorUpdateParamsTargetPageActionUnion](
		"do",
		apijson.Discriminator[MonitorUpdateParamsTargetPageActionWait]("wait"),
		apijson.Discriminator[MonitorUpdateParamsTargetPageActionPerform]("perform"),
		apijson.Discriminator[MonitorUpdateParamsTargetPageActionScroll]("scroll"),
	)
}

// Pause for a fixed number of milliseconds before continuing to the next action.
//
// The properties Do, TimeMs are required.
type MonitorUpdateParamsTargetPageActionWait struct {
	// Time to pause in milliseconds before the next action.
	TimeMs int64 `json:"timeMs" api:"required"`
	// Use `wait` to pause for a fixed duration.
	//
	// This field can be elided, and will marshal its zero value as "wait".
	Do constant.Wait `json:"do" default:"wait"`
	paramObj
}

func (r MonitorUpdateParamsTargetPageActionWait) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetPageActionWait
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetPageActionWait) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Resolve and perform one natural-language browser action.
//
// The properties Action, Do are required.
type MonitorUpdateParamsTargetPageActionPerform struct {
	// One browser instruction, such as clicking a button or entering text.
	Action string `json:"action" api:"required"`
	// Use `perform` for a plain-language browser instruction.
	//
	// This field can be elided, and will marshal its zero value as "perform".
	Do constant.Perform `json:"do" default:"perform"`
	paramObj
}

func (r MonitorUpdateParamsTargetPageActionPerform) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetPageActionPerform
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetPageActionPerform) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Scroll the page or a selected scrollable container, waiting adaptively for
// content and dimensions to settle after each iteration.
//
// The property Do is required.
type MonitorUpdateParamsTargetPageActionScroll struct {
	// CSS selector for the first matching scroll container. Defaults to the page.
	Container param.Opt[string] `json:"container,omitzero"`
	// Maximum scroll iterations. Stops early when scrolling and scrollable extent stop
	// changing. Defaults to 1.
	MaxScrolls param.Opt[int64] `json:"maxScrolls,omitzero"`
	// Pixels per scroll, one visible viewport, or the current scroll boundary.
	// Defaults to viewport.
	Amount MonitorUpdateParamsTargetPageActionScrollAmountUnion `json:"amount,omitzero"`
	// Direction to scroll. Defaults to down.
	//
	// Any of "up", "down", "left", "right".
	Direction string `json:"direction,omitzero"`
	// Use `scroll` to move through the page or a container.
	//
	// This field can be elided, and will marshal its zero value as "scroll".
	Do constant.Scroll `json:"do" default:"scroll"`
	paramObj
}

func (r MonitorUpdateParamsTargetPageActionScroll) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetPageActionScroll
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetPageActionScroll) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func init() {
	apijson.RegisterFieldValidator[MonitorUpdateParamsTargetPageActionScroll](
		"direction", "up", "down", "left", "right",
	)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type MonitorUpdateParamsTargetPageActionScrollAmountUnion struct {
	OfInt param.Opt[int64] `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfMonitorUpdatesTargetPageActionScrollAmountString)
	OfMonitorUpdatesTargetPageActionScrollAmountString param.Opt[string] `json:",omitzero,inline"`
	paramUnion
}

func (u MonitorUpdateParamsTargetPageActionScrollAmountUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfInt, u.OfMonitorUpdatesTargetPageActionScrollAmountString)
}
func (u *MonitorUpdateParamsTargetPageActionScrollAmountUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

type MonitorUpdateParamsTargetPageActionScrollAmountString string

const (
	MonitorUpdateParamsTargetPageActionScrollAmountStringViewport MonitorUpdateParamsTargetPageActionScrollAmountString = "viewport"
	MonitorUpdateParamsTargetPageActionScrollAmountStringMax      MonitorUpdateParamsTargetPageActionScrollAmountString = "max"
)

// Watch a site’s URL inventory for confirmed additions and removals.
//
// The properties Type, URL are required.
type MonitorUpdateParamsTargetSitemap struct {
	// Sitemap URL to monitor.
	URL string `json:"url" api:"required" format:"uri"`
	// Maximum number of sitemap URLs to track (capped at 10,000).
	MaxURLs param.Opt[int64] `json:"max_urls,omitzero"`
	// URL path patterns to exclude (max 50).
	Exclude []string `json:"exclude,omitzero"`
	// URL path patterns to include (max 50).
	Include []string `json:"include,omitzero"`
	// Use `sitemap` to watch a site for added or removed URLs.
	//
	// This field can be elided, and will marshal its zero value as "sitemap".
	Type constant.Sitemap `json:"type" default:"sitemap"`
	paramObj
}

func (r MonitorUpdateParamsTargetSitemap) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetSitemap
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetSitemap) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Track relevant pages selected by `schema` and `instructions`; refresh the page
// set periodically.
//
// The properties Instructions, Type, URL are required.
type MonitorUpdateParamsTargetExtract struct {
	// Natural-language instructions guiding which pages and facts to track and which
	// changes to report.
	Instructions string `json:"instructions" api:"required"`
	// Root URL to extract structured data from.
	URL string `json:"url" api:"required" format:"uri"`
	// Allow page discovery on subdomains of the target site.
	FollowSubdomains param.Opt[bool] `json:"follow_subdomains,omitzero"`
	// Optional maximum link depth from the starting URL (0 = only the starting page).
	MaxDepth param.Opt[int64] `json:"max_depth,omitzero"`
	// Maximum number of pages to track.
	MaxPages param.Opt[int64] `json:"max_pages,omitzero"`
	// JSON Schema for page selection and the baseline snapshot. Changes return diffs
	// and evidence.
	Schema map[string]any `json:"schema,omitzero"`
	// Use `extract` to watch structured data across selected pages.
	//
	// This field can be elided, and will marshal its zero value as "extract".
	Type constant.Extract `json:"type" default:"extract"`
	paramObj
}

func (r MonitorUpdateParamsTargetExtract) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsTargetExtract
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsTargetExtract) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Set to null to remove the webhook. Changing `url` issues a new secret.
//
// The property URL is required.
type MonitorUpdateParamsWebhook struct {
	// Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted
	// messages.
	URL string `json:"url" api:"required" format:"uri"`
	// Events to deliver. Defaults to `change.detected`; `run.completed` also includes
	// unchanged runs.
	//
	// Any of "change.detected", "run.completed".
	Events []string `json:"events,omitzero"`
	// Webhook retry settings. Use {} for the default schedule.
	Retry RetryConfigParam `json:"retry,omitzero"`
	paramObj
}

func (r MonitorUpdateParamsWebhook) MarshalJSON() (data []byte, err error) {
	type shadow MonitorUpdateParamsWebhook
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *MonitorUpdateParamsWebhook) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type MonitorListParams struct {
	// Opaque pagination cursor from a previous response.
	Cursor param.Opt[string] `query:"cursor,omitzero" json:"-"`
	// Maximum number of items to return per page (1-100). Defaults to 25.
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Free-text search term, matched against the fields named in `search_by`.
	Q param.Opt[string] `query:"q,omitzero" json:"-"`
	// Filter to items that have this tag.
	Tag param.Opt[string] `query:"tag,omitzero" json:"-"`
	// Fields to search with `q`. Defaults to all fields; page and extract targets can
	// have instructions.
	//
	// Any of "name", "url", "instructions", "tags".
	SearchBy []string `query:"search_by,omitzero" json:"-"`
	// Comma-separated list of tags to filter by (matches monitors having any of them).
	Tags []string `query:"tags,omitzero" json:"-"`
	// Filter by change detection type.
	//
	// Any of "exact", "semantic".
	ChangeDetectionType MonitorListParamsChangeDetectionType `query:"change_detection_type,omitzero" json:"-"`
	// `prefix` for as-you-type prefix matching (default), `exact` for full-token
	// matching.
	//
	// Any of "exact", "prefix".
	SearchType MonitorListParamsSearchType `query:"search_type,omitzero" json:"-"`
	// Filter monitors by lifecycle status.
	//
	// Any of "active", "paused", "failed".
	Status MonitorListParamsStatus `query:"status,omitzero" json:"-"`
	// Filter by target type.
	//
	// Any of "page", "sitemap", "extract".
	TargetType MonitorListParamsTargetType `query:"target_type,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorListParams]'s query parameters as `url.Values`.
func (r MonitorListParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

// Filter by change detection type.
type MonitorListParamsChangeDetectionType string

const (
	MonitorListParamsChangeDetectionTypeExact    MonitorListParamsChangeDetectionType = "exact"
	MonitorListParamsChangeDetectionTypeSemantic MonitorListParamsChangeDetectionType = "semantic"
)

// `prefix` for as-you-type prefix matching (default), `exact` for full-token
// matching.
type MonitorListParamsSearchType string

const (
	MonitorListParamsSearchTypeExact  MonitorListParamsSearchType = "exact"
	MonitorListParamsSearchTypePrefix MonitorListParamsSearchType = "prefix"
)

// Filter monitors by lifecycle status.
type MonitorListParamsStatus string

const (
	MonitorListParamsStatusActive MonitorListParamsStatus = "active"
	MonitorListParamsStatusPaused MonitorListParamsStatus = "paused"
	MonitorListParamsStatusFailed MonitorListParamsStatus = "failed"
)

// Filter by target type.
type MonitorListParamsTargetType string

const (
	MonitorListParamsTargetTypePage    MonitorListParamsTargetType = "page"
	MonitorListParamsTargetTypeSitemap MonitorListParamsTargetType = "sitemap"
	MonitorListParamsTargetTypeExtract MonitorListParamsTargetType = "extract"
)

type MonitorGetCreditUsageParams struct {
	// Only include items at or after this ISO 8601 timestamp.
	Since param.Opt[time.Time] `query:"since,omitzero" format:"date-time" json:"-"`
	// Only include items before this ISO 8601 timestamp.
	Until param.Opt[time.Time] `query:"until,omitzero" format:"date-time" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorGetCreditUsageParams]'s query parameters as
// `url.Values`.
func (r MonitorGetCreditUsageParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type MonitorListAccountChangesParams struct {
	// Opaque pagination cursor from a previous response.
	Cursor param.Opt[string] `query:"cursor,omitzero" json:"-"`
	// Maximum number of items to return per page (1-100). Defaults to 25.
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Filter changes to a single monitor.
	MonitorID param.Opt[string] `query:"monitor_id,omitzero" json:"-"`
	// Only include items at or after this ISO 8601 timestamp.
	Since param.Opt[time.Time] `query:"since,omitzero" format:"date-time" json:"-"`
	// Filter to items that have this tag.
	Tag param.Opt[string] `query:"tag,omitzero" json:"-"`
	// Only include items before this ISO 8601 timestamp.
	Until param.Opt[time.Time] `query:"until,omitzero" format:"date-time" json:"-"`
	// Filter by change detection type.
	//
	// Any of "exact", "semantic".
	ChangeDetectionType MonitorListAccountChangesParamsChangeDetectionType `query:"change_detection_type,omitzero" json:"-"`
	// Filter by target type.
	//
	// Any of "page", "sitemap", "extract".
	TargetType MonitorListAccountChangesParamsTargetType `query:"target_type,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorListAccountChangesParams]'s query parameters as
// `url.Values`.
func (r MonitorListAccountChangesParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

// Filter by change detection type.
type MonitorListAccountChangesParamsChangeDetectionType string

const (
	MonitorListAccountChangesParamsChangeDetectionTypeExact    MonitorListAccountChangesParamsChangeDetectionType = "exact"
	MonitorListAccountChangesParamsChangeDetectionTypeSemantic MonitorListAccountChangesParamsChangeDetectionType = "semantic"
)

// Filter by target type.
type MonitorListAccountChangesParamsTargetType string

const (
	MonitorListAccountChangesParamsTargetTypePage    MonitorListAccountChangesParamsTargetType = "page"
	MonitorListAccountChangesParamsTargetTypeSitemap MonitorListAccountChangesParamsTargetType = "sitemap"
	MonitorListAccountChangesParamsTargetTypeExtract MonitorListAccountChangesParamsTargetType = "extract"
)

type MonitorListAccountRunsParams struct {
	// Opaque pagination cursor from a previous response.
	Cursor param.Opt[string] `query:"cursor,omitzero" json:"-"`
	// Maximum number of items to return per page (1-100). Defaults to 25.
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Filter runs by lifecycle status.
	//
	// Any of "queued", "running", "completed", "failed", "skipped".
	Status MonitorListAccountRunsParamsStatus `query:"status,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorListAccountRunsParams]'s query parameters as
// `url.Values`.
func (r MonitorListAccountRunsParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

// Filter runs by lifecycle status.
type MonitorListAccountRunsParamsStatus string

const (
	MonitorListAccountRunsParamsStatusQueued    MonitorListAccountRunsParamsStatus = "queued"
	MonitorListAccountRunsParamsStatusRunning   MonitorListAccountRunsParamsStatus = "running"
	MonitorListAccountRunsParamsStatusCompleted MonitorListAccountRunsParamsStatus = "completed"
	MonitorListAccountRunsParamsStatusFailed    MonitorListAccountRunsParamsStatus = "failed"
	MonitorListAccountRunsParamsStatusSkipped   MonitorListAccountRunsParamsStatus = "skipped"
)

type MonitorListChangesParams struct {
	// Opaque pagination cursor from a previous response.
	Cursor param.Opt[string] `query:"cursor,omitzero" json:"-"`
	// Maximum number of items to return per page (1-100). Defaults to 25.
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Only include items at or after this ISO 8601 timestamp.
	Since param.Opt[time.Time] `query:"since,omitzero" format:"date-time" json:"-"`
	// Filter to items that have this tag.
	Tag param.Opt[string] `query:"tag,omitzero" json:"-"`
	// Only include items before this ISO 8601 timestamp.
	Until param.Opt[time.Time] `query:"until,omitzero" format:"date-time" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorListChangesParams]'s query parameters as
// `url.Values`.
func (r MonitorListChangesParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type MonitorListRunsParams struct {
	// Opaque pagination cursor from a previous response.
	Cursor param.Opt[string] `query:"cursor,omitzero" json:"-"`
	// Maximum number of items to return per page (1-100). Defaults to 25.
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Filter runs by lifecycle status.
	//
	// Any of "queued", "running", "completed", "failed", "skipped".
	Status MonitorListRunsParamsStatus `query:"status,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [MonitorListRunsParams]'s query parameters as `url.Values`.
func (r MonitorListRunsParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatComma,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

// Filter runs by lifecycle status.
type MonitorListRunsParamsStatus string

const (
	MonitorListRunsParamsStatusQueued    MonitorListRunsParamsStatus = "queued"
	MonitorListRunsParamsStatusRunning   MonitorListRunsParamsStatus = "running"
	MonitorListRunsParamsStatusCompleted MonitorListRunsParamsStatus = "completed"
	MonitorListRunsParamsStatusFailed    MonitorListRunsParamsStatus = "failed"
	MonitorListRunsParamsStatusSkipped   MonitorListRunsParamsStatus = "skipped"
)

type MonitorGetRunParams struct {
	// ID of the monitor.
	MonitorID string `path:"monitor_id" api:"required" json:"-"`
	paramObj
}