extensions

type BackoffStrategy struct {
	InitialInterval *int     `json:"initialInterval" yaml:"initialInterval,omitempty"`
	MaxInterval     *int     `json:"maxInterval" yaml:"maxInterval,omitempty"`
	Exponent        *float32 `json:"exponent" yaml:"exponent,omitempty"`
	MaxElapsedTime  *int     `json:"maxElapsedTime" yaml:"maxElapsedTime,omitempty"`
}

type CLICommand struct {
	ID           string                  `json:"id" yaml:"id"`
	Path         []string                `json:"path" yaml:"path"`
	Category     string                  `json:"category" yaml:"category"`
	Summary      string                  `json:"summary" yaml:"summary"`
	Tagline      string                  `json:"tagline" yaml:"tagline"`
	Description  string                  `json:"description" yaml:"description"`
	Source       CLICommandSource        `json:"source" yaml:"source"`
	Args         []CLICommandInput       `json:"args" yaml:"args"`
	Flags        []CLICommandInput       `json:"flags" yaml:"flags"`
	Presets      []CLICommandPreset      `json:"presets" yaml:"presets"`
	Async        *CLICommandAsync        `json:"async,omitempty" yaml:"async,omitempty"`
	Output       *CLICommandOutput       `json:"output" yaml:"output"`
	Examples     []CLICommandExample     `json:"examples" yaml:"examples"`
	Help         *CLICommandHelp         `json:"help,omitempty" yaml:"help,omitempty"`
	Override     bool                    `json:"override,omitempty" yaml:"override,omitempty"`
	DispatchKeys []CLICommandDispatchKey `json:"dispatchKeys,omitempty" yaml:"dispatchKeys,omitempty"`
	// Hints maps an error reason to agent-mode hint lines that are merged
	// into the reason-first error envelope. CLI_* reasons are the closed
	// namespace the generated runtime itself produces; external (server)
	// reasons pass through verbatim.
	Hints map[string][]string `json:"hints,omitempty" yaml:"hints,omitempty"`
}

type CLICommandArtifact struct {
	ContentPointer string                      `json:"contentPointer" yaml:"contentPointer"`
	Segments       []CLICommandArtifactSegment `json:"segments" yaml:"segments"`
	Kind           string                      `json:"kind" yaml:"kind"` // image | audio | video
	DefaultPath    string                      `json:"defaultPath" yaml:"defaultPath"`
	// Content-block field bindings (block:). Defaults are the v1 shape.
	TypeField     string `json:"typeField" yaml:"typeField"`         // default "type"
	DataField     string `json:"dataField" yaml:"dataField"`         // default "data"
	MimeTypeField string `json:"mimeTypeField" yaml:"mimeTypeField"` // default "mime_type"
	URIField      string `json:"uriField" yaml:"uriField"`           // default "uri"
	// Response-root identity bindings (identity:). Defaults are the v1 shape.
	IDField        string `json:"idField" yaml:"idField"`               // default "id"
	StatusField    string `json:"statusField" yaml:"statusField"`       // default "status"
	TerminalStatus string `json:"terminalStatus" yaml:"terminalStatus"` // default "completed"
	// ResponseCode is the 2xx status code whose application/json schema the
	// content pointer was validated against (set during linking).
	ResponseCode string `json:"responseCode" yaml:"responseCode"`
	// contains filtered or unexported fields
}

type CLICommandArtifactSegment struct {
	Field string `json:"field,omitempty" yaml:"field,omitempty"`
	Wild  bool   `json:"wild,omitempty" yaml:"wild,omitempty"`
}

type CLICommandAsync struct {
	OperationID        string                             `json:"operationId" yaml:"operationId"`
	ID                 CLICommandAsyncID                  `json:"id" yaml:"id"`
	Params             map[string]any                     `json:"params,omitempty" yaml:"params,omitempty"`
	ResolvedParams     []CLICommandAsyncResolvedParameter `json:"resolvedParams,omitempty" yaml:"resolvedParams,omitempty"`
	StateFrom          string                             `json:"stateFrom" yaml:"stateFrom"`
	StatePointer       string                             `json:"statePointer" yaml:"statePointer"`
	StateSegments      []CLICommandAsyncPathSegment       `json:"stateSegments" yaml:"stateSegments"`
	States             map[string]string                  `json:"states" yaml:"states"`
	Interval           string                             `json:"interval" yaml:"interval"`
	Backoff            float64                            `json:"backoff" yaml:"backoff"`
	MaxInterval        string                             `json:"maxInterval" yaml:"maxInterval"`
	Timeout            string                             `json:"timeout" yaml:"timeout"`
	ErrorField         string                             `json:"errorField" yaml:"errorField"`               // default "error"
	ErrorMessageField  string                             `json:"errorMessageField" yaml:"errorMessageField"` // default "message"
	CreateResponseCode string                             `json:"createResponseCode" yaml:"createResponseCode"`
	ResponseCode       string                             `json:"responseCode" yaml:"responseCode"`
	// contains filtered or unexported fields
}

type CLICommandAsyncID struct {
	From     string                       `json:"from" yaml:"from"`
	Pointer  string                       `json:"pointer" yaml:"pointer"`
	Segments []CLICommandAsyncPathSegment `json:"segments" yaml:"segments"`
	To       CLICommandAsyncParameter     `json:"to" yaml:"to"`
}

type CLICommandAsyncParameter struct {
	In   string `json:"in" yaml:"in"` // path | query
	Name string `json:"name" yaml:"name"`
}

type CLICommandAsyncPathSegment struct {
	Field   string `json:"field,omitempty" yaml:"field,omitempty"`
	Index   int    `json:"index,omitempty" yaml:"index,omitempty"`
	IsIndex bool   `json:"isIndex,omitempty" yaml:"isIndex,omitempty"`
}

type CLICommandAsyncResolvedParameter struct {
	In    string `json:"in" yaml:"in"` // query | header
	Name  string `json:"name" yaml:"name"`
	Value any    `json:"value" yaml:"value"`
}

type CLICommandBind struct {
	In      string `json:"in" yaml:"in"`           // "body" (v1)
	Pointer string `json:"pointer" yaml:"pointer"` // e.g. "/input"
	Mode    string `json:"mode" yaml:"mode"`       // "set" (v1)
}

type CLICommandDispatchKey struct {
	Pointer          string   `json:"pointer" yaml:"pointer"`
	RouteIDs         []string `json:"routeIds,omitempty" yaml:"routeIds,omitempty"`
	UnroutedVariants []string `json:"unroutedVariants,omitempty" yaml:"unroutedVariants,omitempty"`
}

type CLICommandExample struct {
	Summary string `json:"summary" yaml:"summary"`
	Command string `json:"command" yaml:"command"`
}

type CLICommandHelp struct {
	Defaults string `json:"defaults,omitempty" yaml:"defaults,omitempty"`
	Learn    string `json:"learn,omitempty" yaml:"learn,omitempty"`
	Escalate string `json:"escalate,omitempty" yaml:"escalate,omitempty"`
}

type CLICommandInput struct {
	ID          string          `json:"id" yaml:"id"`
	Name        string          `json:"name" yaml:"name"`
	Summary     string          `json:"summary" yaml:"summary"`
	Type        string          `json:"type" yaml:"type"` // string | int | float | bool
	Required    bool            `json:"required" yaml:"required"`
	Variadic    bool            `json:"variadic" yaml:"variadic"`
	Shorthand   string          `json:"shorthand" yaml:"shorthand"`
	Default     any             `json:"default" yaml:"default"`
	DefaultFrom string          `json:"defaultFrom" yaml:"defaultFrom"` // "schema"
	Bind        *CLICommandBind `json:"bind" yaml:"bind"`
	// Enum carries schema enum values as agent/user suggestions only. They are
	// never enforced locally: upstream registries evolve faster than specs, so
	// enum drift must not brick otherwise-valid invocations.
	Enum []any `json:"enum,omitempty" yaml:"enum,omitempty"`
	// RouteIDs lists the dispatch routes whose request variant declares this
	// input's bound property. RequiredRouteIDs is the subset on which the
	// property remains required after schema defaults and effective presets.
	// Both are nil for ordinary single-route commands.
	RouteIDs         []string `json:"routeIds,omitempty" yaml:"routeIds,omitempty"`
	RequiredRouteIDs []string `json:"requiredRouteIds,omitempty" yaml:"requiredRouteIds,omitempty"`
	// contains filtered or unexported fields
}

type CLICommandManifest struct {
	Version    int            `json:"version" yaml:"version"`
	Categories []string       `json:"categories,omitempty" yaml:"categories,omitempty"`
	Commands   []CLICommand   `json:"commands" yaml:"commands"`
	Operations []CLIOperation `json:"operations,omitempty" yaml:"operations,omitempty"`
}

type CLICommandOutput struct {
	Projection *CLICommandProjection       `json:"projection" yaml:"projection"`
	Artifact   *CLICommandArtifact         `json:"artifact,omitempty" yaml:"artifact,omitempty"`
	Stream     *CLICommandStreamProjection `json:"stream,omitempty" yaml:"stream,omitempty"`
}

type CLICommandPreset struct {
	Bind  CLICommandBind `json:"bind" yaml:"bind"`
	Value any            `json:"value" yaml:"value"`
}

type CLICommandProjection struct {
	JQ     string `json:"jq" yaml:"jq"`
	Format string `json:"format" yaml:"format"`
}

type CLICommandRoute struct {
	ID             string `json:"id,omitempty" yaml:"id,omitempty"`
	Label          string `json:"label,omitempty" yaml:"label,omitempty"`
	Default        bool   `json:"default,omitempty" yaml:"default,omitempty"`
	OperationID    string `json:"operationId" yaml:"operationId"`
	RequestVariant string `json:"requestVariant" yaml:"requestVariant"`
	// Selector is the declared or inferred flag that identifies this route.
	Selector string `json:"selector,omitempty" yaml:"selector,omitempty"`
	// Presets contains route-local presets after decoding and the effective
	// command-then-route preset set after linking.
	Presets []CLICommandPreset `json:"presets,omitempty" yaml:"presets,omitempty"`

	// Selectors describes how the pinned request variant is told apart from
	// the other members of a union request body. The generated runtime uses
	// it when a caller supplies a partial body (--body/--body-param) to an
	// intent command: presets fill the gaps of a body that stays inside the
	// pinned variant, and a body that names another variant's selector is a
	// usage error instead of a silently re-targeted request. Nil when the
	// request body is not a union.
	Selectors *CLIVariantSelectors `json:"selectors,omitempty" yaml:"selectors,omitempty"`
}

type CLICommandSource struct {
	Type   string            `json:"type" yaml:"type"` // "operation" | "group" | "planned"
	Routes []CLICommandRoute `json:"routes" yaml:"routes"`
	Note   string            `json:"note" yaml:"note"` // planned: message explaining availability
}

type CLICommandStreamProjection struct {
	Select  string `json:"select" yaml:"select"`
	Pointer string `json:"pointer" yaml:"pointer"`
}

type CLIErrorManifest struct {
	Version int `json:"version" yaml:"version"`
	// ReasonPointer is the declared primary reason carrier: the restricted
	// JSONPath, relative to the response body's error object, whose string
	// values are the structured reason codes the top-level reason rules
	// match. Empty means the default carrier $.reason. Declaring the pointer
	// also opts the carrier into promoting an unmatched reason code verbatim
	// as error_reason.
	ReasonPointer  string                   `json:"reasonPointer,omitempty" yaml:"reasonPointer,omitempty"`
	ReasonSegments []CLIErrorPointerSegment `json:"-" yaml:"-"` // parsed ReasonPointer; generation-only
	Reasons        []CLIErrorRule           `json:"reasons,omitempty" yaml:"reasons,omitempty"`
	// Probes are additional reason carriers consulted after the primary
	// carrier, in declaration order. Each probe declares its pointer
	// explicitly, so each probe promotes an unmatched reason code verbatim.
	Probes []CLIErrorProbe     `json:"probes,omitempty" yaml:"probes,omitempty"`
	Types  []CLIErrorTypeHints `json:"types,omitempty" yaml:"types,omitempty"`
	// UnwrapErrorArray opts into normalizing the single-element
	// array-wrapped error body shape ([{"error": {...}}]) to its sole
	// element before classification. Default off.
	UnwrapErrorArray bool `json:"unwrapErrorArray,omitempty" yaml:"unwrapErrorArray,omitempty"`
}

type CLIErrorPointerSegment struct {
	Field  string `json:"field,omitempty" yaml:"field,omitempty"`
	IsWild bool   `json:"isWild,omitempty" yaml:"isWild,omitempty"`
}

type CLIErrorProbe struct {
	Pointer  string                   `json:"pointer" yaml:"pointer"`
	Segments []CLIErrorPointerSegment `json:"-" yaml:"-"` // parsed Pointer; generation-only
	Reasons  []CLIErrorRule           `json:"reasons,omitempty" yaml:"reasons,omitempty"`
}

type CLIErrorRule struct {
	Reason   string   `json:"reason" yaml:"reason"`
	Type     string   `json:"type,omitempty" yaml:"type,omitempty"`
	Hints    []string `json:"hints,omitempty" yaml:"hints,omitempty"`
	HasHints bool     `json:"-" yaml:"-"` // generation-only presence bit; not extension shape
	// contains filtered or unexported fields
}

type CLIErrorTypeHints struct {
	Type  string   `json:"type" yaml:"type"`
	Hints []string `json:"hints" yaml:"hints"`
}

type CLIOperation struct {
	OperationID  string            `json:"operationId" yaml:"operationId"`
	Output       *CLICommandOutput `json:"output,omitempty" yaml:"output,omitempty"`
	Flags        []CLICommandInput `json:"flags,omitempty" yaml:"flags,omitempty"`
	BodyRequired bool              `json:"bodyRequired,omitempty" yaml:"bodyRequired,omitempty"`
}

type CLIVariantSelectors struct {
	// Own lists distinguishing keys (required or defaulted in some members,
	// absent from at least one) that the pinned variant declares.
	Own []string `json:"own,omitempty" yaml:"own,omitempty"`
	// Foreign lists distinguishing keys the pinned variant does not declare:
	// their presence in a body selects a different variant.
	Foreign []string `json:"foreign,omitempty" yaml:"foreign,omitempty"`
	// DiscriminatorKey/DiscriminatorValue name the pinned variant's
	// discriminator when the union declares one; DiscriminatorValue is the
	// value filled into a body that omits it (explicit mapping entry, then
	// the pinned schema's const/single-enum property, then the implicit
	// mapping — the component name), DiscriminatorAliases every value that
	// selects the pinned variant (mapping aliases included).
	DiscriminatorKey     string `json:"discriminatorKey,omitempty" yaml:"discriminatorKey,omitempty"`
	DiscriminatorValue   any    `json:"discriminatorValue,omitempty" yaml:"discriminatorValue,omitempty"`
	DiscriminatorAliases []any  `json:"discriminatorAliases,omitempty" yaml:"discriminatorAliases,omitempty"`
}

type Comment struct {
	Summary     string `yaml:"summary" json:"summary"`
	Description string `yaml:"description" json:"description"`
}

type Comments map[string]*Comment

type CoreCustomSecurityConfig struct {
	marshaller.CoreModel `model:"customSecurityConfig"`

	UsesScopes marshaller.Node[*bool]           `key:"usesScopes"`
	Schema     marshaller.Node[core.JSONSchema] `key:"schema" required:"true"`
}

type CoreGlobals struct {
	marshaller.CoreModel `model:"globals"`

	Parameters marshaller.Node[[]marshaller.Node[*core.Reference[*core.Parameter]]] `key:"parameters"`
}

type CustomSecurityConfig struct {
	marshaller.Model[CoreCustomSecurityConfig]

	UsesScopes *bool
	Schema     *oas3.JSONSchema[oas3.Referenceable]
}

type Entity struct {
	// All entity names described by the x-speakeasy-entity extension configuration.
	Names []string `json:"names" yaml:"names"`
}

type EntityDescription struct {
	// Entity description for Terraform action.
	TerraformAction string `json:"terraform_action" yaml:"terraform_action"`

	// Entity description for Terraform data resource.
	TerraformDataResource string `json:"terraform_data_resource" yaml:"terraform_data_resource"`

	// Entity description for Terraform ephemeral resource.
	TerraformEphemeralResource string `json:"terraform_ephemeral_resource" yaml:"terraform_ephemeral_resource"`

	// Entity description for Terraform managed resource.
	TerraformManagedResource string `json:"terraform_managed_resource" yaml:"terraform_managed_resource"`
}

type EntityMissingCodes []int

type EntityOperationV1 struct {
	TerraformActions            []EntityOperationV1Config `json:"terraform_actions" yaml:"terraform_actions"`
	TerraformDataResources      []EntityOperationV1Config `json:"terraform_data_resources" yaml:"terraform_data_resources"`
	TerraformEphemeralResources []EntityOperationV1Config `json:"terraform_ephemeral_resources" yaml:"terraform_ephemeral_resources"`
	TerraformManagedResources   []EntityOperationV1Config `json:"terraform_managed_resources" yaml:"terraform_managed_resources"`
}

type EntityOperationV1Config struct {
	// Name of the entity for this operation.
	Entity string `json:"entity" yaml:"entity"`

	// Types of the entity operation.
	OperationTypes []string `json:"operation_types" yaml:"operation_types"`

	// Optional ordering of the operation compared to other definitions of the
	// same entity and operation type.
	Order *int `json:"order,omitempty" yaml:"order,omitempty"`

	// Optional SDK options for this entity operation.
	Options *EntityOperationV1Options `json:"options,omitempty" yaml:"options,omitempty"`
}

type EntityOperationV1Options struct {
	// Polling configuration for this entity operation.
	Polling *EntityOperationV1Polling `json:"polling,omitempty" yaml:"polling,omitempty"`

	// Patch configuration for update operations.
	Patch *EntityOperationV1Patch `json:"patch,omitempty" yaml:"patch,omitempty"`
}

type EntityOperationV1Patch struct {
	// Style of patch semantics to use for updates.
	// Valid values: "only-send-changed-attributes"
	Style string `json:"style" yaml:"style"`
}

type EntityOperationV1Polling struct {
	// Overrides the number of seconds before the first request.
	DelaySeconds *int `json:"delaySeconds,omitempty" yaml:"delaySeconds,omitempty"`

	// Overrides the number of seconds between requests.
	IntervalSeconds *int `json:"intervalSeconds,omitempty" yaml:"intervalSeconds,omitempty"`

	// Overrides the number of requests to limit polling.
	LimitCount *int `json:"limitCount,omitempty" yaml:"limitCount,omitempty"`

	// Name of the polling option to use.
	Name string `json:"name" yaml:"name"`
}

type EntityVersion struct {
	// Entity version for Terraform managed resource.
	TerraformManagedResource int64 `json:"terraform_managed_resource" yaml:"terraform_managed_resource"`
}

type Errors struct {
	StatusCodes []string `yaml:"statusCodes"`
	Override    bool     `yaml:"override"`
}

type Extension int

type ExtensionScope int

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

type Globals struct {
	marshaller.Model[CoreGlobals]
	Parameters []*openapi.ReferencedParameter
}

type GoOptionalMethodArguments string

type HandleRewriteExtensionOption func(*HandleRewriteExtensionOptions)

type HandleRewriteExtensionOptions struct {
	Extensions OAExtensions
	Node       *yaml.Node
}

type MCP struct {
	Disabled        bool     `json:"disabled" yaml:"disabled"`
	Name            string   `json:"name" yaml:"name"`
	Scopes          []string `json:"scopes" yaml:"scopes"`
	Description     string   `json:"description" yaml:"description"`
	Title           string   `json:"title" yaml:"title"`
	DestructiveHint bool     `json:"destructiveHint" yaml:"destructiveHint"`
	IdempotentHint  bool     `json:"idempotentHint" yaml:"idempotentHint"`
	OpenWorldHint   bool     `json:"openWorldHint" yaml:"openWorldHint"`
	ReadOnlyHint    bool     `json:"readOnlyHint" yaml:"readOnlyHint"`
}

type MatchConfig struct {
	// Path to match in the entity (e.g., "id", "object.id")
	// When specified as a scalar string, this field is populated.
	Path *string `json:"path,omitempty" yaml:"path,omitempty"`

	// Whether to use the prior state value for this parameter in update operations.
	UsePriorState bool `json:"usePriorState,omitempty" yaml:"usePriorState,omitempty"`
}

type NameOverride struct {
	OperationId                 string `json:"operationId" yaml:"operationId"`
	GlobalMethodNameOverride    string `json:"methodNameOverride" yaml:"methodNameOverride"`
	ParameterName               string `json:"parameterName" yaml:"parameterName"`
	GlobalParameterNameOverride string `json:"parameterNameOverride" yaml:"parameterNameOverride"`
	Name                        string
	Node                        *yaml.Node // The yaml node where this extension is defined (for error reporting)
}

type OAExtensions = *extensions.Extensions

type Pagination struct {
	Type    PaginationType     `json:"type" yaml:"type"`
	Inputs  []PaginationInputs `json:"inputs" yaml:"inputs"`
	Outputs PaginationOutputs  `json:"outputs" yaml:"outputs"`
}

type PaginationInputInType string

type PaginationInputType string

type PaginationInputs struct {
	Name     string                `json:"name" yaml:"name"`
	In       PaginationInputInType `json:"in" yaml:"in"`
	Type     PaginationInputType   `json:"type" yaml:"type"`
	Optional bool
}

type PaginationOutputs struct {
	// CanUseDotNotation indicates that the JSONPath expressions in this
	// pagination config are simple enough and it is possible to use a
	// lightweight and more performant object-drilling library instead of a
	// JSONPath library.
	CanUseDotNotation bool `json:"-" yaml:"-"`

	Results    string `json:"results" yaml:"results"`
	ResultsDot string `json:"-" yaml:"-"`

	NumPages    string `json:"numPages" yaml:"numPages"`
	NumPagesDot string `json:"-" yaml:"-"`

	NextCursor    string `json:"nextCursor" yaml:"nextCursor"`
	NextCursorDot string `json:"-" yaml:"-"`

	NextURL    string `json:"nextUrl" yaml:"nextUrl"`
	NextURLDot string `json:"-" yaml:"-"`
}

type PaginationType string

type Polling struct {
	// Collection of polling options.
	Options PollingOptions `json:"options" yaml:"options"`
}

type PollingCriteria []*PollingCriterion

type PollingCriterion struct {
	// Condition for the polling criterion. For simple type criterion, this is
	// typically a full expression such as `$statusCode == 200`. For regex type
	// criterion, this is the regular expression pattern.
	Condition *criterion.Condition `json:"condition,omitempty" yaml:"condition,omitempty"`

	// Context is the expression to the value to be evaluated. Required for
	// regex type criterion.
	Context *expression.Expression `json:"context,omitempty" yaml:"context,omitempty"`

	// Type is the type of criterion. Defaults to CriterionTypeSimple.
	Type criterion.CriterionType `json:"type,omitempty" yaml:"type,omitempty"`
}

type PollingOption struct {
	// Delay in seconds before polling calls begin. Defaults to 1.
	DelaySeconds *int64 `json:"delaySeconds,omitempty" yaml:"delaySeconds,omitempty"`

	// Descibes immediate failure criteria for the polling option. When all
	// matching criteria are met (AND boolean), the operation will immediately
	// return an error.
	FailureCriteria PollingCriteria `json:"failureCriteria,omitempty" yaml:"failureCriteria,omitempty"`

	// Interval between polling calls in seconds. Defaults to 1.
	IntervalSeconds *int64 `json:"intervalSeconds,omitempty" yaml:"intervalSeconds,omitempty"`

	// Name of the polling option.
	Name string `json:"name" yaml:"name"`

	// Number of polling calls not matching the FailureCriteria or
	// SuccessCriteria before returning a timeout error. Defaults to 60.
	LimitCount *int64 `json:"limitCount,omitempty" yaml:"limitCount,omitempty"`

	// Descibes success criteria for the polling option. When all matching
	// criteria are met (AND boolean), the operation will return successfully.
	SuccessCriteria PollingCriteria `json:"successCriteria,omitempty" yaml:"successCriteria,omitempty"`
}

type PollingOptions []*PollingOption

type PublicExport struct {
	Group string `json:"group" yaml:"group"`
	Name  string `json:"name" yaml:"name"`
	// Representation selects the rendering the alias refers to: "model"
	// (default) or "input". See PublicExportRepresentation.
	Representation PublicExportRepresentation `json:"representation,omitempty" yaml:"representation,omitempty"`
}

type PublicExportRepresentation string

type RateLimit struct {
	Strategy      string          `json:"strategy" yaml:"strategy"`
	SlidingWindow *WindowStrategy `json:"sliding_window" yaml:"sliding_window"`
	Identifier    string          `json:"identifier" yaml:"identifier"`
	Description   string          `json:"description" yaml:"description"`
}

type ReactHook struct {
	Disabled bool               `json:"disabled" yaml:"disabled"`
	Name     string             `json:"name" yaml:"name"`
	Type     string             `json:"type" yaml:"type"`
	QueryKey *ReactHookQueryKey `json:"queryKey" yaml:"queryKey"`
}

type ReactHookQueryKey struct {
	IncludeRequestBody bool `json:"includeRequestBody" yaml:"includeRequestBody"`
}

type Retries struct {
	Strategy              string           `json:"strategy" yaml:"strategy,omitempty"`
	DefaultApplied        bool             `json:"defaultApplied,omitempty" yaml:"defaultApplied,omitempty"`
	Disabled              *bool            `json:"disabled,omitempty" yaml:"disabled,omitempty"`
	Backoff               *BackoffStrategy `json:"backoff" yaml:"backoff,omitempty"`
	StatusCodes           []string         `json:"statusCodes" yaml:"statusCodes,omitempty"`
	RetryConnectionErrors *bool            `json:"retryConnectionErrors" yaml:"retryConnectionErrors,omitempty"`
	MaxRetries            *int             `json:"maxRetries" yaml:"maxRetries,omitempty"`
}

type SSEOverloadConfig struct {
	In   string // "body" | "query"
	Name string // resolved field name
}

type SSESentinel struct {
	DataValue string
}

type TerraformCustomDefault struct {
	// Go package imports required for the custom default.
	Imports []string `json:"imports" yaml:"imports"`

	// Code rendered into the schema to instantiate the custom default
	// implementation.
	SchemaDefinition string `json:"schemaDefinition" yaml:"schemaDefinition"`
}

type TerraformIgnore struct {
	// When enabled, the field will be ignored in Terraform data models.
	// Enabled when the ignore extension is set to true.
	DataModel bool `json:"dataModel" yaml:"dataModel"`

	// When enabled, the field will be ignored in Terraform schema definitions.
	// Enabled when the ignore extension is set to true.
	Schema bool `json:"schema" yaml:"schema"`
}

type TransformerConfig struct {
	Type   TransformerType
	Config string
}

type TransformerType string

type UsageExampleConfig struct {
	Title       string   `json:"title" yaml:"title,omitempty"`
	Description string   `json:"description" yaml:"description,omitempty"`
	Position    int      `json:"position" yaml:"position,omitempty"`
	Tags        []string `json:"tags" yaml:"tags,omitempty"`
}

type WebhookSecurity struct {
	// Valid values for this field are:
	//
	// * "signature" a configurable signature which respects header name, text encoding and algorithm
	//
	// * "custom" a custom signature down to the API producer to complete the implementation
	//
	// * "signatureStandardWebhooks" a preset which conforms to "Standard Webhooks" naming / guidance
	//
	// * "apiKey" an API key - no signing is performed
	Type string `json:"type" yaml:"type"`
	// Applicable when Type is "signature"
	HeaderName string `json:"headerName" yaml:"headerName,omitempty"`
	// Applicable when Type is "signature"
	SignatureTextEncoding string `json:"signatureTextEncoding" yaml:"signatureTextEncoding,omitempty"`
	// Applicable when Type is "signature"
	SignatureAlgorithm string `json:"algorithm" yaml:"algorithm,omitempty"`
	// ConsumerShouldProvideSecret is true if the webhook consumer should provide the secret - allows for "custom" type to override the default behavior
	ConsumerShouldProvideSecret *bool `json:"consumerShouldProvideSecret" yaml:"consumerShouldProvideSecret,omitempty"`
}

type Webhooks struct {
	// A WebhookSecurity object is used to configure the security for a webhook.
	Security *WebhookSecurity `json:"security" yaml:"security,omitempty"`
}

type WindowStrategy struct {
	Rate   int    `json:"rate" yaml:"rate"`
	Period string `json:"period" yaml:"period"`
}