marrow

type AndValue struct {
	Values []any
}

type ApiCallValue struct {
	Method  MethodName
	Url     any
	Body    any
	Headers Headers
}

type ApiLogsValue struct {
	Last int
}

type AuthScheme string

type AuthUsernamePasswordValue struct {
	Username any
	Password any
}

type AuthValue struct {
	Scheme AuthScheme
	Value  any
}

type BeforeAfter interface {
	When() When
	Runnable
}

type BodyPath string

type BodyReader func(body any) (any, error)

type BodyValue string

type Capture interface {
	Name() string
	Runnable
}

type CaptureError interface {
	Error
	Capture() Capture
	Values() []OperandValue
}

type ClaimValue interface {
	Name() string
	Value() any
}

type Columns map[string]any

type Context interface {
	// Host returns the currently tested API host
	Host() string
	// Vars returns the current Context variables
	//
	// the returned map is mutable but has no effect on the actual variables
	Vars() map[Var]any
	// Db returns a *sql.DB for the named database
	//
	// Note: when only one database is used by tests, the dbName can be ""
	Db(dbName string) *sql.DB
	// Ctx returns the go context.Context
	Ctx() gctx.Context
	// SetVar sets a variable in the context
	SetVar(Var, any)
	// ClearVars clears all variables in the context
	ClearVars()
	// CurrentEndpoint returns the current Endpoint being tested
	//
	// Note: may be nil if an endpoint not yet started
	CurrentEndpoint() Endpoint_
	// CurrentMethod returns the current Method being tested
	//
	// Note: may be nil if a method not yet started
	CurrentMethod() Method_
	// CurrentUrl returns the current URL for the current Endpoint
	CurrentUrl() string
	// CurrentRequest returns the current built request for a method
	//
	// Note: may be nil if the request has not yet been built
	CurrentRequest() *http.Request
	// CurrentResponse returns the current response for a method call
	//
	// Note: may be nil if the method has not yet been called
	CurrentResponse() *http.Response
	// CurrentBody returns the current unmarshalled response body for a method call
	//
	// Note: may be nil if the method has not yet been called or the response body was empty
	CurrentBody() any
	// DbInsert performs an insert into a database table
	//
	// Note: when only one database is used by tests, the dbName can be ""
	DbInsert(dbName string, tableName string, row Columns) error
	// DbExec executes a statement on a database
	//
	// Note: when only one database is used by tests, the dbName can be ""
	DbExec(dbName string, query string, args ...any) error
	// StoreCookie stores the cookie for later use
	StoreCookie(cookie *http.Cookie)
	// GetCookie returns a specific named cookie (or nil if that cookie has not been stored)
	GetCookie(name string) *http.Cookie
	// GetMockService returns a specific named mock service (or nil if that name is not registered)
	GetMockService(name string) service.MockedService
	// ClearMockServices clears all mock services
	ClearMockServices()
	// GetImage returns the named supporting image
	GetImage(name string) with.Image
	// GetApiImage returns the main api (i.e. api under test) image, or nil if not running against an image
	GetApiImage() with.ImageApi
	// Log outputs the args in the test output
	Log(args ...any)
	// DoRequest performs a http request (not as part of tests)
	DoRequest(req *http.Request) (*http.Response, error)
	// ResolveServiceValue resolves a service value
	//
	// example:
	//	ResolveServiceValue("mysql:username")
	// would resolve to the username setting on supporting image "mysql"
	//
	// all supporting images support "host", "port", "mport", "username" & "password"
	//
	// some services support additional settings, e.g. localstack supports "region", "accesskey", "secretkey", "sessiontoken" (and possibly "arn:<name>")
	ResolveServiceValue(v string) (string, bool)

	Listener(name string) Listener
	RegisterListener(name string, listener Listener)
	// contains filtered or unexported methods
}

type DefaultVarValue struct {
	Var   Var
	Value any
}

type Endpoint_ interface {
	common.Endpoint
	Runnable

	fmt.Stringer
	// contains filtered or unexported methods
}

type Env string

type Error interface {
	error
	Type() ErrorType
	Name() string
	Cause() error
	Unwrap() error
	TestFormat() string
	framing.Framed
}

type ErrorType int

type Events string

type EventsCount string

type Expectation interface {
	common.Expectation
	Runnable
	Met(ctx Context) (unmet error, err error)
	IsRequired() bool
}

type FirstValue struct {
	Value any
}

type FormMultipart struct {
	Parts []MultipartPart
}

type FormUrlEncoded struct {
	Values map[string]any
}

type FormatValue struct {
	Format string
	Args   []any
}

type Headers map[string]any

type ImageStartupInitializer interface {
	StartupInit(ctx Context) error
}

type ImageValue struct {
	Service string
	Tokens  []any
}

type JSON map[string]any

type JSONArray []any

type JsonPathValue struct {
	Value any
	Path  string
}

type JsonTraverseValue struct {
	Value any
	Steps []any
}

type JsonifyValue struct {
	Value any
}

type LastValue struct {
	Value any
}

type LenValue struct {
	Value any
}

type Listener interface {
	Events() []any
	EventsCount() int
	Clear()
	Stop()
}

type MethodCaptures interface {
	// SetVar sets a variable in the current Context
	SetVar(when When, name any, value any) Method_
	// ClearVars clears all variables in the current Context
	ClearVars(when When) Method_
	// DbInsert performs an insert into a database table
	//
	// Note: when only one database is used by tests, the dbName can be ""
	DbInsert(when When, dbName string, tableName string, row Columns) Method_
	// DbExec executes a statement on a database
	//
	// Note: when only one database is used by tests, the dbName can be ""
	DbExec(when When, dbName string, query string, args ...any) Method_
	// DbClearTables clears table(s) in a database
	//
	// Note: when only one database is used by tests, the dbName can be ""
	DbClearTables(when When, dbName string, tableNames ...string) Method_
	// Wait wait a specified milliseconds
	//
	// Note: the wait time is not included in the coverage timings
	Wait(when When, ms int) Method_
	// WaitFor waits for a specified condition to be met
	//
	// Notes:
	//   * the condition arg can be a bool value (or value that resolves to a bool) or an Expectation (e.g. ExpectEqual, ExpectNotEqual, etc.)
	//   * if the condition arg is an Expectation, and the expectation is unmet, this does not report a failure or unmet, instead the condition is re-evaluated until maxTime is exceeded
	//   * any condition that is not a bool or Expectation will cause an error during tests
	//
	// delays specifies the durations to wait on each poll cycle...
	//   * if not delays specified, there is no initial delay and polls occur every 250ms
	//   * if only one delay specified, there is no initial delay and polls occur at that specified duration
	//   * if more than one delay is specified, the initial delay is the first duration and subsequent poll delays are the remaining durations
	WaitFor(when When, condition any, maxTime time.Duration, delays ...time.Duration) Method_
	// Do adds before/after operations
	Do(ops ...BeforeAfter) Method_
	// Capture adds a before/after operations
	Capture(when When, ops ...Runnable) Method_
	// CaptureFunc adds the provided func(s) as a before/after operation
	CaptureFunc(when When, fns ...func(Context) error) Method_

	// MockServicesClearAll clears all mock services
	MockServicesClearAll(when When) Method_
	// MockServiceClear clears a specific named mock service
	MockServiceClear(when When, svcName string) Method_
	// MockServiceCall sets up a mock response on a specific named mock service
	MockServiceCall(svcName string, path string, method MethodName, responseStatus int, responseBody any, headers ...any) Method_
}

type MethodExpectations interface {
	// Expect adds expectations to the Method_
	Expect(expectations ...Expectation) Method_

	// AssertOK asserts the response status code is 200 "OK"
	AssertOK() Method_
	// AssertCreated asserts the response status code is 201 "Created"
	AssertCreated() Method_
	// AssertAccepted asserts the response status code is 202 "Accepted"
	AssertAccepted() Method_
	// AssertNoContent asserts the response status code is 204 "No Content"
	AssertNoContent() Method_
	// AssertBadRequest asserts the response status code is 400 "Bad Request"
	AssertBadRequest() Method_
	// AssertUnauthorized asserts the response status code is 401 "Unauthorized"
	AssertUnauthorized() Method_
	// AssertForbidden asserts the response status code is 403 "Forbidden"
	AssertForbidden() Method_
	// AssertNotFound asserts the response status code is 404 "Not Found"
	AssertNotFound() Method_
	// AssertConflict asserts the response status code is 409 "Conflict"
	AssertConflict() Method_
	// AssertGone asserts the response status code is 410 "Gone"
	AssertGone() Method_
	// AssertUnprocessableEntity asserts the response status code is 422 "Unprocessable Entity"
	AssertUnprocessableEntity() Method_
	// AssertStatus asserts the response status code is the status supplied
	AssertStatus(status any) Method_
	// AssertFunc asserts that the supplied func is met
	AssertFunc(fn func(Context) (unmet error, err error)) Method_
	// AssertEqual asserts that the supplied values are equal
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertEqual(v1, v2 any) Method_
	// AssertNotEqual asserts that the supplied values are not equal
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertNotEqual(v1, v2 any) Method_
	// AssertLessThan asserts that v1 is less than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertLessThan(v1, v2 any) Method_
	// AssertLessThanOrEqual asserts that v1 is less than or equal to v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertLessThanOrEqual(v1, v2 any) Method_
	// AssertGreaterThan asserts that v1 is greater than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertGreaterThan(v1, v2 any) Method_
	// AssertGreaterThanOrEqual asserts that v1 is greater than or equal to v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertGreaterThanOrEqual(v1, v2 any) Method_
	// AssertNotLessThan asserts that v1 is not less than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertNotLessThan(v1, v2 any) Method_
	// AssertNotGreaterThan asserts that v1 is not greater than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertNotGreaterThan(v1, v2 any) Method_
	// AssertMatch asserts that the value matches the supplied regex
	//
	// when attempting to match against the regex, the value (or resolved value) is "stringified"
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	AssertMatch(value any, regex string) Method_
	// AssertContains asserts that the value contains a substring
	//
	// when attempting to check contains, the value (or resolved value) is "stringified"
	AssertContains(value any, s string) Method_
	// AssertType asserts that the value (or resolved value) is of the supplied type
	AssertType(value any, typ Type_) Method_
	// AssertNil asserts that the value (or resolved value) is nil
	AssertNil(value any) Method_
	// AssertNotNil asserts that the value (or resolved value) is not nil
	AssertNotNil(value any) Method_
	// AssertLen asserts that the value (or resolved value) has the supplied length
	//
	// the value (or resolved value) must be a string, map or slice
	AssertLen(value any, length int) Method_
	// AssertHasProperties asserts that the value (or resolved value) has the supplied properties
	//
	// the value (or resolved value) must be a map
	AssertHasProperties(value any, propertyNames ...string) Method_
	// AssertOnlyHasProperties asserts that the value (or resolved value) only has the supplied properties
	//
	// the value (or resolved value) must be a map
	AssertOnlyHasProperties(value any, propertyNames ...string) Method_

	// RequireOK requires the response status code is 200 "OK"
	RequireOK() Method_
	// RequireCreated requires the response status code is 201 "Created"
	RequireCreated() Method_
	// RequireAccepted requires the response status code is 202 "Accepted"
	RequireAccepted() Method_
	// RequireNoContent requires the response status code is 204 "No Content"
	RequireNoContent() Method_
	// RequireBadRequest requires the response status code is 400 "Bad Request"
	RequireBadRequest() Method_
	// RequireUnauthorized requires the response status code is 401 "Unauthorized"
	RequireUnauthorized() Method_
	// RequireForbidden requires the response status code is 403 "Forbidden"
	RequireForbidden() Method_
	// RequireNotFound requires the response status code is 404 "Not Found"
	RequireNotFound() Method_
	// RequireConflict requires the response status code is 409 "Conflict"
	RequireConflict() Method_
	// RequireGone requires the response status code is 410 "Gone"
	RequireGone() Method_
	// RequireUnprocessableEntity requires the response status code is 422 "Unprocessable Entity"
	RequireUnprocessableEntity() Method_
	// RequireStatus requires the response status code is the status supplied
	RequireStatus(status any) Method_
	// RequireFunc requires that the supplied func is met
	RequireFunc(fn func(Context) (unmet error, err error)) Method_
	// RequireEqual requires that the supplied values are equal
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireEqual(v1, v2 any) Method_
	// RequireNotEqual requires that the supplied values are not equal
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireNotEqual(v1, v2 any) Method_
	// RequireLessThan requires that v1 is less than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireLessThan(v1, v2 any) Method_
	// RequireLessThanOrEqual requires that v1 is less than or equal to v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireLessThanOrEqual(v1, v2 any) Method_
	// RequireGreaterThan requires that v1 is greater than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireGreaterThan(v1, v2 any) Method_
	// RequireGreaterThanOrEqual requires that v1 is greater than or equal to v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireGreaterThanOrEqual(v1, v2 any) Method_
	// RequireNotLessThan requires that v1 is not less than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireNotLessThan(v1, v2 any) Method_
	// RequireNotGreaterThan requires that v1 is not greater than v2
	//
	// values can be any of:
	//  * primitive type of string, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireNotGreaterThan(v1, v2 any) Method_
	// RequireMatch requires that the value matches the supplied regex
	//
	// when attempting to match against the regex, the value (or resolved value) is "stringified"
	//
	// values can be any of:
	//  * primitive type of string, bool, int, int64, float64
	//  * decimal.Decimal
	//  * or anything that is resolvable...
	//
	// examples of resolvable values are: Var, Body, BodyPath, Query, QueryRows, JsonPath, JsonTraverse,
	// StatusCode, ResponseCookie, ResponseHeader, JSON, JSONArray, TemplateString,
	RequireMatch(value any, regex string) Method_
	// RequireContains requires that the value contains a substring
	//
	// when attempting to check contains, the value (or resolved value) is "stringified"
	RequireContains(value any, s string) Method_
	// RequireType requires that the value (or resolved value) is of the supplied type
	RequireType(value any, typ Type_) Method_
	// RequireNil requires that the value (or resolved value) is nil
	RequireNil(value any) Method_
	// RequireNotNil requires that the value (or resolved value) is not nil
	RequireNotNil(value any) Method_
	// RequireLen requires that the value (or resolved value) has the supplied length
	//
	// the value (or resolved value) must be a string, map or slice
	RequireLen(value any, length int) Method_
	// RequireHasProperties requires that the value (or resolved value) has the supplied properties
	//
	// the value (or resolved value) must be a map
	RequireHasProperties(value any, propertyNames ...string) Method_
	// RequireOnlyHasProperties requires that the value (or resolved value) only has the supplied properties
	//
	// the value (or resolved value) must be a map
	RequireOnlyHasProperties(value any, propertyNames ...string) Method_

	// AssertMockServiceCalled asserts that a specific mock service endpoint+method was called
	AssertMockServiceCalled(svcName string, path string, method MethodName) Method_
	// RequireMockServiceCalled requires that a specific mock service endpoint+method was called
	RequireMockServiceCalled(svcName string, path string, method MethodName) Method_

	// AssertVarSet asserts that a named variable has been set
	AssertVarSet(v Var) Method_
	// RequireVarSet requires that a named variable has been set
	RequireVarSet(v Var) Method_

	// AssertTrue asserts that the value is true
	//
	// the value (or resolved value) must be a bool, otherwise this fails
	//
	// the value can also be an Expectation (e.g. ExpectEqual) - in which case the boolean is evaluated based on that
	// expectation being met
	AssertTrue(value any) Method_
	// RequireTrue requires that the value is true
	//
	// the value (or resolved value) must be a bool, otherwise this fails
	//
	// the value can also be an Expectation (e.g. ExpectEqual) - in which case the boolean is evaluated based on that
	// expectation being met
	RequireTrue(value any) Method_
	// AssertFalse asserts that the value is false
	//
	// the value (or resolved value) must be a bool, otherwise this fails
	//
	// the value can also be an Expectation (e.g. ExpectEqual) - in which case the boolean is evaluated based on that
	// expectation being unmet
	AssertFalse(value any) Method_
	// RequireFalse requires that the value is false
	//
	// the value (or resolved value) must be a bool, otherwise this fails
	//
	// the value can also be an Expectation (e.g. ExpectEqual) - in which case the boolean is evaluated based on that
	// expectation being unmet
	RequireFalse(value any) Method_
}

type MethodName string

type Method_ interface {
	common.Method

	// QueryParam sets a http query param to value(s) for the method call
	QueryParam(name string, values ...any) Method_
	// PathParam sets a URL path param for the method call
	//
	// path params are specified in the order in which they appear in the url template
	PathParam(value any) Method_
	// RequestHeader sets a http header for the method call
	RequestHeader(name string, value any) Method_
	// AuthHeader sets the "Authorization" header for the method call
	AuthHeader(scheme AuthScheme, value any) Method_
	// RequestBody sets the http request body for the method call
	RequestBody(value any) Method_
	// UseCookie sets a named cookie to use on the method call
	//
	// the named cookie has to have been previously stored in the Context
	UseCookie(name string) Method_
	// SetCookie sets a cookie to be used for the method call
	SetCookie(cookie *http.Cookie) Method_
	// StoreCookie stores a named cookie from the response in the Context
	StoreCookie(name string) Method_
	// Authorize provides a function that can be used to authorize a http request
	//
	// the func is passed the current Context, and can obtain the built request using Context.CurrentRequest and manipulate it
	//
	// Notes:
	//  * multiple authorize functions can be added.
	//  * authorize functions are called after pre-captures (i.e. Before's) and after the request has been built
	Authorize(func(ctx Context) error) Method_

	MethodExpectations
	MethodCaptures

	// If runs the operations when the condition arg is met
	//
	// Notes:
	//   * the condition arg can be a bool value (or value that resolves to a bool) or an Expectation (e.g. ExpectEqual, ExpectNotEqual, etc.)
	//   * if the condition arg is an Expectation, and the expectation is unmet, this does not report a failure or unmet, instead the operations are just not performed
	//   * any condition that is not a bool or Expectation will cause an error during tests
	//   * the operations arg can be anything Runnable - any of them that are an Expectation, is run as an expectation (and treated as required) and any unmet or failure errors will be reported
	If(when When, condition any, operations ...Runnable) Method_
	// IfNot runs the operations when the condition arg is not met
	//
	// Notes:
	//   * the condition arg can be a bool value (or value that resolves to a bool) or an Expectation (e.g. ExpectEqual, ExpectNotEqual, etc.)
	//   * if the condition arg is an Expectation, and the expectation is unmet, this does not report a failure or unmet, instead the operations are just not performed
	//   * any condition that is not a bool or Expectation will cause an error during tests
	//   * the operations arg can be anything Runnable - any of them that are an Expectation, is run as an expectation (and treated as required) and any unmet or failure errors will be reported
	IfNot(when When, condition any, operations ...Runnable) Method_
	// ForEach iterates over the value (or resolved value)
	//
	// if the value (or resolved value) is not a slice - an error occurs
	//
	// on each iteration a var is set - use the iterVar arg to set the name of this variable (if the iterVar arg is nil - a var name of "." is used)
	ForEach(when When, value any, iterVar any, ops ...Runnable) Method_

	// FailFast instructs the method to fail on unmet assertions
	//
	// i.e. treat all `Assert...()` as `Require...()`
	FailFast() Method_

	// RequestMarshal provides an override function to build (marshal) the request body
	//
	// only one func is used, so if this is called multiple times - last one wins
	RequestMarshal(fn func(ctx Context, body any) ([]byte, error)) Method_
	// ResponseUnmarshal provides an override function to unmarshal the response body
	//
	// only one func is used, so if this is called multiple times - last one wins
	ResponseUnmarshal(fn func(response *http.Response) (any, error)) Method_
	Runnable
	fmt.Stringer
}

type MultipartField struct {
	Name  string
	Value any
}

type MultipartFile struct {
	FieldName   string
	FileName    string
	Source      any
	ContentType string
}

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

type NthValue struct {
	Value any
	Index int
}

type OperandValue struct {
	Original      any
	Resolved      any
	Coerced       any
	CoercionError error
}

type OrValue struct {
	Values []any
}

type QueryRowsValue struct {
	DbName string
	Query  string
	Args   []any
}

type QueryValue struct {
	DbName string
	Query  string
	Args   []any
}

type RawQuery string

type Resolvable interface {
	ResolveValue(ctx Context) (av any, err error)
}

type ResponseCookie string

type ResponseHeader string

type Runnable interface {
	Run(ctx Context) error
	framing.Framed
}

type Status int

type StatusCode int

type Suite_ interface {
	// Init initializes the Suite using the provided withs
	//
	// a with can be from any provided by the [with] package -
	// with.ApiImage, with.Make, with.Database, with.HttpDo, with.ApiHost, with.Testing, with.Var, with.Cookie, with.ReportCoverage, with.CoverageCollector, with.OAS, with.Repeats, with.Logging
	//
	// a with can also be supporting image - see [images] package
	//
	// Note: Init takes a clone of the Suite, so that multiple runners with independent initialisation can be run from the same test endpoint definitions
	Init(withs ...with.With) Suite_
	// Run runs the test suite
	//
	// only critical errors are returned - unmet expectations are not (use coverage to inspect test failures and unmet expectations)
	Run() error
}

type TemplateString string

type Type_ interface {
	Type() reflect.Type
}

type UnmetError interface {
	Error
	Expected() OperandValue
	Actual() OperandValue
	IsComparator() bool
	Comparator() string
	Left() OperandValue
	Right() OperandValue
}

type Var string

type When int