api

type APIOptions struct {
	Auth    func(*http.Request) error
	AuthJWT func(*http.Request) error
	// AuthMTLS is invoked for routes whose config declared auth: "mtls"
	// AFTER the basic securex.VerifyMTLS gate has accepted the request.
	// Use this hook to enforce deployment-specific issuer-label policy
	// (PIV/CAC/custom) using policy.SupportedIssuers. Returning a non-nil
	// error rejects the request with 401.
	AuthMTLS func(*http.Request, securex.MTLSPolicy) error
	// MTLSRuntimes holds the boot-constructed CRL/OCSP revocation checkers
	// and CAC/PIV certificate-policy verifier for every mtls route whose
	// config declares crl/ocsp/cac_piv/principal_mapping (L-51), keyed by
	// "METHOD /path". server_lib.go.tmpl's Serve constructs this map ONCE
	// at boot (mtlsx.CRLChecker/OCSPChecker hold response caches and make
	// network calls, so they must never be rebuilt per request) and passes
	// it straight through here. A nil map, or a route missing from it, is
	// the zero securex.MTLSRuntime{} -- "no CRL/OCSP/CAC-PIV enforcement
	// for this route" -- which is exactly pre-L-51 behavior, so this field
	// is fully backward compatible with hand-built APIOptions literals
	// (tests, custom entrypoints) that never set it.
	MTLSRuntimes map[string]securex.MTLSRuntime
	// AuthWebhook resolves a per-route HMAC secret keyed on the
	// WebhookPolicy.Name supplied at codegen. Returning (nil, err)
	// rejects the request with a generic 401 envelope before any
	// signature check. The generator wires server.go.tmpl to populate
	// this from rc.Security.Webhooks; consumers that supply their own
	// resolver (e.g. a Vault-backed lookup) pass it via
	// APIOptions{AuthWebhook: myFunc}.
	AuthWebhook func(name string) ([]byte, error)
	// CookieName is the name of the HttpOnly cookie carrying the session JWT
	// for routes with auth: "cookie". Empty falls back to "session" at
	// request time. Wired by server_lib from security.auth.cookie_name.
	CookieName string
	// CSRF, when non-nil, enforces signed double-submit CSRF tokens on
	// cookie-authenticated state-changing requests and powers the issuance
	// endpoint. Wired by server_lib from security.csrf.
	CSRF           *csrfx.Signer
	CSRFCookieName string
	CSRFHeaderName string
	// CSRFSessionID extracts the session identifier a token is bound to
	// (default: verified claims Subject).
	CSRFSessionID func(*http.Request) string
	GlobalRate    float64
	GlobalBurst   float64
}

type BadRequest = Error

type CatchAllServerInterface interface {
	HandleRoute(w http.ResponseWriter, r *http.Request, route RouteInfo, req any) (any, error)
}

type Claims struct {
	// AdditionalData Any extra claim data
	AdditionalData *map[string]interface{} `json:"additionalData,omitempty"`
	Roles          *[]Role                 `json:"roles,omitempty"`
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {
	// LoginUserWithBody request with any body
	LoginUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	LoginUser(ctx context.Context, body LoginUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// LogoutUser request
	LogoutUser(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCurrentUser request
	GetCurrentUser(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RefreshTokenWithBody request with any body
	RefreshTokenWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	RefreshToken(ctx context.Context, body RefreshTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RegisterUserWithBody request with any body
	RegisterUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	RegisterUser(ctx context.Context, body RegisterUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EchoWithBody request with any body
	EchoWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	Echo(ctx context.Context, body EchoJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListPets request
	ListPets(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePetWithBody request with any body
	CreatePetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreatePet(ctx context.Context, body CreatePetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ShowPetById request
	ShowPetById(ctx context.Context, petId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUsers request
	ListUsers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUserWithBody request with any body
	CreateUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateUser(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteUser request
	DeleteUser(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetUserById request
	GetUserById(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateUserWithBody request with any body
	UpdateUserWithBody(ctx context.Context, userId ID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateUser(ctx context.Context, userId ID, body UpdateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {
	// LoginUserWithBodyWithResponse request with any body
	LoginUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginUserResponse, error)

	LoginUserWithResponse(ctx context.Context, body LoginUserJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginUserResponse, error)

	// LogoutUserWithResponse request
	LogoutUserWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutUserResponse, error)

	// GetCurrentUserWithResponse request
	GetCurrentUserWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCurrentUserResponse, error)

	// RefreshTokenWithBodyWithResponse request with any body
	RefreshTokenWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RefreshTokenResponse, error)

	RefreshTokenWithResponse(ctx context.Context, body RefreshTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*RefreshTokenResponse, error)

	// RegisterUserWithBodyWithResponse request with any body
	RegisterUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterUserResponse, error)

	RegisterUserWithResponse(ctx context.Context, body RegisterUserJSONRequestBody, reqEditors ...RequestEditorFn) (*RegisterUserResponse, error)

	// EchoWithBodyWithResponse request with any body
	EchoWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*EchoResponse, error)

	EchoWithResponse(ctx context.Context, body EchoJSONRequestBody, reqEditors ...RequestEditorFn) (*EchoResponse, error)

	// ListPetsWithResponse request
	ListPetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListPetsResponse, error)

	// CreatePetWithBodyWithResponse request with any body
	CreatePetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreatePetResponse, error)

	CreatePetWithResponse(ctx context.Context, body CreatePetJSONRequestBody, reqEditors ...RequestEditorFn) (*CreatePetResponse, error)

	// ShowPetByIdWithResponse request
	ShowPetByIdWithResponse(ctx context.Context, petId ID, reqEditors ...RequestEditorFn) (*ShowPetByIdResponse, error)

	// ListUsersWithResponse request
	ListUsersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListUsersResponse, error)

	// CreateUserWithBodyWithResponse request with any body
	CreateUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	CreateUserWithResponse(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// DeleteUserWithResponse request
	DeleteUserWithResponse(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*DeleteUserResponse, error)

	// GetUserByIdWithResponse request
	GetUserByIdWithResponse(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*GetUserByIdResponse, error)

	// UpdateUserWithBodyWithResponse request with any body
	UpdateUserWithBodyWithResponse(ctx context.Context, userId ID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateUserResponse, error)

	UpdateUserWithResponse(ctx context.Context, userId ID, body UpdateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateUserResponse, error)
}

type Conflict = Error

type CreatePetJSONRequestBody = Pet

type CreatePetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Pet
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type CreateUserJSONRequestBody = Registration

type CreateUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON409      *Conflict
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type DeleteUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type EchoJSONRequestBody = EchoReq

type EchoMsg struct {
	Msg string `json:"msg"`
}

type EchoReq struct {
	Msg string `json:"msg"`
}

type EchoResp struct {
	Msg string `json:"msg"`
}

type EchoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EchoResp
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
}

type Error struct {
	// Error Error code
	Error string `json:"error"`

	// Id id for the Record
	Id *ID `json:"id,omitempty"`

	// Message Error message
	Message string `json:"message"`
}

type Forbidden = Error

type GeneratedServerInterface interface {
	Action(w http.ResponseWriter, r *http.Request, req *types.AdminActionReq) (*types.AdminActionResp, error)
	Metrics(w http.ResponseWriter, r *http.Request, req *types.AdminMetricsReq) (*types.AdminMetricsResp, error)
	Create(w http.ResponseWriter, r *http.Request, req *types.PostCreateReq) (*types.PostCreateResp, error)
	Search(w http.ResponseWriter, r *http.Request, req *types.PostSearchReq) (*types.PostSearchResp, error)
	Register(w http.ResponseWriter, r *http.Request, req *types.RegisterReq) (*types.RegisterResp, error)
	Update(w http.ResponseWriter, r *http.Request, req *types.UserUpdateReq) (*types.UserUpdateResp, error)
}

type GetCurrentUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type GetUserByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type GinServerOptions struct {
	BaseURL      string
	Middlewares  []MiddlewareFunc
	ErrorHandler func(*gin.Context, error, int)
}

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type ID = uuid.UUID

type InternalServerError = Error

type ListPetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Pet
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type ListUsersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type Login struct {
	// Password Password for authentication
	Password Password `` /* 137-byte string literal not displayed */

	// Username Username for authentication
	Username Username `json:"username" safe-to-log:"true" validate:"required,min=10,max=50,regexp=^(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]{10,50}$"`
}

type LoginUserJSONRequestBody = Login

type LoginUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Token
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type LogoutUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Message *string `json:"message,omitempty"`
	}
	JSON400     *BadRequest
	JSON401     *Unauthorized
	JSON429     *TooManyRequests
	JSON500     *InternalServerError
	JSONDefault *UnexpectedError
}

type MCPParams struct {
	Msg string `json:"msg"`
}

type MCPResult struct {
	Msg string `json:"msg"`
}

type MCPTool func(ctx context.Context, params jsontext.Value) (jsontext.Value, error)

type MiddlewareFunc func(c *gin.Context)

type NOOPHandlers struct{}

type NotFound = Error

type OAuth2Error struct {
	Code        string
	Description string
	URI         string
	Status      int
	Err         error
}

type OIDC struct {
	Issuer string `json:"issuer" validate:"required,url,max=255"`

	AuthZURL *url.URL
	TokenURL *url.URL
	UserURL  *url.URL

	LogoutURL      *url.URL
	IntrospectURL  *url.URL
	RevocationURL  *url.URL
	DeviceAuthzURL *url.URL

	JWKsURL *url.URL
	// JWKs holds the cold-start key set so legacy callers continue to
	// observe a non-nil reference. The authoritative, auto-refreshing
	// view lives behind jwkCache and is consulted on every JWT
	// validation path so IdP key rotation is picked up without a host
	// process restart (PERF-0043, SEC #150).
	JWKs jwk.Set

	Aud string

	ResponseTypes [][]string
	ResponseModes []string `json:"response_modes_supported"`
	GrantTypes    []string `json:"grant_types_supported"`

	SigningAlgos         []string `json:"id_token_signing_alg_values_supported"`
	SubjectTypes         []string `json:"subject_types_supported"`
	AuthMethods          []string `json:"token_endpoint_auth_methods_supported"`
	AcrValues            []string `json:"acr_values_supported"`
	Scopes               []string `json:"scopes_supported"`
	Claims               []string `json:"claims_supported"`
	CodeChallengeMethods []string `json:"code_challenge_methods_supported"`

	ClaimsParameters bool `json:"claims_parameter_supported"`
	RequestParameter bool `json:"request_parameter_supported"`
	// contains filtered or unexported fields
}

type Option func(*apiServer) error

type Password = string

type Pet struct {
	// Id id for the Record
	Id *ID `json:"id,omitempty"`

	// Name Name of the pet
	Name string `json:"name"`

	// Tag Tag or label for the pet
	Tag *string `json:"tag,omitempty"`
}

type RefreshTokenJSONBody struct {
	// RefreshToken JWT or similar token for refresh
	RefreshToken *string `json:"refreshToken,omitempty"`
}

type RefreshTokenJSONRequestBody RefreshTokenJSONBody

type RefreshTokenResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Token
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type Register func(*gin.Engine) error

type RegisterUserJSONRequestBody = Registration

type RegisterUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON409      *Conflict
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type Registration struct {
	// Password Password for authentication
	Password Password `` /* 137-byte string literal not displayed */

	// Username Username for authentication
	Username Username `json:"username" safe-to-log:"true" validate:"required,min=10,max=50,regexp=^(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]{10,50}$"`
}

type RequestEditorFn func(ctx context.Context, req *http.Request) error

type RequestResponsePair struct {
	// In a simple scenario, you can store literal bytes to compare against the read.
	// For real HTTP testing, you might parse or only compare a portion of the request.
	Request  []byte
	Response []byte
}

type Role string

type RouteInfo struct {
	Method             string
	Path               string
	MuxPattern         string
	MethodName         string
	BodyMode           string
	Auth               string
	Surface            string
	Sensitivity        string
	Profile            string
	RequestType        string
	ResponseType       string
	RequestSchema      string
	ResponseSchema     string
	HasTypedRequest    bool
	HasTypedResponse   bool
	PathParams         []string
	RequiredRoles      []string
	RequiredScopes     []string
	RequiredAttributes map[string]string
	// APPSEC-Gen-F-006: surface the per-route WebAuthn ceremony policy
	// (ceremony, phase, attestation, user_verification, discoverable)
	// so catch-all handlers can read it without re-parsing the config.
	Webauthn *WebauthnInfo
	// APPSEC-15 (Plan 02 follow-up): per-route mTLS CA bundle path so
	// catch-all handlers can construct their own per-route
	// mtlsx.Verifier. Empty when the operation declares no mtls block
	// or no ca_bundle_path. Server-construction-time wiring still
	// goes through api.WithMTLS for the listener.
	MTLSCABundlePath string
}

type Server interface {
	Serve(context.Context) error
}

type ServerInterface interface {
	// User login
	// (POST /v1/auth/login)
	LoginUser(c *gin.Context)
	// Logout user
	// (POST /v1/auth/logout)
	LogoutUser(c *gin.Context)
	// Get current user info
	// (GET /v1/auth/me)
	GetCurrentUser(c *gin.Context)
	// Refresh user token
	// (POST /v1/auth/refresh)
	RefreshToken(c *gin.Context)
	// User registration
	// (POST /v1/auth/register)
	RegisterUser(c *gin.Context)
	// Echo
	// (POST /v1/echo)
	Echo(c *gin.Context)
	// List all pets
	// (GET /v1/pets)
	ListPets(c *gin.Context)
	// Create a pet
	// (POST /v1/pets)
	CreatePet(c *gin.Context)
	// Show a specific pet
	// (GET /v1/pets/{petId})
	ShowPetById(c *gin.Context, petId ID)
	// List all users
	// (GET /v1/users)
	ListUsers(c *gin.Context)
	// Create a user
	// (POST /v1/users)
	CreateUser(c *gin.Context)
	// Delete a user
	// (DELETE /v1/users/{userId})
	DeleteUser(c *gin.Context, userId ID)
	// Get a specific user
	// (GET /v1/users/{userId})
	GetUserById(c *gin.Context, userId ID)
	// Update a specific user
	// (PATCH /v1/users/{userId})
	UpdateUser(c *gin.Context, userId ID)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandler       func(*gin.Context, error, int)
}

type ShowPetByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Pet
	JSON201      *Pet
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type StatusError struct {
	Code    int
	Message string
	Err     error
}

type TOKEN string

type TestConn struct{}

type TestListener struct {

	// Host and Port are just informational/logging in Addr().
	Host string
	Port uint16
	// contains filtered or unexported fields
}

type Token struct {
	// ExpiresIn Token expiration in seconds
	ExpiresIn *int64 `json:"expiresIn,omitempty"`

	// Token JWT or OAuth2 access token
	Token *string `json:"token,omitempty"`
}

type TooManyRequests = Error

type Unauthorized = Error

type UnexpectedError = Error

type UnimplementedServer struct{}

type UpdateUserJSONBody struct {
	// Password Password for authentication
	Password *Password `` /* 147-byte string literal not displayed */

	// Roles New roles to assign
	Roles *[]Role `json:"roles,omitempty"`
}

type UpdateUserJSONRequestBody UpdateUserJSONBody

type UpdateUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON400      *BadRequest
	JSON401      *Unauthorized
	JSON403      *Forbidden
	JSON404      *NotFound
	JSON429      *TooManyRequests
	JSON500      *InternalServerError
	JSONDefault  *UnexpectedError
}

type User struct {
	// Claims Additional claims for extended user profile or permissions
	Claims *Claims `json:"claims,omitempty"`

	// CreatedAt When the user was created
	CreatedAt time.Time `json:"createdAt"`

	// Id id for the Record
	Id    *ID    `json:"id,omitempty"`
	Roles []Role `json:"roles"`

	// UpdatedAt When the user was last updated
	UpdatedAt time.Time `json:"updatedAt"`

	// Username Username for authentication
	Username Username `json:"username" safe-to-log:"true" validate:"required,min=10,max=50,regexp=^(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]{10,50}$"`
}

type Username = string

type Validator interface {
	Valid() error
}

type WebauthnInfo struct {
	Ceremony                string
	Phase                   string
	Attestation             string
	AuthenticatorAttachment string
	UserVerification        string
	Discoverable            bool
}