client

type ClientResponseFunc = func(*http.Response) runtime.ClientResponse //nolint:revive

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

type Runtime struct {
	DefaultMediaType      string
	DefaultAuthentication runtime.ClientAuthInfoWriter
	Consumers             map[string]runtime.Consumer
	Producers             map[string]runtime.Producer

	Transport http.RoundTripper
	Jar       http.CookieJar
	// Spec      *spec.Document
	Host     string
	BasePath string
	Formats  strfmt.Registry
	// Deprecated: prefer [runtime.ContextualTransport.SubmitContext] to pass the request context explicitly.
	Context context.Context //nolint:containedctx  // we precisely want this type to contain the request context

	Debug bool

	// Trace enables connection-level diagnostic output via
	// [net/http/httptrace]. When true, the runtime narrates the
	// connection lifecycle of every request through r.logger.Debugf:
	// DNS, dial, TLS handshake, idle-pool reuse, request body
	// transfer, time-to-first-byte, response body transfer, and a
	// trailing per-request summary line.
	//
	// Trace is orthogonal to Debug: Debug dumps wire bytes (request
	// and response headers and body), Trace narrates how the
	// connection got there. Both may be enabled independently.
	//
	// Trace is not coupled to the SWAGGER_DEBUG / DEBUG environment
	// variables: it defaults to false and is only enabled by
	// explicit assignment.
	//
	// Trace is primarily intended as a problem-investigation tool
	// (the local equivalent of curl -vvv), not an always-on tracer.
	// For distributed-trace correlation, use the OpenTelemetry
	// integration ([Runtime.WithOpenTelemetry]).
	Trace bool

	// MatchSuffix enables RFC 6839 structured-syntax suffix tolerance
	// for codec lookup. When true, a response with Content-Type
	// "application/problem+json" finds the JSON consumer registered
	// under "application/json"; with the default false, the lookup
	// is strict and falls through to the "*/*" wildcard if present.
	// See [mediatype.AllowSuffix] for the semantics.
	MatchSuffix bool
	// contains filtered or unexported fields
}

type TLSClientOptions struct {
	// Certificate is the path to a PEM-encoded certificate to be used for
	// client authentication. If set then Key must also be set.
	Certificate string

	// LoadedCertificate is the certificate to be used for client authentication.
	// This field is ignored if Certificate is set. If this field is set, LoadedKey
	// is also required.
	LoadedCertificate *x509.Certificate

	// Key is the path to an unencrypted PEM-encoded private key for client
	// authentication. This field is required if Certificate is set.
	Key string

	// LoadedKey is the key for client authentication. This field is required if
	// LoadedCertificate is set.
	LoadedKey crypto.PrivateKey

	// CA is a path to a PEM-encoded certificate that specifies the root certificate
	// to use when validating the TLS certificate presented by the server. If this field
	// (and LoadedCA) is not set, the system certificate pool is used. This field is ignored if LoadedCA
	// is set.
	CA string

	// LoadedCA specifies the root certificate to use when validating the server's TLS certificate.
	// If this field (and CA) is not set, the system certificate pool is used.
	LoadedCA *x509.Certificate

	// LoadedCAPool specifies a pool of RootCAs to use when validating the server's TLS certificate.
	// If set, it will be combined with the other loaded certificates (see LoadedCA and CA).
	// If neither LoadedCA or CA is set, the provided pool will override the system
	// certificate pool.
	//
	// The caller must not use the supplied pool after calling TLSClientAuth.
	LoadedCAPool *x509.CertPool

	// ServerName specifies the hostname to use when verifying the server certificate.
	// If this field is set then InsecureSkipVerify will be ignored and treated as
	// false.
	ServerName string

	// InsecureSkipVerify controls whether the certificate chain and hostname presented
	// by the server are validated. If true, any certificate is accepted.
	InsecureSkipVerify bool

	// VerifyPeerCertificate, if not nil, is called after normal
	// certificate verification. It receives the raw ASN.1 certificates
	// provided by the peer and also any verified chains that normal processing found.
	// If it returns a non-nil error, the handshake is aborted and that error results.
	//
	// If normal verification fails then the handshake will abort before
	// considering this callback. If normal verification is disabled by
	// setting InsecureSkipVerify then this callback will be considered but
	// the verifiedChains argument will always be nil.
	VerifyPeerCertificate func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error

	// VerifyConnection, if not nil, is called after normal certificate
	// verification and after [TLSClientOptions.VerifyPeerCertificate] by either a TLS client or
	// server. It receives the [tls.ConnectionState] which may be inspected.
	//
	// Unlike VerifyPeerCertificate, this callback is invoked on every
	// connection, including resumed ones, making it suitable for checks
	// that must always apply (e.g. certificate pinning).
	//
	// If it returns a non-nil error, the handshake is aborted and that error results.
	VerifyConnection func(tls.ConnectionState) error

	// SessionTicketsDisabled may be set to true to disable session ticket and
	// PSK (resumption) support. Note that on clients, session ticket support is
	// also disabled if ClientSessionCache is nil.
	SessionTicketsDisabled bool

	// ClientSessionCache is a cache of ClientSessionState entries for TLS
	// session resumption. It is only used by clients.
	ClientSessionCache tls.ClientSessionCache
	// contains filtered or unexported fields
}